Publish

- now@16.1.4-canary.6
 - @now/go@0.5.11-canary.4
 - @now/node@1.0.0-canary.5
 - @now/ruby@0.1.5-canary.3

.circleci/config.yml

@@ -0,0 +1,490 @@
+version: 2
+jobs:
+  install:
+    docker:
+      - image: circleci/node:10
+    working_directory: ~/repo
+    environment:
+      GOPATH: $HOME/go
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "yarn.lock" }}
+            # fallback to using the latest cache if no exact match is found
+            - v1-dependencies-
+      - run:
+          name: Updating apt packages
+          command: sudo apt-get update
+      - run:
+          name: Installing the latest version of Go
+          command: sudo apt-get install golang-go
+      - run:
+          name: Installing Dependencies
+          command: yarn install --check-files --frozen-lockfile
+      - save_cache:
+          paths:
+            - node_modules
+            - packages/gatsby-plugin-now/node_modules
+            - packages/now-build-utils/node_modules
+            - packages/now-cgi/node_modules
+            - packages/now-cli/node_modules
+            - packages/now-client/node_modules
+            - packages/now-go/node_modules
+            - packages/now-next/node_modules
+            - packages/now-node/node_modules
+            - packages/now-node-bridge/node_modules
+            - packages/now-python/node_modules
+            - packages/now-routing-utils/node_modules
+            - packages/now-ruby/node_modules
+            - packages/now-static-build/node_modules
+          key: v1-dependencies-{{ checksum "yarn.lock" }}
+      - persist_to_workspace:
+          root: .
+          paths:
+            - node_modules
+            - packages/gatsby-plugin-now/node_modules
+            - packages/now-build-utils/node_modules
+            - packages/now-cgi/node_modules
+            - packages/now-cli/node_modules
+            - packages/now-client/node_modules
+            - packages/now-go/node_modules
+            - packages/now-next/node_modules
+            - packages/now-node/node_modules
+            - packages/now-node-bridge/node_modules
+            - packages/now-python/node_modules
+            - packages/now-routing-utils/node_modules
+            - packages/now-ruby/node_modules
+            - packages/now-static-build/node_modules
+
+  build:
+    docker:
+      - image: circleci/node:10
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - run:
+          name: Installing apt dependencies
+          command: sudo apt install -y rsync
+      - attach_workspace:
+          at: .
+      - run:
+          name: Linking dependencies
+          command: yarn bootstrap
+      - run:
+          name: Building
+          command: yarn build
+      - store_artifacts:
+          path: packages/now-cli/dist
+      - persist_to_workspace:
+          root: .
+          paths:
+            - packages/gatsby-plugin-now/test/fixtures
+            - packages/now-build-utils/dist
+            - packages/now-cgi/dist
+            - packages/now-cli/dist
+            - packages/now-cli/assets
+            - packages/now-client/dist
+            - packages/now-go/dist
+            - packages/now-next/dist
+            - packages/now-node/dist
+            - packages/now-node/test/fixtures/15-helpers/ts/types.d.ts
+            - packages/now-node/test/fixtures/11-symlinks/symlink
+            - packages/now-node-bridge/index.js
+            - packages/now-node-bridge/bridge.js
+            - packages/now-python/dist
+            - packages/now-routing-utils/dist
+            - packages/now-ruby/dist
+            - packages/now-static-build/dist
+            - packages/now-static-build/test/fixtures/10a-gatsby-redirects/plugins
+
+  test-lint:
+    docker:
+      - image: circleci/node:10
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Compiling `now dev` HTML error templates
+          command: node packages/now-cli/scripts/compile-templates.js
+      - run:
+          name: Linting Code
+          command: yarn test-lint
+
+  test-integration-macos-node-8:
+    macos:
+      xcode: '9.2.0'
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Update Node.js
+          command: curl -sfLS install-node.now.sh/8.11 | sh -s -- --yes
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Running Integration Tests
+          command: yarn test-integration --clean false
+
+  test-integration-macos-node-10:
+    macos:
+      xcode: '10.0.0'
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Running Integration Tests
+          command: yarn test-integration --clean false
+
+  test-integration-macos-node-12:
+    macos:
+      xcode: '10.3.0'
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Running Integration Tests
+          command: yarn test-integration --clean false
+
+  test-integration-linux-node-8:
+    docker:
+      - image: circleci/node:8
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Running Integration Tests
+          command: yarn test-integration --clean false
+
+  test-integration-linux-node-10:
+    docker:
+      - image: circleci/node:10
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Running Integration Tests
+          command: yarn test-integration --clean false
+
+  test-integration-linux-node-12:
+    docker:
+      - image: circleci/node:12
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Running Integration Tests
+          command: yarn test-integration --clean false
+
+  test-integration-macos-now-dev-node-8:
+    macos:
+      xcode: '9.2.0'
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Update Node.js
+          command: curl -sfLS install-node.now.sh/8.11 | sh -s -- --yes
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Downloading Hugo
+          command: curl -L -O https://github.com/gohugoio/hugo/releases/download/v0.56.0/hugo_0.56.0_macOS-64bit.tar.gz && tar -xzf hugo_0.56.0_macOS-64bit.tar.gz && mv ./hugo packages/now-cli/test/dev/fixtures/08-hugo/
+      - run:
+          name: Running Integration Tests for `now dev`
+          command: yarn test-integration-now-dev --clean false
+
+  test-integration-macos-now-dev-node-10:
+    macos:
+      xcode: '10.0.0'
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Downloading Hugo
+          command: curl -L -O https://github.com/gohugoio/hugo/releases/download/v0.56.0/hugo_0.56.0_macOS-64bit.tar.gz && tar -xzf hugo_0.56.0_macOS-64bit.tar.gz && mv ./hugo packages/now-cli/test/dev/fixtures/08-hugo/
+      - run:
+          name: Running Integration Tests for `now dev`
+          command: yarn test-integration-now-dev --clean false
+
+  test-integration-macos-now-dev-node-12:
+    macos:
+      xcode: '10.3.0'
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Downloading Hugo
+          command: curl -L -O https://github.com/gohugoio/hugo/releases/download/v0.56.0/hugo_0.56.0_macOS-64bit.tar.gz && tar -xzf hugo_0.56.0_macOS-64bit.tar.gz && mv ./hugo packages/now-cli/test/dev/fixtures/08-hugo/
+      - run:
+          name: Running Integration Tests for `now dev`
+          command: yarn test-integration-now-dev --clean false
+
+  test-integration-linux-now-dev-node-8:
+    docker:
+      - image: circleci/node:8
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Downloading Hugo
+          command: curl -L -O https://github.com/gohugoio/hugo/releases/download/v0.55.6/hugo_0.55.6_Linux-64bit.tar.gz && tar -xzf hugo_0.55.6_Linux-64bit.tar.gz && mv ./hugo packages/now-cli/test/dev/fixtures/08-hugo/
+      - run:
+          name: Running Integration Tests for `now dev`
+          command: yarn test-integration-now-dev --clean false
+
+  test-integration-linux-now-dev-node-10:
+    docker:
+      - image: circleci/node:10
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Downloading Hugo
+          command: curl -L -O https://github.com/gohugoio/hugo/releases/download/v0.55.6/hugo_0.55.6_Linux-64bit.tar.gz && tar -xzf hugo_0.55.6_Linux-64bit.tar.gz && mv ./hugo packages/now-cli/test/dev/fixtures/08-hugo/
+      - run:
+          name: Running Integration Tests for `now dev`
+          command: yarn test-integration-now-dev --clean false
+
+  test-integration-linux-now-dev-node-12:
+    docker:
+      - image: circleci/node:12
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Downloading Hugo
+          command: curl -L -O https://github.com/gohugoio/hugo/releases/download/v0.55.6/hugo_0.55.6_Linux-64bit.tar.gz && tar -xzf hugo_0.55.6_Linux-64bit.tar.gz && mv ./hugo packages/now-cli/test/dev/fixtures/08-hugo/
+      - run:
+          name: Running Integration Tests for `now dev`
+          command: yarn test-integration-now-dev --clean false
+
+  test-integration-once:
+    docker:
+      - image: circleci/node:10
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Output version
+          command: node --version
+      - run:
+          name: Running Integration Tests Once
+          command: yarn test-integration-once --clean false
+
+  coverage:
+    docker:
+      - image: circleci/node:10
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Compiling `now dev` HTML error templates
+          command: node packages/now-cli/scripts/compile-templates.js
+      - run:
+          name: Run unit tests
+          command: yarn workspace now run test-unit
+      - run:
+          name: Run coverage report
+          command: yarn workspace now run coverage
+
+  source-maps:
+    docker:
+      - image: circleci/node:10
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Installing Sentry CLI
+          command: npm install -g @sentry/cli
+      - run:
+          name: Creating a New Sentry Release
+          command: sentry-cli releases new now-cli@`git describe --tags`
+      - run:
+          name: Upload Sourcemap Files
+          command: sentry-cli releases files now-cli@`git describe --tags` upload-sourcemaps ./dist
+      - run:
+          name: Finalize Sentry Release
+          command: sentry-cli releases finalize now-cli@`git describe --tags`
+
+workflows:
+  version: 2
+  unscheduled:
+    jobs:
+      - install:
+          filters:
+            tags:
+              only: /.*/
+      - build:
+          requires:
+            - install
+          filters:
+            tags:
+              only: /.*/
+      - test-lint:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-macos-node-8:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-macos-node-10:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-macos-node-12:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-linux-node-8:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-linux-node-10:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-linux-node-12:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-macos-now-dev-node-8:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-macos-now-dev-node-10:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-macos-now-dev-node-12:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-linux-now-dev-node-8:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-linux-now-dev-node-10:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-linux-now-dev-node-12:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - test-integration-once:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+      - coverage:
+          requires:
+            - test-integration-macos-node-8
+            - test-integration-macos-node-10
+            - test-integration-macos-node-12
+            - test-integration-linux-node-8
+            - test-integration-linux-node-10
+            - test-integration-linux-node-12
+            - test-integration-macos-now-dev-node-8
+            - test-integration-macos-now-dev-node-10
+            - test-integration-macos-now-dev-node-12
+            - test-integration-linux-now-dev-node-8
+            - test-integration-linux-now-dev-node-10
+            - test-integration-linux-now-dev-node-12
+            - test-integration-once
+            - test-lint
+          filters:
+            tags:
+              only: /.*/

.circleci/publish.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+set -euo pipefail
+
+if [ -z "$NPM_TOKEN" ]; then
+  echo "NPM_TOKEN not found. Did you forget to assign the GitHub Action secret?"
+  exit 1
+fi
+
+echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
+
+if [ ! -e ~/.npmrc ]; then
+  echo "~/.npmrc file does not exist, skipping publish"
+  exit 0
+fi
+
+npm_tag=""
+tag="$(git describe --tags --exact-match 2> /dev/null || :)"
+
+if [ -z "$tag" ]; then
+  echo "Not a tagged commit, skipping publish"
+  exit 0
+fi
+
+if [[ "$tag" =~ -canary ]]; then
+  echo "Publishing canary release"
+  npm_tag="--npm-tag canary"
+else
+  echo "Publishing stable release"
+fi
+
+# Sometimes this is a false alarm and blocks publish
+git checkout yarn.lock
+
+yarn run lerna publish from-git $npm_tag --yes

.editorconfig

@@ -0,0 +1,37 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+tab_width = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[{*.json,*.json.example,*.gyp,*.yml,*.yaml}]
+indent_style = space
+indent_size = 2
+
+[{*.py,*.asm}]
+indent_style = space
+
+[*.py]
+indent_size = 4
+
+[*.asm]
+indent_size = 8
+
+[*.md]
+trim_trailing_whitespace = false
+
+# Ideal settings - some plugins might support these.
+[*.js]
+quote_type = single
+
+[{*.c,*.cc,*.h,*.hh,*.cpp,*.hpp,*.m,*.mm,*.mpp,*.js,*.java,*.go,*.rs,*.php,*.ng,*.jsx,*.ts,*.d,*.cs,*.swift}]
+curly_bracket_next_line = false
+spaces_around_operators = true
+spaces_around_brackets = outside
+# close enough to 1TB
+indent_brace_style = K&R

.eslintignore

@@ -0,0 +1,32 @@
+node_modules
+dist
+
+# gatsby-plugin-now
+packages/gatsby-plugin-now/test/fixtures
+
+# now-cli
+packages/now-cli/@types
+packages/now-cli/download
+packages/now-cli/dist
+packages/now-cli/test/fixtures
+packages/now-cli/test/dev/fixtures
+packages/now-cli/bin
+packages/now-cli/link
+packages/now-cli/src/util/dev/templates/*.ts
+
+# now-client
+packages/now-client/tests/fixtures
+packages/now-client/lib
+
+# now-next
+packages/now-next/test/fixtures
+
+# now-node
+packages/now-node/src/bridge.ts
+packages/now-node/test/fixtures
+
+# now-node-bridge
+packages/now-node-bridge/bridge.*
+
+# now-static-build
+packages/now-static-build/test/fixtures

.eslintrc.json

@@ -0,0 +1,64 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "module",
+    "modules": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier",
+    "prettier/@typescript-eslint"
+  ],
+  "env": {
+    "node": true,
+    "jest": true,
+    "es6": true
+  },
+  "rules": {
+    "require-atomic-updates": 0,
+    "@typescript-eslint/ban-ts-ignore": 0,
+    "@typescript-eslint/camelcase": 0,
+    "@typescript-eslint/explicit-function-return-type": 0,
+    "@typescript-eslint/no-empty-function": 0,
+    "@typescript-eslint/no-use-before-define": 0
+  },
+  "overrides": [
+    {
+      "files": ["**/*.js"],
+      "rules": {
+        "@typescript-eslint/no-var-requires": "off"
+      }
+    },
+    {
+      "files": ["packages/now-cli/**/*"],
+      "rules": {
+        "lines-between-class-members": 0,
+        "no-async-promise-executor": 0,
+        "no-control-regex": 0,
+        "no-empty": 0,
+        "prefer-const": 0,
+        "prefer-destructuring": 0,
+        "@typescript-eslint/ban-types": 0,
+        "@typescript-eslint/consistent-type-assertions": 0,
+        "@typescript-eslint/member-delimiter-style": 0,
+        "@typescript-eslint/no-empty-function": 0,
+        "@typescript-eslint/no-explicit-any": 0,
+        "@typescript-eslint/no-inferrable-types": 0,
+        "@typescript-eslint/no-var-requires": 0
+      }
+    },
+    {
+      "files": ["packages/now-client/**/*"],
+      "rules": {
+        "prefer-const": 0,
+        "require-atomic-updates": 0,
+        "@typescript-eslint/ban-ts-ignore": 0,
+        "@typescript-eslint/no-explicit-any": 0
+      }
+    }
+  ]
+}

.gitattributes

@@ -0,0 +1,3 @@
+# Ignore test fixtures in GitHub Languages
+# See https://github.com/github/linguist#vendored-code
+packages/*/test/* linguist-vendored

.github/CODEOWNERS

@@ -0,0 +1,18 @@
+# Documentation
+# https://help.github.com/en/articles/about-code-owners
+
+*                                        @tootallnate @leo
+/packages/now-cli/src/commands/dev/      @tootallnate @leo @styfle @AndyBitz
+/packages/now-cli/src/util/dev/          @tootallnate @leo @styfle @AndyBitz
+/packages/now-cli/src/commands/domains/  @javivelasco @mglagola @anatrajkovska
+/packages/now-cli/src/commands/certs/    @javivelasco @mglagola @anatrajkovska
+/packages/now-client                     @leo @rdev
+/packages/now-build-utils                @styfle @AndyBitz
+/packages/now-node                       @styfle @tootallnate @lucleray
+/packages/now-node-bridge                @styfle @tootallnate @lucleray
+/packages/now-next                       @Timer
+/packages/now-go                         @styfle @sophearak
+/packages/now-python                     @styfle @sophearak
+/packages/now-ruby                       @styfle @coetry @nathancahill
+/packages/now-static-build               @styfle @AndyBitz
+/packages/now-routing-utils              @dav-is

.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: Publish
+
+on:
+  push:
+    branches:
+    - master
+    - canary
+    tags:
+    - '!*'
+
+jobs:
+  Publish:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x]
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Checkout
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: Install
+      run: yarn install --check-files --frozen-lockfile
+    - name: Build
+      run: yarn build
+    - name: Publish
+      run: yarn publish-from-github
+      env:
+        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -1,9 +1,20 @@
-# build output
-packed
-download/dist
-
-# dependencies
 node_modules
-
-# logs
+package-lock.json
+dist
 npm-debug.log
+yarn-error.log
+.nyc_output
+coverage
+*.swp
+*.bak
+*.tgz
+packages/now-cli/.builders
+packages/now-cli/assets
+packages/now-cli/src/util/dev/templates/*.ts
+packages/now-cli/test/**/yarn.lock
+!packages/now-cli/test/dev/**/yarn.lock
+packages/now-cli/test/**/node_modules
+packages/now-cli/test/dev/fixtures/08-hugo/hugo
+packages/now-cli/test/dev/fixtures/**/dist
+packages/now-cli/test/dev/fixtures/**/public
+packages/now-cli/test/fixtures/integration

.kodiak.toml

@@ -0,0 +1,16 @@
+version = 1
+
+[merge]
+automerge_label = "automerge"
+blacklist_title_regex = "^WIP.*"
+blacklist_labels = ["work in progress"]
+method = "squash"
+delete_branch_on_merge = true
+block_on_reviews_requested = false
+notify_on_conflict = true
+optimistic_updates = true
+
+[merge.message]
+title = "pull_request_title"
+include_pr_number = true
+body_type = "markdown"

.npmrc

@@ -1 +0,0 @@
-save-exact = true

.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "es5"
+}

.travis.yml

@@ -1,28 +0,0 @@
-{
-  "language": "node_js",
-  "node_js": [
-    "node"
-  ],
-  "script": [
-    "npm run test",
-    "./node_modules/.bin/prettier --single-quote --no-semi --write  `find ./lib -name '*.js'` `find ./bin -name '*.js'` ; echo 'checking if prettier changed something' ; git diff-index --name-only HEAD ; git diff HEAD ; git diff-index --quiet HEAD && echo 'ok' || (echo 'pretier modified contents, please run prettier locally and add changes. exitting...' && exit 1)"
-  ],
-  "before_deploy": "npm run pack",
-  "deploy": {
-    "provider": "releases",
-    "api_key": {
-      "secure": "RN06QEC2Vaigv2oX0rcBGCym1StJhQRoiRii6hq+AQJzdvuBJcWGDGz34CE0TPNeYbG56TyfnfryWxNtEmL+daQ9tjML3Wjk5cSt7bfo8uiB3qfuMSt2uUQvdwr7kOyzUDY6FNWB9ViTYxXzNZahZcOHdVxKdZ4RMDZfdvkun9baobhIF3OvPsFT+DiV0APVEcIg/e3PYNPLzyr59Z1yo2algvwn2c3TgHFiOBvTPLiNSO3eZQ33E8TuwSdl7D5Mnx5hUDc2Q9PDAH40aGM01Rq3aNvko4H2INfQJOlyu1JALEsnT3YGHkBOMkLoQGVGTNU7b7Ktxq+4FLDc5KiVTT49uvsPuNdMonEBRxahANqF6KJ9MqXeJZ59rBm7qa56hyffn2bXy2t2Wmn/8Wvn7gxj6eT4/1cVMNnUl/snLBvs5gHT4crPOkTT8vrdfpUWeacKIgfnvYYVcxJ8O5DCnFoIgd48+K5M6DG/g4N52lRFonHVj2VMpxSROEky/vlntalrKxqT7rJom0Ko5T3pYVMXoZGCuy2StBjXX6B4ofkj+9WkkHgzXxcpJDUb1ZPtUGul2sed2e8zPeG1sJVypLOnTXyJenm28w3oUckdH3Rd1Qv5BiFT6uiwIQExzyj9IGzaADAeoKctkGJlqbDW1PHyavFKePyLTpNh/bmXOuk="
-    },
-    "file_glob": true,
-    "file": "packed/*",
-    "skip_cleanup": true,
-    "on": {
-      "tags": true
-    }
-  },
-  "after_script": [
-    'npm install --global slackup',
-    'npm run pack',
-    './scripts/slack.js'
-  ]
-}

.yarnrc

@@ -0,0 +1 @@
+save-prefix ""

CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+## Code of Conduct
+
+ ### Our Pledge
+
+ In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+ ### Our Standards
+
+ Examples of behavior that contributes to creating a positive environment
+include:
+
+ - Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
+
+ Examples of unacceptable behavior by participants include:
+
+ - The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+ ### Our Responsibilities
+
+ Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+ Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+ ### Scope
+
+ This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+ ### Enforcement
+
+ Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [abuse@zeit.co](mailto:abuse@zeit.co). All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+ Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+ ### Attribution
+
+ This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+ [homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -0,0 +1,96 @@
+# Contributing
+
+When contributing to this repository, please first discuss the change you wish to make via [GitHub Issue](https://github.com/zeit/now/issues/new) or [Spectrum](https://spectrum.chat/zeit) with the owners of this repository before submitting a Pull Request.
+
+Please read our [code of conduct](CODE_OF_CONDUCT.md) and follow it in all your interactions with the project.
+
+## Local development
+
+This project is configured in a monorepo pattern where one repo contains multiple npm packages. Dependencies are installed and managed with `yarn`, not `npm` CLI.
+
+To get started, execute the following:
+
+```
+git clone https://github.com/zeit/now
+yarn install
+yarn bootstrap
+yarn build
+yarn lint
+yarn test
+```
+
+Make sure all the tests pass before making changes.
+
+## Verifying your change
+
+Once you are done with your changes (we even suggest doing it along the way ), make sure all the test still run by running
+
+```
+yarn build && yarn test
+```
+
+from the root of the project.
+
+If any test fails, make sure to fix it along with your changes. See [Interpreting test errors](#Interpreting-test-errors) for more information about how the tests are executed, especially the integration tests.
+
+## Pull Request Process
+
+Once you are confident that your changes work properly, open a pull request on the main repository.
+
+The pull request will be reviewed by the maintainers and the tests will be checked by our continuous integration platform.
+
+## Interpreting test errors
+
+There are 2 kinds of tests in this repository – Unit tests and Integration tests.
+
+Unit tests are run locally with `jest` and execute quickly because they are testing the smallest units of code.
+
+### Integration tests
+
+Integration tests create deployments to your ZEIT account using the `test` project name. After each test is deployed, the `probes` key is used to check if the response is the expected value. If the value doesn't match, you'll see a message explaining the difference. If the deployment failed to build, you'll see a more generic message like the following:
+
+```
+[Error: Fetched page https://test-8ashcdlew.now.sh/root.js does not contain hello Root!. Instead it contains An error occurred with this application.
+
+    NO_STATUS_CODE_FRO Response headers:
+       cache-control=s-maxage=0
+      connection=close
+      content-type=text/plain; charset=utf-8
+      date=Wed, 19 Jun 2019 18:01:37 GMT
+      server=now
+      strict-transport-security=max-age=63072000
+      transfer-encoding=chunked
+      x-now-id=iad1:hgtzj-1560967297876-44ae12559f95
+      x-now-trace=iad1]
+```
+
+In such cases you can visit the URL of the failed deployment and append `/_logs` so see the build error. In the case above, that would be https://test-8ashcdlew.now.sh/_logs
+
+The logs of this deployment will contain the actual error which may help you to understand what went wrong.
+
+### @zeit/node-file-trace
+
+Some of the Builders use `@zeit/node-file-trace` to tree-shake files before deployment. If you suspect an error with this tree-shaking mechanism, you can create the following script in your project:
+
+```js
+const trace = require('@zeit/node-file-trace');
+trace(['path/to/entrypoint.js'], {
+  ts: true,
+  mixedModules: true,
+})
+  .then(o => console.log(o.fileList))
+  .then(e => console.error(e));
+```
+
+When you run this script, you'll see all imported files. If anything file is missing, the bug is in [@zeit/node-file-trace](https://github.com/zeit/node-file-trace) and not the Builder.
+
+## Deploy a Builder with existing project
+
+Sometimes you want to test changes to a Builder against an existing project, maybe with `now dev` or an actual deployment. You can avoid publishing every Builder change to npm by uploading the Builder as a tarball.
+
+1. Change directory to the desired Builder `cd ./packages/now-node`
+2. Run `yarn build` to compile typescript and other build steps
+3. Run `npm pack` to create a tarball file
+4. Run `now *.tgz` to upload the tarball file and get a URL
+5. Edit any existing `now.json` project and replace `use` with the URL
+6. Run `now` or `now dev` to deploy with the experimental Builder

DEVELOPING_A_BUILDER.md

@@ -0,0 +1,447 @@
+# Builders Developer Reference
+
+The following page is a reference for how to create a Builder using the available Builder's API.
+
+A Builder is an npm module that exposes a `build` function and optionally an `analyze` function and `prepareCache` function.
+Official Builders are published to [npmjs.com](https://npmjs.com) as a package and referenced in the `use` property of the `now.json` configuration file.
+However, the `use` property will work with any [npm install argument](https://docs.npmjs.com/cli/install) such as a git repo url which is useful for testing your Builder.
+
+See the [Builders Documentation](https://zeit.co/docs/v2/advanced/builders) to view example usage.
+
+## Builder Exports
+
+### `version`
+
+A **required** exported constant that decides which version of the Builder API to use.
+
+The latest and suggested version is `2`.
+
+### `analyze`
+
+An **optional** exported function that returns a unique fingerprint used for the purpose of [build de-duplication](https://zeit.co/docs/v2/advanced/concepts/immutability#deduplication-algorithm). If the `analyze` function is not supplied, a random fingerprint is assigned to each build.
+
+```js
+export analyze({
+  files: Files,
+  entrypoint: String,
+  workPath: String,
+  config: Object
+}) : String fingerprint
+```
+
+If you are using TypeScript, you should use the following types:
+
+```ts
+import { AnalyzeOptions } from '@now/build-utils'
+
+export analyze(options: AnalyzeOptions) {
+  return 'fingerprint goes here'
+}
+```
+
+### `build`
+
+A **required** exported function that returns a [Files](#files) data structure that contains the Build outputs, which can be a [Static File](#file) or a [Serverless Function](#serverless-function).
+
+What's a Serverless Function? Read about [Serverless Function concepts](https://zeit.co/docs/v2/deployments/concepts/lambdas) to learn more.
+
+```js
+build({
+  files: Files,
+  entrypoint: String,
+  workPath: String,
+  config: Object,
+  meta?: {
+    isDev?: Boolean,
+    requestPath?: String,
+    filesChanged?: Array<String>,
+    filesRemoved?: Array<String>
+  }
+}) : {
+  watch: Array<String>,
+  output: Files output,
+  routes: Object
+}
+```
+
+If you are using TypeScript, you should use the following types:
+
+```ts
+import { BuildOptions } from '@now/build-utils'
+
+export build(options: BuildOptions) {
+  // Build the code here
+
+  return {
+    output: {
+      'path-to-file': File,
+      'path-to-lambda': Lambda
+    },
+    watch: [],
+    routes: {}
+  }
+}
+```
+
+### `prepareCache`
+
+An **optional** exported function that is equivalent to [`build`](#build), but it executes the instructions necessary to prepare a cache for the next run.
+
+```js
+prepareCache({
+  files: Files,
+  entrypoint: String,
+  workPath: String,
+  cachePath: String,
+  config: Object
+}) : Files cacheOutput
+```
+
+If you are using TypeScript, you can import the types for each of these functions by using the following:
+
+```ts
+import { PrepareCacheOptions } from '@now/build-utils'
+
+export prepareCache(options: PrepareCacheOptions) {
+  return { 'path-to-file': File }
+}
+```
+
+### `shouldServe`
+
+An **optional** exported function that is only used by `now dev` in [Now CLI](https:///download) and indicates whether a [Builder](https://zeit.co/docs/v2/advanced/builders) wants to be responsible for building a certain request path.
+
+```js
+shouldServe({
+  entrypoint: String,
+  files: Files,
+  config: Object,
+  requestPath: String,
+  workPath: String
+}) : Boolean
+```
+
+If you are using TypeScript, you can import the types for each of these functions by using the following:
+
+```ts
+import { ShouldServeOptions } from '@now/build-utils'
+
+export shouldServe(options: ShouldServeOptions) {
+  return Boolean
+}
+```
+
+If this method is not defined, Now CLI will default to [this function](https://github.com/zeit/now/blob/52994bfe26c5f4f179bdb49783ee57ce19334631/packages/now-build-utils/src/should-serve.ts).
+
+### Builder Options
+
+The exported functions [`analyze`](#analyze), [`build`](#build), and [`prepareCache`](#preparecache) receive one argument with the following properties.
+
+**Properties:**
+
+- `files`: All source files of the project as a [Files](#files) data structure.
+- `entrypoint`: Name of entrypoint file for this particular build job. Value `files[entrypoint]` is guaranteed to exist and be a valid [File](#files) reference. `entrypoint` is always a discrete file and never a glob, since globs are expanded into separate builds at deployment time.
+- `workPath`: A writable temporary directory where you are encouraged to perform your build process. This directory will be populated with the restored cache from the previous run (if any) for [`analyze`](#analyze) and [`build`](#build).
+- `cachePath`: A writable temporary directory where you can build a cache for the next run. This is only passed to `prepareCache`.
+- `config`: An arbitrary object passed from by the user in the [Build definition](#defining-the-build-step) in `now.json`.
+
+## Example: html-minifier
+
+Let's walk through what it takes to create a simple builder that takes in a HTML source file and yields a minified HTML static file as its build output.
+
+While this is a very simple builder, the approach demonstrated here can be used to return anything: one or more static files and/or one or more lambdas.
+
+## Setting up the module
+
+### Defining the analyze step
+
+The `analyze` hook is optional. Its goal is to give the developer a tool to avoid wasting time _re-computing a build_ that has already occurred.
+
+The return value of `analyze` is a _fingerprint_: a simple string that uniquely identifies the build process.
+
+If `analyze` is not specified, its behavior is to use as the fingerprint the combined checksums of **all the files in the same directory level as the entrypoint**. This is a default that errs on making sure that we re-execute builds when files _other than the entrypoint_ (like dependencies, manifest files, etc) have changed.
+
+For our `html-minify` example, we know that HTML files don't have dependencies. Therefore, our analyze step can just return the `digest` of the entrypoint.
+
+Our `index.js` file looks as follows:
+
+```js
+exports.analyze = function({ files, entrypoint }) {
+  return files[entrypoint].digest
+}
+```
+
+This means that we will only re-minify and re-create the build output _only if the file contents (and therefore its digest) change._
+
+### Defining the build step
+
+Your module will need some utilities to manipulate the data structures we pass you, create new ones and alter the filesystem.
+
+To that end, we expose our API as part of a `@now/build-utils` package. This package is always loaded on your behalf, so make sure it's only included as `peerDependencies` in your `package.json`.
+
+Builders can include dependencies of their liking:
+
+```js
+const htmlMinifier = require('html-minifier')
+
+exports.version = 2
+
+exports.analyze = ({ files, entrypoint }) => files[entrypoint].digest
+
+exports.build = async ({ files, entrypoint, config }) => {
+  const stream = files[entrypoint].toStream()
+  const options = Object.assign({}, config || {})
+  const { data } = await FileBlob.fromStream({ stream })
+  const content = data.toString()
+  const minified = htmlMinifier(content, options)
+  const result = new FileBlob({ data: minified })
+
+  return {
+    output: {
+      [entrypoint]: result
+    },
+    watch: [],
+    routes: {}
+  }
+}
+```
+
+### Defining a `prepareCache` step
+
+If our builder had performed work that could be re-used in the next build invocation, we could define a `prepareCache` step.
+
+In this case, there are not intermediate artifacts that we can cache, and our `analyze` step already takes care of caching the full output based on the fingerprint of the input.
+
+## Technical Details
+
+### Execution Context
+
+A [Serverless Function](https://zeit.co/docs/v2/advanced/concepts/lambdas) is created where the builder logic is executed. The lambda is run using the Node.js 8 runtime. A brand new sandbox is created for each deployment, for security reasons. The sandbox is cleaned up between executions to ensure no lingering temporary files are shared from build to build.
+
+All the APIs you export ([`analyze`](#analyze), [`build`](#build) and [`prepareCache`](#preparecache)) are not guaranteed to be run in the same process, but the filesystem we expose (e.g.: `workPath` and the results of calling [`getWriteableDirectory`](#getWriteableDirectory) ) is retained.
+
+If you need to share state between those steps, use the filesystem.
+
+### Directory and Cache Lifecycle
+
+When a new build is created, we pre-populate the `workPath` supplied to `analyze` with the results of the `prepareCache` step of the previous build.
+
+The `analyze` step can modify that directory, and it will not be re-created when it's supplied to `build` and `prepareCache`.
+
+To learn how the cache key is computed and invalidated, refer to the [overview](https://zeit.co/docs/v2/advanced/builders#technical-details).
+
+### Accessing Environment and Secrets
+
+The env and secrets specified by the user as `build.env` are passed to the builder process. This means you can access user env via `process.env` in Node.js.
+
+### Utilities as peerDependencies
+
+When you publish your builder to npm, make sure to not specify `@now/build-utils` (as seen below in the API definitions) as a dependency, but rather as part of `peerDependencies`.
+
+## Types
+
+### `Files`
+
+```ts
+import { File } from '@now/build-utils'
+type Files = { [filePath: string]: File }
+```
+
+This is an abstract type that is implemented as a plain [JavaScript Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object). It's helpful to think of it as a virtual filesystem representation.
+
+When used as an input, the `Files` object will only contain `FileRefs`. When `Files` is an output, it may consist of `Lambda` (Serverless Functions) types as well as `FileRefs`.
+
+An example of a valid output `Files` object is:
+
+```json
+{
+  "index.html": FileRef,
+  "api/index.js": Lambda
+}
+```
+
+### `File`
+
+This is an abstract type that can be imported if you are using TypeScript.
+
+```ts
+import { File } from '@now/build-utils'
+```
+
+Valid `File` types include:
+
+- [`FileRef`](#fileref)
+- [`FileFsRef`](#filefsref)
+- [`FileBlob`](#fileblob)
+
+### `FileRef`
+
+```ts
+import { FileRef } from '@now/build-utils'
+```
+
+This is a [JavaScript class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) that represents an abstract file instance stored in our platform, based on the file identifier string (its checksum). When a `Files` object is passed as an input to `analyze` or `build`, all its values will be instances of `FileRef`.
+
+**Properties:**
+
+- `mode : Number` file mode
+- `digest : String` a checksum that represents the file
+
+**Methods:**
+
+- `toStream() : Stream` creates a [Stream](https://nodejs.org/api/stream.html) of the file body
+
+### `FileFsRef`
+
+```ts
+import { FileFsRef } from '@now/build-utils'
+```
+
+This is a [JavaScript class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) that represents an abstract instance of a file present in the filesystem that the build process is executing in.
+
+**Properties:**
+
+- `mode : Number` file mode
+- `fsPath : String` the absolute path of the file in file system
+
+**Methods:**
+
+- `static async fromStream({ mode : Number, stream : Stream, fsPath : String }) : FileFsRef` creates an instance of a [FileFsRef](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) from `Stream`, placing file at `fsPath` with `mode`
+- `toStream() : Stream` creates a [Stream](https://nodejs.org/api/stream.html) of the file body
+
+### `FileBlob`
+
+```ts
+import { FileBlob } from '@now/build-utils'
+```
+
+This is a [JavaScript class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) that represents an abstract instance of a file present in memory.
+
+**Properties:**
+
+- `mode : Number` file mode
+- `data : String | Buffer` the body of the file
+
+**Methods:**
+
+- `static async fromStream({ mode : Number, stream : Stream }) :FileBlob` creates an instance of a [FileBlob](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) from [`Stream`](https://nodejs.org/api/stream.html) with `mode`
+- `toStream() : Stream` creates a [Stream](https://nodejs.org/api/stream.html) of the file body
+
+### `Lambda`
+
+```ts
+import { Lambda } from '@now/build-utils'
+```
+
+This is a [JavaScript class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes), called a Serverless Function, that can be created by supplying `files`, `handler`, `runtime`, and `environment` as an object to the [`createLambda`](#createlambda) helper. The instances of this class should not be created directly. Instead use a call to [`createLambda`](#createlambda).
+
+**Properties:**
+
+- `files : Files` the internal filesystem of the lambda
+- `handler : String` path to handler file and (optionally) a function name it exports
+- `runtime : LambdaRuntime` the name of the lambda runtime
+- `environment : Object` key-value map of handler-related (aside of those passed by user) environment variables
+
+### `LambdaRuntime`
+
+This is an abstract enumeration type that is implemented by one of the following possible `String` values:
+
+- `nodejs10.x`
+- `nodejs8.10`
+- `go1.x`
+- `java-1.8.0-openjdk`
+- `python3.6`
+- `python2.7`
+- `dotnetcore2.1`
+- `dotnetcore2.0`
+- `dotnetcore1.0`
+
+## JavaScript API
+
+The following is exposed by `@now/build-utils` to simplify the process of writing Builders, manipulating the file system, using the above types, etc.
+
+### `createLambda`
+
+Signature: `createLambda(Object spec) : Lambda`
+
+```ts
+import { createLambda } from '@now/build-utils'
+```
+
+Constructor for the [`Lambda`](#lambda) type.
+
+```js
+const { createLambda, FileBlob } = require('@now/build-utils')
+await createLambda({
+  runtime: 'nodejs8.10',
+  handler: 'index.main',
+  files: {
+    'index.js': new FileBlob({ data: 'exports.main = () => {}' })
+  }
+})
+```
+
+### `download`
+
+Signature: `download() : Files`
+
+```ts
+import { download } from '@now/build-utils'
+```
+
+This utility allows you to download the contents of a [`Files`](#files) data structure, therefore creating the filesystem represented in it.
+
+Since `Files` is an abstract way of representing files, you can think of `download` as a way of making that virtual filesystem _real_.
+
+If the **optional** `meta` property is passed (the argument for [build](#build)), only the files that have changed are downloaded. This is decided using `filesRemoved` and `filesChanged` inside that object.
+
+```js
+await download(files, workPath, meta)
+```
+
+### `glob`
+
+Signature: `glob() : Files`
+
+```ts
+import { glob } from '@now/build-utils'
+```
+
+This utility allows you to _scan_ the filesystem and return a [`Files`](#files) representation of the matched glob search string. It can be thought of as the reverse of [`download`](#download).
+
+The following trivial example downloads everything to the filesystem, only to return it back (therefore just re-creating the passed-in [`Files`](#files)):
+
+```js
+const { glob, download } = require('@now/build-utils')
+
+exports.build = ({ files, workPath }) => {
+  await download(files, workPath)
+  return glob('**', workPath)
+}
+```
+
+### `getWriteableDirectory`
+
+Signature: `getWriteableDirectory() : String`
+
+```ts
+import { getWriteableDirectory } from '@now/build-utils'
+```
+
+In some occasions, you might want to write to a temporary directory.
+
+### `rename`
+
+Signature: `rename(Files) : Files`
+
+```ts
+import { rename } from '@now/build-utils'
+```
+
+Renames the keys of the [`Files`](#files) object, which represent the paths. For example, to remove the `*.go` suffix you can use:
+
+```js
+const rename = require('@now/build-utils')
+const originalFiles = { 'one.go': fileFsRef1, 'two.go': fileFsRef2 }
+const renamedFiles = rename(originalFiles, path => path.replace(/\.go$/, '')
+```

LICENSE

@@ -0,0 +1,190 @@
+                             Apache License
+                       Version 2.0, January 2004
+                    https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+      Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+      stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+      that You distribute, all copyright, patent, trademark, and
+      attribution notices from the Source form of the Work,
+      excluding those notices that do not pertain to any part of
+      the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+      distribution, then any Derivative Works that You distribute must
+      include a readable copy of the attribution notices contained
+      within such NOTICE file, excluding those notices that do not
+      pertain to any part of the Derivative Works, in at least one
+      of the following places: within a NOTICE text file distributed
+      as part of the Derivative Works; within the Source form or
+      documentation, if provided along with the Derivative Works; or,
+      within a display generated by the Derivative Works, if and
+      wherever such third-party notices normally appear. The contents
+      of the NOTICE file are for informational purposes only and
+      do not modify the License. You may add Your own attribution
+      notices within Derivative Works that You distribute, alongside
+      or as an addendum to the NOTICE text from the Work, provided
+      that such additional attribution notices cannot be construed
+      as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2017 ZEIT, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

PUBLISHING.md

@@ -0,0 +1,43 @@
+# Publishing to npm
+
+Always publish to the Canary Channel as soon as a PR is merged into the `canary` branch.
+
+```
+yarn publish-canary
+```
+
+Publish the Stable Channel weekly.
+
+- Cherry pick each commit from `canary` to `master` branch
+- Verify that you are _in-sync_ with canary (with the exception of the `version` line in `package.json`)
+- Deploy the modified Builders
+
+```
+# View differences excluding "Publish" commits
+git checkout canary && git pull
+git log --pretty=format:"$ad- %s [%an]" | grep -v Publish > ~/Desktop/canary.txt
+git checkout master && git pull
+git log --pretty=format:"$ad- %s [%an]" | grep -v Publish > ~/Desktop/master.txt
+diff ~/Desktop/canary.txt ~/Desktop/master.txt
+
+# Cherry pick all PRs from canary into master ...
+git cherry-pick <PR501_COMMIT_SHA>
+git cherry-pick <PR502_COMMIT_SHA>
+git cherry-pick <PR503_COMMIT_SHA>
+git cherry-pick <PR504_COMMIT_SHA>
+
+# Verify the only difference is "version" in package.json
+git diff origin/canary
+
+# Generate release notes since previous publish
+git log --pretty=format:"- %s [%an] %H" `git log --pretty=format:"%s %H" | grep "^Publish" | head -n 1 | awk '{ print $NF }'`...HEAD
+
+# Ship it
+yarn publish-stable
+```
+
+After running this publish step, GitHub Actions will take care of publishing the modified Builder packages to npm.
+
+If for some reason GitHub Actions fails to publish the npm package, you may do so
+manually by running `npm publish` from the package directory. Make sure to
+use `npm publish --tag canary` if you are publishing a canary release!

README.md

@@ -0,0 +1,41 @@
+![now](https://assets.zeit.co/image/upload/v1542240976/repositories/now-cli/now-cli-repo-banner-v3.png)
+
+[![Build Status](https://circleci.com/gh/zeit/now.svg?&style=shield)](https://circleci.com/gh/zeit/workflows/now)
+[![Join the community on Spectrum](https://withspectrum.github.io/badge/badge.svg)](https://spectrum.chat/zeit)
+
+**Note**: The [canary](https://github.com/zeit/now/tree/canary) branch is under heavy development – the stable release branch is [master](https://github.com/zeit/now/tree/master).
+
+## Usage
+
+To install the latest version of Now CLI, visit [zeit.co/download](https://zeit.co/download) or run this command:
+
+```
+npm i -g now
+```
+
+To quickly start a new project, run the following commands:
+
+```
+now init        # Pick an example project to clone
+cd <PROJECT>    # Change directory to the newly created project
+now dev         # Run locally during development
+now             # Deploy to the cloud
+```
+
+## Documentation
+
+For details on how to use Now CLI, check out our [documentation](https://zeit.co/docs).
+
+## Caught a Bug?
+
+1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your own GitHub account and then [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device
+2. Install dependencies with `yarn install`
+3. Compile the code: `yarn build`
+4. Link the package to the global module directory: `yarn link`
+5. You can now start using `now` anywhere inside the command line
+
+As always, you should use `yarn test-unit` to run the tests and see if your changes have broken anything.
+
+## How to Create a Release
+
+If you have write access to this repository, you can read more about how to publish a release [here](https://github.com/zeit/now/wiki/Creating-a-Release).

VERSIONING.md

@@ -0,0 +1,25 @@
+# Versioning
+
+Builders are released to two different channels.
+
+## Channels
+
+| Channel | Git Branch                                                    | npm dist-tag | use example        |
+| ------- | ------------------------------------------------------------- | ------------ | ------------------ |
+| Canary  | [canary](https://github.com/zeit/now/commits/canary)          | `@canary`    | `@now/node@canary` |
+| Stable  | [master](https://github.com/zeit/now/commits/master)          | `@latest`    | `@now/node@latest` |
+
+All PRs are submitted to the `canary` branch. Once a PR is merged into the `canary` branch, it should be published to npm immediately using the Canary Channel.
+
+## Version Selection
+
+Since Builders are published to [npmjs.com](https://npmjs.com), this makes versioning works the same for Builders as it does for any npm package. The `use` statement in [now.json](https://zeit.co/docs/v2/advanced/configuration#builds) has a similar syntax to `npm install`.
+
+The following are valid examples [@now/node](https://www.npmjs.com/package/@now/node?activeTab=versions):
+
+- `@now/node`
+- `@now/node@0.7.3`
+- `@now/node@canary`
+- `@now/node@0.7.2-canary.2`
+
+We always recommend using the latest version by leaving off the dist-tag suffix, `@now/node` for example.

bin/domains/buy.js

@@ -1,80 +0,0 @@
-const { italic, bold } = require('chalk')
-
-const error = require('../../lib/utils/output/error')
-const wait = require('../../lib/utils/output/wait')
-const cmd = require('../../lib/utils/output/cmd')
-const param = require('../../lib/utils/output/param')
-const info = require('../../lib/utils/output/info')
-const uid = require('../../lib/utils/output/uid')
-const success = require('../../lib/utils/output/success')
-const stamp = require('../../lib/utils/output/stamp')
-const promptBool = require('../../lib/utils/input/prompt-bool')
-const eraseLines = require('../../lib/utils/output/erase-lines')
-const treatBuyError = require('../../lib/utils/domains/treat-buy-error')
-
-module.exports = async function({ domains, args, currentTeam, user }) {
-  const name = args[0]
-  let elapsed
-
-  if (!name) {
-    return error(`Missing domain name. Run ${cmd('now domains help')}`)
-  }
-
-  const nameParam = param(name)
-  elapsed = stamp()
-  let stopSpinner = wait(`Checking availability for ${nameParam}`)
-
-  let price
-  let period
-  try {
-    const json = await domains.price(name)
-    price = json.price
-    period = json.period
-  } catch (err) {
-    stopSpinner()
-    return error(err.message)
-  }
-
-  const available = await domains.status(name)
-
-  stopSpinner()
-
-  if (!available) {
-    return error(
-      `The domain ${nameParam} is ${italic('unavailable')}! ${elapsed()}`
-    )
-  }
-  const periodMsg = `${period}yr${period > 1 ? 's' : ''}`
-  info(
-    `The domain ${nameParam} is ${italic('available')} to buy under ${bold(
-      (currentTeam && currentTeam.slug) || user.username || user.email
-    )}! ${elapsed()}`
-  )
-  const confirmation = await promptBool(
-    `Buy now for ${bold(`$${price}`)} (${periodMsg})?`
-  )
-
-  eraseLines(1)
-  if (!confirmation) {
-    return info('Aborted')
-  }
-
-  stopSpinner = wait('Purchasing')
-  elapsed = stamp()
-  let domain
-  try {
-    domain = await domains.buy(name)
-  } catch (err) {
-    stopSpinner()
-    return treatBuyError(err)
-  }
-
-  stopSpinner()
-
-  success(`Domain purchased and created ${uid(domain.uid)} ${elapsed()}`)
-  info(
-    `You may now use your domain as an alias to your deployments. Run ${cmd(
-      'now alias --help'
-    )}`
-  )
-}

bin/now-alias.js

@@ -1,525 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const chalk = require('chalk')
-const minimist = require('minimist')
-const table = require('text-table')
-const ms = require('ms')
-const printf = require('printf')
-require('epipebomb')()
-const supportsColor = require('supports-color')
-
-// Ours
-const strlen = require('../lib/strlen')
-const NowAlias = require('../lib/alias')
-const NowDomains = require('../lib/domains')
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const { error } = require('../lib/error')
-const toHost = require('../lib/to-host')
-const { reAlias } = require('../lib/re-alias')
-const exit = require('../lib/utils/exit')
-const info = require('../lib/utils/output/info')
-const logo = require('../lib/utils/output/logo')
-const promptBool = require('../lib/utils/input/prompt-bool')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token', 'rules'],
-  boolean: ['help', 'debug'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    rules: 'r',
-    debug: 'd',
-    token: 't'
-  }
-})
-
-const subcommand = argv._[0]
-
-const grayWidth = 10
-const underlineWidth = 11
-
-// Options
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now alias`)} <ls | set | rm> <deployment> <alias>
-
-  ${chalk.dim('Options:')}
-
-    -h, --help                         Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}             Config file
-    -r ${chalk.bold.underline('RULES_FILE')}, --rules=${chalk.bold.underline(
-    'RULES_FILE'
-  )}  Rules file
-    -d, --debug                        Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )}            Login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Lists all your aliases:
-
-      ${chalk.cyan('$ now alias ls')}
-
-  ${chalk.gray('–')} Adds a new alias to ${chalk.underline('my-api.now.sh')}:
-
-      ${chalk.cyan(
-        `$ now alias set ${chalk.underline(
-          'api-ownv3nc9f8.now.sh'
-        )} ${chalk.underline('my-api.now.sh')}`
-      )}
-
-      The ${chalk.dim('`.now.sh`')} suffix can be ommited:
-
-      ${chalk.cyan('$ now alias set api-ownv3nc9f8 my-api')}
-
-      The deployment id can be used as the source:
-
-      ${chalk.cyan('$ now alias set deploymentId my-alias')}
-
-      Custom domains work as alias targets:
-
-      ${chalk.cyan(
-        `$ now alias set ${chalk.underline(
-          'api-ownv3nc9f8.now.sh'
-        )} ${chalk.underline('my-api.com')}`
-      )}
-
-      ${chalk.dim('–')} The subcommand ${chalk.dim(
-    '`set`'
-  )} is the default and can be skipped.
-      ${chalk.dim('–')} ${chalk.dim(
-    '`http(s)://`'
-  )} in the URLs is unneeded / ignored.
-
-  ${chalk.gray('–')} Add and modify path based aliases for ${chalk.underline(
-    'zeit.ninja'
-  )}:
-
-      ${chalk.cyan(
-        `$ now alias ${chalk.underline('zeit.ninja')} -r ${chalk.underline(
-          'rules.json'
-        )}`
-      )}
-
-      Export effective routing rules:
-
-      ${chalk.cyan(
-        `$ now alias ls aliasId --json > ${chalk.underline('rules.json')}`
-      )}
-
-      ${chalk.cyan(`$ now alias ls zeit.ninja`)}
-
-  ${chalk.gray('–')} Removing an alias:
-
-      ${chalk.cyan('$ now alias rm aliasId')}
-
-      To get the list of alias ids, use ${chalk.dim('`now alias ls`')}.
-
-  ${chalk.dim('Alias:')} ln
-`)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-if (argv.help) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-
-    try {
-      await run({ token, config })
-    } catch (err) {
-      if (err.userError) {
-        error(err.message)
-      } else {
-        error(`Unknown error: ${err}\n${err.stack}`)
-      }
-      exit(1)
-    }
-  })
-}
-
-async function run({ token, config: { currentTeam, user } }) {
-  const alias = new NowAlias({ apiUrl, token, debug, currentTeam })
-  const domains = new NowDomains({ apiUrl, token, debug, currentTeam })
-  const args = argv._.slice(1)
-
-  switch (subcommand) {
-    case 'ls':
-    case 'list': {
-      if (args.length === 1) {
-        const list = await alias.listAliases()
-        const item = list.find(
-          e => e.uid === argv._[1] || e.alias === argv._[1]
-        )
-        if (!item || !item.rules) {
-          error(`Could not match path alias for: ${argv._[1]}`)
-          return exit(1)
-        }
-
-        if (argv.json) {
-          console.log(JSON.stringify({ rules: item.rules }, null, 2))
-        } else {
-          const header = [
-            ['', 'pathname', 'method', 'dest'].map(s => chalk.dim(s))
-          ]
-          const text = list.length === 0
-            ? null
-            : table(
-                header.concat(
-                  item.rules.map(rule => {
-                    return [
-                      '',
-                      rule.pathname ? rule.pathname : '',
-                      rule.method ? rule.method : '*',
-                      rule.dest
-                    ]
-                  })
-                ),
-                {
-                  align: ['l', 'l', 'l', 'l'],
-                  hsep: ' '.repeat(2),
-                  stringLength: strlen
-                }
-              )
-
-          console.log(text)
-        }
-        break
-      } else if (args.length !== 0) {
-        error(
-          `Invalid number of arguments. Usage: ${chalk.cyan('`now alias ls`')}`
-        )
-        return exit(1)
-      }
-
-      const start_ = new Date()
-      const list = await alias.list()
-      const urls = new Map(list.map(l => [l.uid, l.url]))
-      const aliases = await alias.ls()
-      aliases.sort((a, b) => new Date(b.created) - new Date(a.created))
-      const current = new Date()
-      const sourceUrlLength =
-        aliases.reduce((acc, i) => {
-          return Math.max(
-            acc,
-            (i.deploymentId && urls.get(i.deploymentId).length) || 0
-          )
-        }, 0) + 9
-      const aliasLength =
-        aliases.reduce((acc, i) => {
-          return Math.max(acc, (i.alias && i.alias.length) || 0)
-        }, 0) + 8
-      const elapsed_ = ms(new Date() - start_)
-      console.log(
-        `> ${aliases.length} alias${aliases.length === 1
-          ? ''
-          : 'es'} found ${chalk.gray(`[${elapsed_}]`)} under ${chalk.bold(
-          (currentTeam && currentTeam.slug) || user.username || user.email
-        )}`
-      )
-      console.log()
-
-      if (supportsColor) {
-        const urlSpecHeader = `%-${sourceUrlLength + 1}s`
-        const aliasSpecHeader = `%-${aliasLength + 1}s`
-        console.log(
-          printf(
-            `  ${chalk.gray(urlSpecHeader + ' ' + aliasSpecHeader + '  %5s')}`,
-            'source',
-            'url',
-            'age'
-          )
-        )
-      } else {
-        const urlSpecHeader = `%-${sourceUrlLength}s`
-        const aliasSpecHeader = `%-${aliasLength}s`
-        console.log(
-          printf(
-            `  ${urlSpecHeader} ${aliasSpecHeader} %5s`,
-            'source',
-            'url',
-            'age'
-          )
-        )
-      }
-
-      let text = ''
-      aliases.forEach(_alias => {
-        let urlSpec = sourceUrlLength
-        let aliasSpec = aliasLength
-        let ageSpec = 5
-        const _url = chalk.underline(`https://${_alias.alias}`)
-        const target = _alias.deploymentId
-        let _sourceUrl
-        if (supportsColor) {
-          aliasSpec += underlineWidth
-          ageSpec += grayWidth
-        }
-        if (urls.get(target)) {
-          _sourceUrl = chalk.underline(`https://${urls.get(target)}`)
-          if (supportsColor) {
-            urlSpec += grayWidth
-          }
-        } else if (_alias.rules) {
-          _sourceUrl = chalk.gray(
-            `[${_alias.rules.length} custom rule${_alias.rules.length > 1
-              ? 's'
-              : ''}]`
-          )
-          if (supportsColor) {
-            urlSpec += underlineWidth
-          }
-        } else {
-          _sourceUrl = chalk.gray('<null>')
-        }
-
-        const time = chalk.gray(ms(current - new Date(_alias.created)))
-        text += printf(
-          `  %-${urlSpec}s %-${aliasSpec}s %${ageSpec}s\n`,
-          _sourceUrl,
-          _url,
-          time
-        )
-      })
-
-      console.log(text)
-      break
-    }
-    case 'rm':
-    case 'remove': {
-      const _target = String(args[0])
-      if (!_target) {
-        const err = new Error('No alias id specified')
-        err.userError = true
-        throw err
-      }
-
-      if (args.length !== 1) {
-        error(
-          `Invalid number of arguments. Usage: ${chalk.cyan(
-            '`now alias rm <id>`'
-          )}`
-        )
-        return exit(1)
-      }
-
-      const _aliases = await alias.ls()
-      const _alias = findAlias(_target, _aliases)
-
-      if (!_alias) {
-        const err = new Error(
-          `Alias not found by "${_target}" under ${chalk.bold(
-            (currentTeam && currentTeam.slug) || user.username || user.email
-          )}. Run ${chalk.dim('`now alias ls`')} to see your aliases.`
-        )
-        err.userError = true
-        throw err
-      }
-
-      try {
-        const confirmation = await confirmDeploymentRemoval(alias, _alias)
-        if (!confirmation) {
-          info('Aborted')
-          return process.exit(0)
-        }
-
-        const start = new Date()
-        await alias.rm(_alias)
-        const elapsed = ms(new Date() - start)
-        console.log(
-          `${chalk.cyan('> Success!')} Alias ${chalk.bold(
-            _alias.uid
-          )} removed [${elapsed}]`
-        )
-      } catch (err) {
-        error(err)
-        exit(1)
-      }
-
-      break
-    }
-    case 'add':
-    case 'set': {
-      if (argv.rules) {
-        await updatePathAlias(alias, argv._[0], argv.rules, domains)
-        break
-      }
-      if (args.length !== 2) {
-        error(
-          `Invalid number of arguments. Usage: ${chalk.cyan(
-            '`now alias set <id> <domain>`'
-          )}`
-        )
-        return exit(1)
-      }
-      await alias.set(
-        String(args[0]),
-        String(args[1]),
-        domains,
-        currentTeam,
-        user
-      )
-      break
-    }
-    default: {
-      if (argv._.length === 0) {
-        await reAlias(
-          token,
-          null,
-          null,
-          help,
-          exit,
-          apiUrl,
-          debug,
-          alias,
-          currentTeam,
-          user
-        )
-        break
-      }
-
-      if (argv.rules) {
-        await updatePathAlias(alias, argv._[0], argv.rules, domains)
-        break
-      }
-
-      if (argv._.length === 1) {
-        await reAlias(
-          token,
-          null,
-          String(argv._[0]),
-          help,
-          exit,
-          apiUrl,
-          debug,
-          alias,
-          currentTeam,
-          user
-        )
-        break
-      } else if (argv._.length === 2) {
-        await alias.set(
-          String(argv._[0]),
-          String(argv._[1]),
-          domains,
-          currentTeam,
-          user
-        )
-      } else if (argv._.length >= 3) {
-        error('Invalid number of arguments')
-        help()
-        exit(1)
-      } else {
-        error('Please specify a valid subcommand: ls | set | rm')
-        help()
-        exit(1)
-      }
-    }
-  }
-
-  domains.close()
-  alias.close()
-}
-
-async function confirmDeploymentRemoval(alias, _alias) {
-  const deploymentsList = await alias.list()
-  const urls = new Map(deploymentsList.map(l => [l.uid, l.url]))
-
-  const time = chalk.gray(ms(new Date() - new Date(_alias.created)) + ' ago')
-  const _sourceUrl = chalk.underline(`https://${urls.get(_alias.deploymentId)}`)
-  const tbl = table(
-    [
-      [_alias.uid, _sourceUrl, chalk.underline(`https://${_alias.alias}`), time]
-    ],
-    { align: ['l', 'r', 'l'], hsep: ' '.repeat(6) }
-  )
-
-  const msg =
-    '> The following alias will be removed permanently\n' +
-    `  ${tbl} \nAre you sure?`
-
-  return promptBool(msg, {
-    trailing: '\n'
-  })
-}
-
-function findAlias(alias, list) {
-  let key
-  let val
-
-  if (/\./.test(alias)) {
-    val = toHost(alias)
-    key = 'alias'
-  } else {
-    val = alias
-    key = 'uid'
-  }
-
-  const _alias = list.find(d => {
-    if (d[key] === val) {
-      if (debug) {
-        console.log(`> [debug] matched alias ${d.uid} by ${key} ${val}`)
-      }
-
-      return true
-    }
-
-    // Match prefix
-    if (`${val}.now.sh` === d.alias) {
-      if (debug) {
-        console.log(`> [debug] matched alias ${d.uid} by url ${d.host}`)
-      }
-
-      return true
-    }
-
-    return false
-  })
-
-  return _alias
-}
-
-async function updatePathAlias(alias, aliasName, rules, domains) {
-  const start = new Date()
-  const res = await alias.updatePathBasedroutes(
-    String(aliasName),
-    rules,
-    domains
-  )
-  const elapsed = ms(new Date() - start)
-  if (res.error) {
-    const err = new Error(res.error.message)
-    err.userError = true
-    throw err
-  } else {
-    console.log(
-      `${chalk.cyan(
-        '> Success!'
-      )} ${res.ruleCount} rules configured for ${chalk.underline(
-        res.alias
-      )} [${elapsed}]`
-    )
-  }
-}

bin/now-billing-add.js

@@ -1,219 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const ansiEscapes = require('ansi-escapes')
-const chalk = require('chalk')
-const ccValidator = require('credit-card')
-
-// Ours
-const textInput = require('../lib/utils/input/text')
-const countries = require('../lib/utils/billing/country-list')
-const cardBrands = require('../lib/utils/billing/card-brands')
-const geocode = require('../lib/utils/billing/geocode')
-const success = require('../lib/utils/output/success')
-const wait = require('../lib/utils/output/wait')
-const { tick } = require('../lib/utils/output/chars')
-const rightPad = require('../lib/utils/output/right-pad')
-
-function expDateMiddleware(data) {
-  return data
-}
-
-module.exports = function({ creditCards, currentTeam, user }) {
-  const state = {
-    error: undefined,
-    cardGroupLabel: `> ${chalk.bold(
-      `Enter your card details for ${chalk.bold(
-        (currentTeam && currentTeam.slug) || user.username || user.email
-      )}`
-    )}`,
-
-    name: {
-      label: rightPad('Full Name', 12),
-      placeholder: 'John Appleseed',
-      validateValue: data => data.trim().length > 0
-    },
-
-    cardNumber: {
-      label: rightPad('Number', 12),
-      mask: 'cc',
-      placeholder: '#### #### #### ####',
-      validateKeypress: (data, value) => /\d/.test(data) && value.length < 19,
-      validateValue: data => {
-        data = data.replace(/ /g, '')
-        const type = ccValidator.determineCardType(data)
-        if (!type) {
-          return false
-        }
-        return ccValidator.isValidCardNumber(data, type)
-      }
-    },
-
-    ccv: {
-      label: rightPad('CCV', 12),
-      mask: 'ccv',
-      placeholder: '###',
-      validateValue: data => {
-        const brand = state.cardNumber.brand.toLowerCase()
-        return ccValidator.doesCvvMatchType(data, brand)
-      }
-    },
-
-    expDate: {
-      label: rightPad('Exp. Date', 12),
-      mask: 'expDate',
-      placeholder: 'mm / yyyy',
-      middleware: expDateMiddleware,
-      validateValue: data => !ccValidator.isExpired(...data.split(' / '))
-    },
-
-    addressGroupLabel: `\n> ${chalk.bold('Enter your billing address')}`,
-
-    country: {
-      label: rightPad('Country', 12),
-      async autoComplete(value) {
-        for (const country in countries) {
-          if (!Object.hasOwnProperty.call(countries, country)) {
-            continue
-          }
-          if (country.startsWith(value)) {
-            return country.substr(value.length)
-          }
-        }
-        return false
-      },
-      validateValue: value => countries[value] !== undefined
-    },
-
-    zipCode: {
-      label: rightPad('ZIP', 12),
-      validadeKeypress: data => data.trim().length > 0,
-      validateValue: data => data.trim().length > 0
-    },
-
-    state: {
-      label: rightPad('State', 12),
-      validateValue: data => data.trim().length > 0
-    },
-
-    city: {
-      label: rightPad('City', 12),
-      validateValue: data => data.trim().length > 0
-    },
-
-    address1: {
-      label: rightPad('Address', 12),
-      validateValue: data => data.trim().length > 0
-    }
-  }
-
-  async function render() {
-    for (const key in state) {
-      if (!Object.hasOwnProperty.call(state, key)) {
-        continue
-      }
-      const piece = state[key]
-      if (typeof piece === 'string') {
-        console.log(piece)
-      } else if (typeof piece === 'object') {
-        let result
-        try {
-          /* eslint-disable no-await-in-loop */
-          result = await textInput({
-            label: '- ' + piece.label,
-            initialValue: piece.initialValue || piece.value,
-            placeholder: piece.placeholder,
-            mask: piece.mask,
-            validateKeypress: piece.validateKeypress,
-            validateValue: piece.validateValue,
-            autoComplete: piece.autoComplete
-          })
-
-          piece.value = result
-
-          if (key === 'cardNumber') {
-            let brand = cardBrands[ccValidator.determineCardType(result)]
-            piece.brand = brand
-            if (brand === 'American Express') {
-              state.ccv.placeholder = '#'.repeat(4)
-            } else {
-              state.ccv.placeholder = '#'.repeat(3)
-            }
-            brand = chalk.cyan(`[${brand}]`)
-            const masked = chalk.gray('#### '.repeat(3)) + result.split(' ')[3]
-            process.stdout.write(
-              `${chalk.cyan(tick)} ${piece.label}${masked} ${brand}\n`
-            )
-          } else if (key === 'ccv') {
-            process.stdout.write(
-              `${chalk.cyan(tick)} ${piece.label}${'*'.repeat(result.length)}\n`
-            )
-          } else if (key === 'expDate') {
-            let text = result.split(' / ')
-            text = text[0] + chalk.gray(' / ') + text[1]
-            process.stdout.write(`${chalk.cyan(tick)} ${piece.label}${text}\n`)
-          } else if (key === 'zipCode') {
-            const stopSpinner = wait(piece.label + result)
-            const addressInfo = await geocode({
-              country: state.country.value,
-              zipCode: result
-            })
-            if (addressInfo.state) {
-              state.state.initialValue = addressInfo.state
-            }
-            if (addressInfo.city) {
-              state.city.initialValue = addressInfo.city
-            }
-            stopSpinner()
-            process.stdout.write(
-              `${chalk.cyan(tick)} ${piece.label}${result}\n`
-            )
-          } else {
-            process.stdout.write(
-              `${chalk.cyan(tick)} ${piece.label}${result}\n`
-            )
-          }
-        } catch (err) {
-          if (err.message === 'USER_ABORT') {
-            process.exit(1)
-          } else {
-            console.error(err)
-          }
-        }
-      }
-    }
-    console.log('') // New line
-    const stopSpinner = wait('Saving card')
-
-    try {
-      const res = await creditCards.add({
-        name: state.name.value,
-        cardNumber: state.cardNumber.value,
-        ccv: state.ccv.value,
-        expDate: state.expDate.value,
-        country: state.country.value,
-        zipCode: state.zipCode.value,
-        state: state.state.value,
-        city: state.city.value,
-        address1: state.address1.value
-      })
-      stopSpinner()
-      success(
-        `${state.cardNumber
-          .brand} ending in ${res.last4} was added to ${chalk.bold(
-          (currentTeam && currentTeam.slug) || user.username || user.email
-        )}`
-      )
-    } catch (err) {
-      stopSpinner()
-      const linesToClear = state.error ? 13 : 12
-      process.stdout.write(ansiEscapes.eraseLines(linesToClear))
-      state.error = `${chalk.red(
-        '> Error!'
-      )} ${err.message} Please make sure the info is correct`
-      await render()
-    }
-  }
-
-  render().catch(console.error)
-}

bin/now-billing.js

@@ -1,378 +0,0 @@
-#!/usr/bin/env node
-
-// Native
-const { resolve } = require('path')
-
-// Packages
-const chalk = require('chalk')
-const minimist = require('minimist')
-const ms = require('ms')
-
-// Ours
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const { error } = require('../lib/error')
-const NowCreditCards = require('../lib/credit-cards')
-const indent = require('../lib/indent')
-const listInput = require('../lib/utils/input/list')
-const success = require('../lib/utils/output/success')
-const promptBool = require('../lib/utils/input/prompt-bool')
-const info = require('../lib/utils/output/info')
-const logo = require('../lib/utils/output/logo')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    token: 't'
-  }
-})
-
-const subcommand = argv._[0]
-
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now billing`)} <ls | add | rm | set-default>
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Lists all your credit cards:
-
-      ${chalk.cyan('$ now billing ls')}
-
-  ${chalk.gray('–')} Adds a credit card (interactively):
-
-      ${chalk.cyan(`$ now billing add`)}
-
-  ${chalk.gray('–')} Removes a credit card:
-
-      ${chalk.cyan(`$ now billing rm <id>`)}
-
-      ${chalk.gray('–')} If the id is omitted, you can choose interactively
-
-  ${chalk.gray('–')} Selects your default credit card:
-
-      ${chalk.cyan(`$ now billing set-default <id>`)}
-
-      ${chalk.gray('–')} If the id is omitted, you can choose interactively
-  `)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-const exit = code => {
-  // We give stdout some time to flush out
-  // because there's a node bug where
-  // stdout writes are asynchronous
-  // https://github.com/nodejs/node/issues/6456
-  setTimeout(() => process.exit(code || 0), 100)
-}
-
-if (argv.help || !subcommand) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-    try {
-      await run({ token, config })
-    } catch (err) {
-      if (err.userError) {
-        error(err.message)
-      } else {
-        error(`Unknown error: ${err.stack}`)
-      }
-      exit(1)
-    }
-  })
-}
-
-// Builds a `choices` object that can be passesd to inquirer.prompt()
-function buildInquirerChoices(cards) {
-  return cards.cards.map(card => {
-    const _default = card.id === cards.defaultCardId
-      ? ' ' + chalk.bold('(default)')
-      : ''
-    const id = `${chalk.cyan(`ID: ${card.id}`)}${_default}`
-    const number = `${chalk.gray('#### ').repeat(3)}${card.last4}`
-    const str = [
-      id,
-      indent(card.name, 2),
-      indent(`${card.brand} ${number}`, 2)
-    ].join('\n')
-
-    return {
-      name: str, // Will be displayed by Inquirer
-      value: card.id, // Will be used to identify the answer
-      short: card.id // Will be displayed after the users answers
-    }
-  })
-}
-
-async function run({ token, config: { currentTeam, user } }) {
-  const start = new Date()
-  const creditCards = new NowCreditCards({ apiUrl, token, debug, currentTeam })
-  const args = argv._.slice(1)
-
-  switch (subcommand) {
-    case 'ls':
-    case 'list': {
-      let cards
-      try {
-        cards = await creditCards.ls()
-      } catch (err) {
-        error(err.message)
-        return
-      }
-      const text = cards.cards
-        .map(card => {
-          const _default = card.id === cards.defaultCardId
-            ? ' ' + chalk.bold('(default)')
-            : ''
-          const id = `${chalk.gray('-')} ${chalk.cyan(
-            `ID: ${card.id}`
-          )}${_default}`
-          const number = `${chalk.gray('#### ').repeat(3)}${card.last4}`
-          let address = card.address_line1
-
-          if (card.address_line2) {
-            address += `, ${card.address_line2}.`
-          } else {
-            address += '.'
-          }
-
-          address += `\n${card.address_city}, `
-
-          if (card.address_state) {
-            address += `${card.address_state}, `
-          }
-
-          // Stripe is returning a two digit code for the country,
-          // but we want the full country name
-          address += `${card.address_zip}. ${card.address_country}`
-
-          return [
-            id,
-            indent(card.name, 2),
-            indent(`${card.brand} ${number}`, 2),
-            indent(address, 2)
-          ].join('\n')
-        })
-        .join('\n\n')
-
-      const elapsed = ms(new Date() - start)
-      console.log(
-        `> ${cards.cards.length} card${cards.cards.length === 1
-          ? ''
-          : 's'} found under ${chalk.bold(
-          (currentTeam && currentTeam.slug) || user.username || user.email
-        )} ${chalk.gray(`[${elapsed}]`)}`
-      )
-      if (text) {
-        console.log(`\n${text}\n`)
-      }
-
-      break
-    }
-
-    case 'set-default': {
-      if (args.length > 1) {
-        error('Invalid number of arguments')
-        return exit(1)
-      }
-
-      const start = new Date()
-
-      let cards
-      try {
-        cards = await creditCards.ls()
-      } catch (err) {
-        error(err.message)
-        return
-      }
-
-      if (cards.cards.length === 0) {
-        error('You have no credit cards to choose from')
-        return exit(0)
-      }
-
-      let cardId = args[0]
-
-      if (cardId === undefined) {
-        const elapsed = ms(new Date() - start)
-        const message = `Selecting a new default payment card for ${chalk.bold(
-          (currentTeam && currentTeam.slug) || user.username || user.email
-        )} ${chalk.gray(`[${elapsed}]`)}`
-        const choices = buildInquirerChoices(cards)
-
-        cardId = await listInput({
-          message,
-          choices,
-          separator: true,
-          abort: 'end'
-        })
-      }
-
-      // Check if the provided cardId (in case the user
-      // typed `now billing set-default <some-id>`) is valid
-      if (cardId) {
-        const label = `Are you sure that you to set this card as the default?`
-        const confirmation = await promptBool(label, {
-          trailing: '\n'
-        })
-        if (!confirmation) {
-          info('Aborted')
-          break
-        }
-        const start = new Date()
-        await creditCards.setDefault(cardId)
-
-        const card = cards.cards.find(card => card.id === cardId)
-        const elapsed = ms(new Date() - start)
-        success(
-          `${card.brand} ending in ${card.last4} is now the default ${chalk.gray(
-            `[${elapsed}]`
-          )}`
-        )
-      } else {
-        console.log('No changes made')
-      }
-
-      break
-    }
-
-    case 'rm':
-    case 'remove': {
-      if (args.length > 1) {
-        error('Invalid number of arguments')
-        return exit(1)
-      }
-
-      const start = new Date()
-      let cards
-      try {
-        cards = await creditCards.ls()
-      } catch (err) {
-        error(err.message)
-        return
-      }
-
-      if (cards.cards.length === 0) {
-        error(
-          `You have no credit cards to choose from to delete under ${chalk.bold(
-            (currentTeam && currentTeam.slug) || user.username || user.email
-          )}`
-        )
-        return exit(0)
-      }
-
-      let cardId = args[0]
-
-      if (cardId === undefined) {
-        const elapsed = ms(new Date() - start)
-        const message = `Selecting a card to ${chalk.underline(
-          'remove'
-        )} under ${chalk.bold(
-          (currentTeam && currentTeam.slug) || user.username || user.email
-        )} ${chalk.gray(`[${elapsed}]`)}`
-        const choices = buildInquirerChoices(cards)
-
-        cardId = await listInput({
-          message,
-          choices,
-          separator: true,
-          abort: 'start'
-        })
-      }
-
-      // Shoud check if the provided cardId (in case the user
-      // typed `now billing rm <some-id>`) is valid
-      if (cardId) {
-        const label = `Are you sure that you want to remove this card?`
-        const confirmation = await promptBool(label)
-        if (!confirmation) {
-          console.log('Aborted')
-          break
-        }
-        const start = new Date()
-        await creditCards.rm(cardId)
-
-        const deletedCard = cards.cards.find(card => card.id === cardId)
-        const remainingCards = cards.cards.filter(card => card.id !== cardId)
-
-        let text = `${deletedCard.brand} ending in ${deletedCard.last4} was deleted`
-        //  ${chalk.gray(`[${elapsed}]`)}
-
-        if (cardId === cards.defaultCardId) {
-          if (remainingCards.length === 0) {
-            // The user deleted the last card in their account
-            text += `\n${chalk.yellow('Warning!')} You have no default card`
-          } else {
-            // We can't guess the current default card – let's ask the API
-            const cards = await creditCards.ls()
-            const newDefaultCard = cards.cards.find(
-              card => card.id === cards.defaultCardId
-            )
-
-            text += `\n${newDefaultCard.brand} ending in ${newDefaultCard.last4} in now default for ${chalk.bold(
-              (currentTeam && currentTeam.slug) || user.username || user.email
-            )}`
-          }
-        }
-
-        const elapsed = ms(new Date() - start)
-        text += ` ${chalk.gray(`[${elapsed}]`)}`
-        success(text)
-      } else {
-        console.log('No changes made')
-      }
-
-      break
-    }
-
-    case 'add': {
-      require(resolve(__dirname, 'now-billing-add.js'))({
-        creditCards,
-        currentTeam,
-        user
-      })
-
-      break
-    }
-
-    default:
-      error('Please specify a valid subcommand: ls | add | rm | set-default')
-      help()
-      exit(1)
-  }
-
-  creditCards.close()
-}

bin/now-certs.js

@@ -1,379 +0,0 @@
-#!/usr/bin/env node
-
-// Native
-const path = require('path')
-
-// Packages
-const chalk = require('chalk')
-const table = require('text-table')
-const minimist = require('minimist')
-const fs = require('fs-extra')
-const ms = require('ms')
-const printf = require('printf')
-require('epipebomb')()
-const supportsColor = require('supports-color')
-
-// Ours
-const cfg = require('../lib/cfg')
-const { handleError, error } = require('../lib/error')
-const NowCerts = require('../lib/certs')
-const login = require('../lib/login')
-const exit = require('../lib/utils/exit')
-const logo = require('../lib/utils/output/logo')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token', 'crt', 'key', 'ca'],
-  boolean: ['help', 'debug'],
-  alias: { help: 'h', config: 'c', debug: 'd', token: 't' }
-})
-
-const subcommand = argv._[0]
-
-// Options
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now certs`)} <ls | create | renew | replace | rm> <cn>
-
-  ${chalk.dim('Note:')}
-
-  This command is intended for advanced use only, normally ${chalk.bold(
-    'now'
-  )} manages your certificates automatically.
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-    --crt ${chalk.bold.underline('FILE')}              Certificate file
-    --key ${chalk.bold.underline('FILE')}              Certificate key file
-    --ca ${chalk.bold.underline('FILE')}               CA certificate chain file
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Listing all your certificates:
-
-      ${chalk.cyan('$ now certs ls')}
-
-  ${chalk.gray('–')} Creating a new certificate:
-
-      ${chalk.cyan('$ now certs create domain.com')}
-
-  ${chalk.gray('–')} Renewing an existing certificate issued with ${chalk.bold(
-    'now'
-  )}:
-
-      ${chalk.cyan('$ now certs renew domain.com')}
-
-  ${chalk.gray(
-    '–'
-  )} Replacing an existing certificate with a user-supplied certificate:
-
-      ${chalk.cyan(
-        '$ now certs replace --crt domain.crt --key domain.key --ca ca_chain.crt domain.com'
-      )}
-`)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-if (argv.help || !subcommand) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-
-    try {
-      await run({ token, config })
-    } catch (err) {
-      handleError(err)
-      exit(1)
-    }
-  })
-}
-
-function formatExpirationDate(date) {
-  const diff = date - Date.now()
-  return diff < 0
-    ? chalk.gray(ms(-diff) + ' ago')
-    : chalk.gray('in ' + ms(diff))
-}
-
-async function run({ token, config: { currentTeam, user } }) {
-  const certs = new NowCerts({ apiUrl, token, debug, currentTeam })
-  const args = argv._.slice(1)
-  const start = Date.now()
-
-  if (subcommand === 'ls' || subcommand === 'list') {
-    if (args.length !== 0) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan('`now certs ls`')}`
-      )
-      return exit(1)
-    }
-
-    const list = await certs.ls()
-    const elapsed = ms(new Date() - start)
-
-    console.log(
-      `> ${list.length} certificate${list.length === 1
-        ? ''
-        : 's'} found ${chalk.gray(`[${elapsed}]`)} under ${chalk.bold(
-        (currentTeam && currentTeam.slug) || user.username || user.email
-      )}`
-    )
-
-    if (list.length > 0) {
-      const cur = Date.now()
-      list.sort((a, b) => {
-        return a.cn.localeCompare(b.cn)
-      })
-
-      const maxCnLength =
-        list.reduce((acc, i) => {
-          return Math.max(acc, (i.cn && i.cn.length) || 0)
-        }, 0) + 1
-
-      console.log(
-        chalk.dim(
-          printf(
-            `  %-${maxCnLength}s %-8s  %-10s  %-10s`,
-            'cn',
-            'created',
-            'expiration',
-            'auto-renew'
-          )
-        )
-      )
-
-      list.forEach(cert => {
-        const cn = chalk.bold(cert.cn)
-        const time = chalk.gray(ms(cur - new Date(cert.created)) + ' ago')
-        const expiration = formatExpirationDate(new Date(cert.expiration))
-        const autoRenew = cert.autoRenew ? 'yes' : 'no'
-        let spec
-        if (supportsColor) {
-          spec = `  %-${maxCnLength + 9}s %-18s  %-20s  %-20s\n`
-        } else {
-          spec = `  %-${maxCnLength}s %-8s  %-10s  %-10s\n`
-        }
-        process.stdout.write(printf(spec, cn, time, expiration, autoRenew))
-      })
-    }
-  } else if (subcommand === 'create') {
-    if (args.length !== 1) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan(
-          '`now certs create <cn>`'
-        )}`
-      )
-      return exit(1)
-    }
-    const cn = args[0]
-    let cert
-
-    if (argv.crt || argv.key || argv.ca) {
-      // Issue a custom certificate
-      if (!argv.crt || !argv.key) {
-        error(
-          `Missing required arguments for a custom certificate entry. Usage: ${chalk.cyan(
-            '`now certs create --crt DOMAIN.CRT --key DOMAIN.KEY [--ca CA.CRT] <id | cn>`'
-          )}`
-        )
-        return exit(1)
-      }
-
-      const crt = readX509File(argv.crt)
-      const key = readX509File(argv.key)
-      const ca = argv.ca ? readX509File(argv.ca) : ''
-
-      cert = await certs.put(cn, crt, key, ca)
-    } else {
-      // Issue a standard certificate
-      cert = await certs.create(cn)
-    }
-    if (!cert) {
-      // Cert is undefined and "Cert is already issued" has been printed to stdout
-      return exit(1)
-    }
-    const elapsed = ms(new Date() - start)
-    console.log(
-      `${chalk.cyan('> Success!')} Certificate entry ${chalk.bold(
-        cn
-      )} ${chalk.gray(`(${cert.uid})`)} created ${chalk.gray(`[${elapsed}]`)}`
-    )
-  } else if (subcommand === 'renew') {
-    if (args.length !== 1) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan(
-          '`now certs renew <id | cn>`'
-        )}`
-      )
-      return exit(1)
-    }
-
-    const cert = await getCertIdCn(certs, args[0], currentTeam, user)
-    if (!cert) {
-      return exit(1)
-    }
-    const yes = await readConfirmation(
-      cert,
-      'The following certificate will be renewed\n'
-    )
-
-    if (!yes) {
-      error('User abort')
-      return exit(0)
-    }
-
-    await certs.renew(cert.cn)
-    const elapsed = ms(new Date() - start)
-    console.log(
-      `${chalk.cyan('> Success!')} Certificate ${chalk.bold(
-        cert.cn
-      )} ${chalk.gray(`(${cert.uid})`)} renewed ${chalk.gray(`[${elapsed}]`)}`
-    )
-  } else if (subcommand === 'replace') {
-    if (!argv.crt || !argv.key) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan(
-          '`now certs replace --crt DOMAIN.CRT --key DOMAIN.KEY [--ca CA.CRT] <id | cn>`'
-        )}`
-      )
-      return exit(1)
-    }
-
-    const crt = readX509File(argv.crt)
-    const key = readX509File(argv.key)
-    const ca = argv.ca ? readX509File(argv.ca) : ''
-
-    const cert = await getCertIdCn(certs, args[0], currentTeam, user)
-    if (!cert) {
-      return exit(1)
-    }
-    const yes = await readConfirmation(
-      cert,
-      'The following certificate will be replaced permanently\n'
-    )
-    if (!yes) {
-      error('User abort')
-      return exit(0)
-    }
-
-    await certs.put(cert.cn, crt, key, ca)
-    const elapsed = ms(new Date() - start)
-    console.log(
-      `${chalk.cyan('> Success!')} Certificate ${chalk.bold(
-        cert.cn
-      )} ${chalk.gray(`(${cert.uid})`)} replaced ${chalk.gray(`[${elapsed}]`)}`
-    )
-  } else if (subcommand === 'rm' || subcommand === 'remove') {
-    if (args.length !== 1) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan(
-          '`now certs rm <id | cn>`'
-        )}`
-      )
-      return exit(1)
-    }
-
-    const cert = await getCertIdCn(certs, args[0], currentTeam, user)
-    if (!cert) {
-      return exit(1)
-    }
-    const yes = await readConfirmation(
-      cert,
-      'The following certificate will be removed permanently\n'
-    )
-    if (!yes) {
-      error('User abort')
-      return exit(0)
-    }
-
-    await certs.delete(cert.cn)
-    const elapsed = ms(new Date() - start)
-    console.log(
-      `${chalk.cyan('> Success!')} Certificate ${chalk.bold(
-        cert.cn
-      )} ${chalk.gray(`(${cert.uid})`)} removed ${chalk.gray(`[${elapsed}]`)}`
-    )
-  } else {
-    error(
-      'Please specify a valid subcommand: ls | create | renew | replace | rm'
-    )
-    help()
-    exit(1)
-  }
-  return certs.close()
-}
-
-process.on('uncaughtException', err => {
-  handleError(err)
-  exit(1)
-})
-
-function readConfirmation(cert, msg) {
-  return new Promise(resolve => {
-    const time = chalk.gray(ms(new Date() - new Date(cert.created)) + ' ago')
-    const tbl = table([[cert.uid, chalk.bold(cert.cn), time]], {
-      align: ['l', 'r', 'l'],
-      hsep: ' '.repeat(6)
-    })
-
-    process.stdout.write(`> ${msg}`)
-    process.stdout.write('  ' + tbl + '\n')
-
-    process.stdout.write(
-      `${chalk.bold.red('> Are you sure?')} ${chalk.gray('[y/N] ')}`
-    )
-
-    process.stdin
-      .on('data', d => {
-        process.stdin.pause()
-        resolve(d.toString().trim().toLowerCase() === 'y')
-      })
-      .resume()
-  })
-}
-
-function readX509File(file) {
-  return fs.readFileSync(path.resolve(file), 'utf8')
-}
-
-async function getCertIdCn(certs, idOrCn, currentTeam, user) {
-  const list = await certs.ls()
-  const thecert = list.filter(cert => {
-    return cert.uid === idOrCn || cert.cn === idOrCn
-  })[0]
-
-  if (!thecert) {
-    error(
-      `No certificate found by id or cn "${idOrCn}" under ${chalk.bold(
-        (currentTeam && currentTeam.slug) || user.username || user.email
-      )}`
-    )
-    return null
-  }
-
-  return thecert
-}

bin/now-deploy.js

@@ -1,829 +0,0 @@
-#!/usr/bin/env node
-
-// Native
-const { resolve } = require('path')
-
-// Packages
-const Progress = require('progress')
-const fs = require('fs-extra')
-const bytes = require('bytes')
-const chalk = require('chalk')
-const minimist = require('minimist')
-const ms = require('ms')
-const flatten = require('arr-flatten')
-const dotenv = require('dotenv')
-const { eraseLines } = require('ansi-escapes')
-const { write: copy } = require('clipboardy')
-
-// Ours
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const { version } = require('../lib/pkg')
-const Logger = require('../lib/build-logger')
-const Now = require('../lib')
-const toHumanPath = require('../lib/utils/to-human-path')
-const { handleError, error } = require('../lib/error')
-const { fromGit, isRepoPath, gitPathParts } = require('../lib/git')
-const readMetaData = require('../lib/read-metadata')
-const checkPath = require('../lib/utils/check-path')
-const { reAlias, assignAlias } = require('../lib/re-alias')
-const exit = require('../lib/utils/exit')
-const logo = require('../lib/utils/output/logo')
-const cmd = require('../lib/utils/output/cmd')
-const info = require('../lib/utils/output/info')
-const wait = require('../lib/utils/output/wait')
-const NowPlans = require('../lib/plans')
-const promptBool = require('../lib/utils/input/prompt-bool')
-const promptOptions = require('../lib/utils/input/prompt-options')
-const note = require('../lib/utils/output/note')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token', 'name', 'alias', 'session-affinity'],
-  boolean: [
-    'help',
-    'version',
-    'debug',
-    'force',
-    'links',
-    'login',
-    'no-clipboard',
-    'forward-npm',
-    'docker',
-    'npm',
-    'static'
-  ],
-  alias: {
-    env: 'e',
-    dotenv: 'E',
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    version: 'v',
-    force: 'f',
-    token: 't',
-    forceSync: 'F',
-    links: 'l',
-    login: 'L',
-    public: 'p',
-    'no-clipboard': 'C',
-    'forward-npm': 'N',
-    'session-affinity': 'S',
-    name: 'n',
-    alias: 'a'
-  }
-})
-
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now`)} [options] <command | path>
-
-  ${chalk.dim('Commands:')}
-
-    ${chalk.dim('Cloud')}
-
-      deploy               [path]      Performs a deployment ${chalk.bold(
-        '(default)'
-      )}
-      ls | list            [app]       List deployments
-      rm | remove          [id]        Remove a deployment
-      ln | alias           [id] [url]  Configures aliases for deployments
-      domains              [name]      Manages your domain names
-      certs                [cmd]       Manages your SSL certificates
-      secrets              [name]      Manages your secret environment variables
-      dns                  [name]      Manages your DNS records
-      logs                 [url]       Displays the logs for a deployment
-      scale                [args]      Scales the instance count of a deployment
-      help                 [cmd]       Displays complete help for [cmd]
-
-    ${chalk.dim('Administrative')}
-
-      billing | cc         [cmd]       Manages your credit cards and billing methods
-      upgrade | downgrade  [plan]      Upgrades or downgrades your plan
-      teams                [team]      Manages your teams
-      switch                           Switches between teams and your account
-      login                            Login into your account or creates a new one
-      logout                           Logout from your account
-
-  ${chalk.dim('Options:')}
-
-    -h, --help                Output usage information
-    -v, --version             Output the version number
-    -n, --name                Set the name of the deployment
-    -c ${chalk.underline('FILE')}, --config=${chalk.underline(
-    'FILE'
-  )}    Config file
-    -d, --debug               Debug mode [off]
-    -f, --force               Force a new deployment even if nothing has changed
-    -t ${chalk.underline('TOKEN')}, --token=${chalk.underline(
-    'TOKEN'
-  )}   Login token
-    -L, --login               Configure login
-    -l, --links               Copy symlinks without resolving their target
-    -p, --public              Deployment is public (${chalk.dim(
-      '`/_src`'
-    )} is exposed) [on for oss, off for premium]
-    -e, --env                 Include an env var (e.g.: ${chalk.dim(
-      '`-e KEY=value`'
-    )}). Can appear many times.
-    -E ${chalk.underline('FILE')}, --dotenv=${chalk.underline(
-    'FILE'
-  )}    Include env vars from .env file. Defaults to '.env'
-    -C, --no-clipboard        Do not attempt to copy URL to clipboard
-    -N, --forward-npm         Forward login information to install private npm modules
-    --session-affinity        Session affinity, \`ip\` (default) or \`random\` to control session affinity.
-
-  ${chalk.dim(
-    'Enforcable Types (when both package.json and Dockerfile exist):'
-  )}
-
-    --npm                     Node.js application
-    --docker                  Docker container
-    --static                  Static file hosting
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Deploys the current directory
-
-    ${chalk.cyan('$ now')}
-
-  ${chalk.gray('–')} Deploys a custom path ${chalk.dim('`/usr/src/project`')}
-
-    ${chalk.cyan('$ now /usr/src/project')}
-
-  ${chalk.gray('–')} Deploys a GitHub repository
-
-    ${chalk.cyan('$ now user/repo#ref')}
-
-  ${chalk.gray('–')} Deploys a GitHub, GitLab or Bitbucket repo using its URL
-
-    ${chalk.cyan('$ now https://gitlab.com/user/repo')}
-
-  ${chalk.gray('–')} Deploys with ENV vars
-
-    ${chalk.cyan(
-      '$ now -e NODE_ENV=production -e MYSQL_PASSWORD=@mysql-password'
-    )}
-
-  ${chalk.gray('–')} Displays comprehensive help for the subcommand ${chalk.dim(
-    '`list`'
-  )}
-
-    ${chalk.cyan('$ now help list')}
-`)
-}
-
-let path = argv._[0]
-
-if (path) {
-  // If path is relative: resolve
-  // if path is absolute: clear up strange `/` etc
-  path = resolve(process.cwd(), path)
-} else {
-  path = process.cwd()
-}
-
-// If the current deployment is a repo
-const gitRepo = {}
-
-// Options
-let forceNew = argv.force
-let deploymentName = argv.name
-let sessionAffinity = argv['session-affinity']
-const debug = argv.debug
-const clipboard = !argv['no-clipboard']
-const forwardNpm = argv['forward-npm']
-const forceSync = argv.forceSync
-const shouldLogin = argv.login
-const followSymlinks = !argv.links
-const wantsPublic = argv.public
-const apiUrl = argv.url || 'https://api.zeit.co'
-const isTTY = process.stdout.isTTY
-const quiet = !isTTY
-const autoAliases = typeof argv.alias === 'undefined'
-  ? false
-  : flatten([argv.alias])
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-if (Array.isArray(autoAliases)) {
-  console.log(
-    `${chalk.red('Deprecated!')} The option ${chalk.grey(
-      '--alias'
-    )} will be removed soon.`
-  )
-  console.log('Read more about the new way here: http://bit.ly/2l2v5Fg\n')
-}
-
-const stopDeployment = msg => {
-  handleError(msg)
-  process.exit(1)
-}
-
-// Create a new deployment if user changed the name or made `_src` public.
-// This works fine because it doesn't force a new sync,
-// it just forces a new deployment.
-if (deploymentName || wantsPublic) {
-  forceNew = true
-}
-
-let alwaysForwardNpm
-
-async function main() {
-  let config = await cfg.read({ token: argv.token })
-  alwaysForwardNpm = config.forwardNpm
-
-  if (argv.h || argv.help) {
-    help()
-    return exit(0)
-  } else if (argv.v || argv.version) {
-    console.log(version)
-    return exit(0)
-  }
-
-  let token = argv.token || config.token
-  if (!token || shouldLogin) {
-    try {
-      token = await login(apiUrl)
-      config = await cfg.read()
-    } catch (err) {
-      return stopDeployment(`Authentication error – ${err.message}`)
-    }
-
-    console.log(
-      `> Logged in successfully. Token saved to ${chalk.bold('~/.now.json')}.`
-    )
-    console.log(
-      `> Run ${cmd('now')} to deploy the current directory, or ${cmd(
-        'now --help'
-      )} for usage info.\n`
-    )
-    return exit(0)
-  }
-
-  // If we got to here then `token` should be set
-  try {
-    await sync({ token, config })
-  } catch (err) {
-    return stopDeployment(err)
-  }
-}
-
-async function sync({ token, config: { currentTeam, user } }) {
-  const start = Date.now()
-  const rawPath = argv._[0]
-
-  const planPromise = new NowPlans({
-    apiUrl,
-    token,
-    debug,
-    currentTeam
-  }).getCurrent()
-
-  try {
-    await fs.stat(path)
-  } catch (err) {
-    let repo
-    let isValidRepo = false
-
-    try {
-      isValidRepo = isRepoPath(rawPath)
-    } catch (err) {
-      if (err.code === 'INVALID_URL') {
-        stopDeployment(err)
-      } else {
-        throw err
-      }
-    }
-
-    if (isValidRepo) {
-      const gitParts = gitPathParts(rawPath)
-      Object.assign(gitRepo, gitParts)
-
-      const searchMessage = setTimeout(() => {
-        console.log(`> Didn't find directory. Searching on ${gitRepo.type}...`)
-      }, 500)
-
-      try {
-        repo = await fromGit(rawPath, debug)
-      } catch (err) {}
-
-      clearTimeout(searchMessage)
-    }
-
-    if (repo) {
-      // Tell now which directory to deploy
-      path = repo.path
-
-      // Set global variable for deleting tmp dir later
-      // once the deployment has finished
-      Object.assign(gitRepo, repo)
-    } else if (isValidRepo) {
-      const gitRef = gitRepo.ref ? `with "${chalk.bold(gitRepo.ref)}" ` : ''
-      stopDeployment(
-        `There's no repository named "${chalk.bold(
-          gitRepo.main
-        )}" ${gitRef}on ${gitRepo.type}`
-      )
-    } else {
-      stopDeployment(`Could not read directory ${chalk.bold(path)}`)
-    }
-  }
-
-  // Make sure that directory is deployable
-  try {
-    await checkPath(path)
-  } catch (err) {
-    error(err)
-    return
-  }
-
-  if (!quiet) {
-    if (gitRepo.main) {
-      const gitRef = gitRepo.ref ? ` at "${chalk.bold(gitRepo.ref)}" ` : ''
-      console.log(
-        `> Deploying ${gitRepo.type} repository "${chalk.bold(
-          gitRepo.main
-        )}" ${gitRef} under ${chalk.bold(
-          (currentTeam && currentTeam.slug) || user.username || user.email
-        )}`
-      )
-    } else {
-      console.log(
-        `> Deploying ${chalk.bold(toHumanPath(path))} under ${chalk.bold(
-          (currentTeam && currentTeam.slug) || user.username || user.email
-        )}`
-      )
-    }
-  }
-
-  let deploymentType
-
-  // CLI deployment type explicit overrides
-  if (argv.docker) {
-    if (debug) {
-      console.log(`> [debug] Forcing \`deploymentType\` = \`docker\``)
-    }
-
-    deploymentType = 'docker'
-  } else if (argv.npm) {
-    if (debug) {
-      console.log(`> [debug] Forcing \`deploymentType\` = \`npm\``)
-    }
-
-    deploymentType = 'npm'
-  } else if (argv.static) {
-    if (debug) {
-      console.log(`> [debug] Forcing \`deploymentType\` = \`static\``)
-    }
-
-    deploymentType = 'static'
-  }
-
-  let meta
-  ;({ meta, deploymentName, deploymentType, sessionAffinity } = await readMeta(
-    path,
-    deploymentName,
-    deploymentType,
-    sessionAffinity
-  ))
-  const nowConfig = meta.nowConfig
-
-  const now = new Now({ apiUrl, token, debug, currentTeam })
-
-  let dotenvConfig
-  let dotenvOption
-
-  if (argv.dotenv) {
-    dotenvOption = argv.dotenv
-  } else if (nowConfig && nowConfig.dotenv) {
-    dotenvOption = nowConfig.dotenv
-  }
-
-  if (dotenvOption) {
-    const dotenvFileName = typeof dotenvOption === 'string'
-      ? dotenvOption
-      : '.env'
-
-    if (!fs.existsSync(dotenvFileName)) {
-      error(`--dotenv flag is set but ${dotenvFileName} file is missing`)
-      return process.exit(1)
-    }
-
-    const dotenvFile = await fs.readFile(dotenvFileName)
-    dotenvConfig = dotenv.parse(dotenvFile)
-  }
-
-  // Merge `now.env` from package.json with `-e` arguments.
-  const pkgEnv = nowConfig && nowConfig.env
-  const envs = [
-    ...Object.keys(dotenvConfig || {}).map(k => `${k}=${dotenvConfig[k]}`),
-    ...Object.keys(pkgEnv || {}).map(k => `${k}=${pkgEnv[k]}`),
-    ...[].concat(argv.env || [])
-  ]
-
-  let secrets
-  const findSecret = async uidOrName => {
-    if (!secrets) {
-      secrets = await now.listSecrets()
-    }
-
-    return secrets.filter(secret => {
-      return secret.name === uidOrName || secret.uid === uidOrName
-    })
-  }
-
-  const env_ = await Promise.all(
-    envs.map(async kv => {
-      if (typeof kv !== 'string') {
-        error('Env key and value missing')
-        return process.exit(1)
-      }
-
-      const [key, ...rest] = kv.split('=')
-      let val
-
-      if (rest.length > 0) {
-        val = rest.join('=')
-      }
-
-      if (/[^A-z0-9_]/i.test(key)) {
-        error(
-          `Invalid ${chalk.dim('-e')} key ${chalk.bold(
-            `"${chalk.bold(key)}"`
-          )}. Only letters, digits and underscores are allowed.`
-        )
-        return process.exit(1)
-      }
-
-      if (!key) {
-        error(`Invalid env option ${chalk.bold(`"${kv}"`)}`)
-        return process.exit(1)
-      }
-
-      if (val === undefined) {
-        if (key in process.env) {
-          console.log(
-            `> Reading ${chalk.bold(
-              `"${chalk.bold(key)}"`
-            )} from your env (as no value was specified)`
-          )
-          // Escape value if it begins with @
-          val = process.env[key].replace(/^@/, '\\@')
-        } else {
-          error(
-            `No value specified for env ${chalk.bold(
-              `"${chalk.bold(key)}"`
-            )} and it was not found in your env.`
-          )
-          return process.exit(1)
-        }
-      }
-
-      if (val[0] === '@') {
-        const uidOrName = val.substr(1)
-        const secrets = await findSecret(uidOrName)
-        if (secrets.length === 0) {
-          if (uidOrName === '') {
-            error(
-              `Empty reference provided for env key ${chalk.bold(
-                `"${chalk.bold(key)}"`
-              )}`
-            )
-          } else {
-            error(
-              `No secret found by uid or name ${chalk.bold(`"${uidOrName}"`)}`
-            )
-          }
-          return process.exit(1)
-        } else if (secrets.length > 1) {
-          error(
-            `Ambiguous secret ${chalk.bold(
-              `"${uidOrName}"`
-            )} (matches ${chalk.bold(secrets.length)} secrets)`
-          )
-          return process.exit(1)
-        }
-
-        val = { uid: secrets[0].uid }
-      }
-
-      return [key, typeof val === 'string' ? val.replace(/^\\@/, '@') : val]
-    })
-  )
-
-  const env = {}
-  env_.filter(v => Boolean(v)).forEach(([key, val]) => {
-    if (key in env) {
-      note(`Overriding duplicate env key ${chalk.bold(`"${key}"`)}`)
-    }
-
-    env[key] = val
-  })
-
-  try {
-    await now.create(
-      path,
-      Object.assign(
-        {
-          env,
-          followSymlinks,
-          forceNew,
-          forceSync,
-          forwardNpm: alwaysForwardNpm || forwardNpm,
-          quiet,
-          wantsPublic,
-          sessionAffinity
-        },
-        meta
-      )
-    )
-  } catch (err) {
-    if (debug) {
-      console.log(`> [debug] error: ${err}\n${err.stack}`)
-    }
-
-    return stopDeployment(err)
-  }
-
-  const { url } = now
-  const elapsed = ms(new Date() - start)
-
-  if (isTTY) {
-    if (clipboard) {
-      try {
-        await copy(url)
-        console.log(
-          `${chalk.cyan('> Ready!')} ${chalk.bold(
-            url
-          )} (copied to clipboard) [${elapsed}]`
-        )
-      } catch (err) {
-        console.log(`${chalk.cyan('> Ready!')} ${chalk.bold(url)} [${elapsed}]`)
-      }
-    } else {
-      console.log(`> ${url} [${elapsed}]`)
-    }
-  } else {
-    process.stdout.write(url)
-  }
-
-  const startU = new Date()
-
-  const complete = ({ syncCount }) => {
-    if (!quiet) {
-      const elapsedU = ms(new Date() - startU)
-      console.log(
-        `> Synced ${syncCount} (${bytes(now.syncAmount)}) [${elapsedU}] `
-      )
-      console.log('> Initializing…')
-    }
-
-    // Close http2 agent
-    now.close()
-
-    // Show build logs
-    if (!quiet) {
-      if (deploymentType === 'static') {
-        console.log(`${chalk.cyan('> Deployment complete!')}`)
-      } else {
-        printLogs(now.host, token, currentTeam, user)
-      }
-    }
-  }
-
-  const plan = await planPromise
-
-  if (plan.id === 'oss' && !wantsPublic) {
-    if (isTTY) {
-      info(
-        `${chalk.bold(
-          (currentTeam && `${currentTeam.slug} is`) ||
-            `You (${user.username || user.email}) are`
-        )} on the OSS plan. Your code and logs will be made ${chalk.bold(
-          'public'
-        )}.`
-      )
-
-      const proceed = await promptBool(
-        'Are you sure you want to proceed with the deployment?',
-        { trailing: eraseLines(1) }
-      )
-
-      if (proceed) {
-        note(`You can use ${cmd('now --public')} to skip this prompt`)
-      } else {
-        const stopSpinner = wait('Canceling deployment')
-        await now.remove(now.id, { hard: true })
-        stopSpinner()
-        info('Deployment aborted. No files were synced.')
-        info(`You can upgrade by running ${cmd('now upgrade')}.`)
-        return exit()
-      }
-    } else if (!wantsPublic) {
-      const msg =
-        '\nYou are on the OSS plan. Your code and logs will be made public.' +
-        ' If you agree with that, please run again with --public.'
-      return stopDeployment(msg)
-    }
-  }
-
-  if (now.syncAmount) {
-    if (debug && now.syncFileCount !== now.fileCount) {
-      console.log(
-        `> [debug] total files ${now.fileCount}, ${now.syncFileCount} changed. `
-      )
-    }
-    const size = bytes(now.syncAmount)
-    const syncCount = `${now.syncFileCount} file${now.syncFileCount > 1
-      ? 's'
-      : ''}`
-    const bar = new Progress(
-      `> Upload [:bar] :percent :etas (${size}) [${syncCount}]`,
-      {
-        width: 20,
-        complete: '=',
-        incomplete: '',
-        total: now.syncAmount,
-        clear: true
-      }
-    )
-
-    now.upload()
-
-    now.on('upload', ({ names, data }) => {
-      const amount = data.length
-      if (debug) {
-        console.log(
-          `> [debug] Uploaded: ${names.join(' ')} (${bytes(data.length)})`
-        )
-      }
-      bar.tick(amount)
-    })
-
-    now.on('complete', () => complete({ syncCount }))
-
-    now.on('error', err => {
-      error('Upload failed')
-      return stopDeployment(err)
-    })
-  } else {
-    if (!quiet) {
-      console.log(`> Initializing…`)
-    }
-
-    // Close http2 agent
-    now.close()
-
-    // Show build logs
-    if (!quiet) {
-      if (deploymentType === 'static') {
-        console.log(`${chalk.cyan('> Deployment complete!')}`)
-      } else {
-        printLogs(now.host, token, currentTeam, user)
-      }
-    }
-  }
-}
-
-async function readMeta(path, deploymentName, deploymentType, sessionAffinity) {
-  try {
-    const meta = await readMetaData(path, {
-      deploymentType,
-      deploymentName,
-      quiet: true,
-      sessionAffinity
-    })
-
-    if (!deploymentType) {
-      deploymentType = meta.type
-
-      if (debug) {
-        console.log(
-          `> [debug] Detected \`deploymentType\` = \`${deploymentType}\``
-        )
-      }
-    }
-
-    if (!deploymentName) {
-      deploymentName = meta.name
-
-      if (debug) {
-        console.log(
-          `> [debug] Detected \`deploymentName\` = "${deploymentName}"`
-        )
-      }
-    }
-
-    return {
-      meta,
-      deploymentName,
-      deploymentType,
-      sessionAffinity
-    }
-  } catch (err) {
-    if (isTTY && err.code === 'MULTIPLE_MANIFESTS') {
-      if (debug) {
-        console.log('> [debug] Multiple manifests found, disambiguating')
-      }
-
-      console.log(
-        `> Two manifests found. Press [${chalk.bold(
-          'n'
-        )}] to deploy or re-run with --flag`
-      )
-
-      deploymentType = await promptOptions([
-        ['npm', `${chalk.bold('package.json')}\t${chalk.gray('   --npm')} `],
-        ['docker', `${chalk.bold('Dockerfile')}\t${chalk.gray('--docker')} `]
-      ])
-
-      if (debug) {
-        console.log(
-          `> [debug] Selected \`deploymentType\` = "${deploymentType}"`
-        )
-      }
-
-      return readMeta(path, deploymentName, deploymentType)
-    }
-    throw err
-  }
-}
-
-function printLogs(host, token, currentTeam, user) {
-  // Log build
-  const logger = new Logger(host, token, { debug, quiet })
-
-  logger.on('error', async err => {
-    if (!quiet) {
-      if (err && err.type === 'BUILD_ERROR') {
-        error(
-          `The build step of your project failed. To retry, run ${cmd(
-            'now --force'
-          )}.`
-        )
-      } else {
-        error('Deployment failed')
-      }
-    }
-
-    if (gitRepo && gitRepo.cleanup) {
-      // Delete temporary directory that contains repository
-      gitRepo.cleanup()
-
-      if (debug) {
-        console.log(`> [debug] Removed temporary repo directory`)
-      }
-    }
-
-    process.exit(1)
-  })
-
-  logger.on('close', async () => {
-    if (Array.isArray(autoAliases)) {
-      const aliasList = autoAliases.filter(item => item !== '')
-
-      if (aliasList.length > 0) {
-        const assignments = []
-
-        for (const alias of aliasList) {
-          assignments.push(
-            assignAlias(alias, token, host, apiUrl, debug, currentTeam, user)
-          )
-        }
-
-        await Promise.all(assignments)
-      } else {
-        await reAlias(
-          token,
-          host,
-          null,
-          help,
-          exit,
-          apiUrl,
-          debug,
-          currentTeam,
-          user
-        )
-      }
-    }
-
-    if (!quiet) {
-      console.log(`${chalk.cyan('> Deployment complete!')}`)
-    }
-
-    if (gitRepo && gitRepo.cleanup) {
-      // Delete temporary directory that contains repository
-      gitRepo.cleanup()
-
-      if (debug) {
-        console.log(`> [debug] Removed temporary repo directory`)
-      }
-    }
-
-    process.exit(0)
-  })
-}
-
-main()

bin/now-dns.js

@@ -1,338 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const chalk = require('chalk')
-const minimist = require('minimist')
-const ms = require('ms')
-const table = require('text-table')
-
-// Ours
-const cfg = require('../lib/cfg')
-const DomainRecords = require('../lib/domain-records')
-const indent = require('../lib/indent')
-const login = require('../lib/login')
-const strlen = require('../lib/strlen')
-const { handleError, error } = require('../lib/error')
-const exit = require('../lib/utils/exit')
-const logo = require('../lib/utils/output/logo')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config'],
-  boolean: ['help', 'debug'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    token: 't'
-  }
-})
-
-const subcommand = argv._[0]
-
-// Options
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now dns ls`)} [domain]
-  ${chalk.bold(
-    `${logo} now dns add`
-  )} <domain> <name> <A | AAAA | ALIAS | CNAME | TXT> <value>
-  ${chalk.bold(`${logo} now dns add`)} <domain> <name> MX <value> <mx_priority>
-  ${chalk.bold(
-    `${logo} now dns add`
-  )} <domain> <name> SRV <priority> <weight> <port> <target>
-  ${chalk.bold(`${logo} now dns rm`)} <id>
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  config file
-    -d, --debug             debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} List all your DNS records
-
-      ${chalk.cyan('$ now dns ls')}
-
-  ${chalk.gray('–')} Add an A record for a subdomain
-
-      ${chalk.cyan(
-        '$ now dns add <YOUR DOMAIN> <SUBDOMAIN NAME> A <RECORD VALUE>'
-      )}
-      ${chalk.cyan('$ now dns add zeit.rocks api A 198.51.100.100')}
-
-  ${chalk.gray('–')} Add an MX record (@ as a name refers to the domain)
-
-      ${chalk.cyan(
-        '$ now dns add <YOUR DOMAIN> @ MX <RECORD VALUE> <PRIORITY>'
-      )}
-      ${chalk.cyan('$ now dns add zeit.rocks @ MX mail.zeit.rocks 10')}
-`)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-if (argv.help || !subcommand) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-
-    try {
-      await run({ token, config })
-    } catch (err) {
-      handleError(err)
-      exit(1)
-    }
-  })
-}
-
-async function run({ token, config: { currentTeam, user } }) {
-  const domainRecords = new DomainRecords({ apiUrl, token, debug, currentTeam })
-  const args = argv._.slice(1)
-  const start = Date.now()
-
-  if (subcommand === 'ls' || subcommand === 'list') {
-    if (args.length > 1) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan(
-          '`now dns ls [domain]`'
-        )}`
-      )
-      return exit(1)
-    }
-
-    const elapsed = ms(new Date() - start)
-    const res = await domainRecords.ls(args[0])
-    const text = []
-    let count = 0
-    res.forEach((records, domain) => {
-      count += records.length
-      if (records.length > 0) {
-        const cur = Date.now()
-        const header = [
-          ['', 'id', 'name', 'type', 'value', 'aux', 'created'].map(s =>
-            chalk.dim(s)
-          )
-        ]
-        const out = table(
-          header.concat(
-            records.map(record => {
-              const time = chalk.gray(
-                ms(cur - new Date(Number(record.created))) + ' ago'
-              )
-              const aux = (() => {
-                if (record.mxPriority !== undefined) return record.mxPriority
-                if (record.priority !== undefined) return record.priority
-                return ''
-              })()
-              return [
-                '',
-                record.id,
-                record.name,
-                record.type,
-                record.value,
-                aux,
-                time
-              ]
-            })
-          ),
-          {
-            align: ['l', 'r', 'l', 'l', 'l', 'l'],
-            hsep: ' '.repeat(2),
-            stringLength: strlen
-          }
-        )
-        text.push(`\n\n${chalk.bold(domain)}\n${indent(out, 2)}`)
-      }
-    })
-    console.log(
-      `> ${count} record${count === 1 ? '' : 's'} found ${chalk.gray(
-        `[${elapsed}]`
-      )} under ${chalk.bold(
-        (currentTeam && currentTeam.slug) || user.username || user.email
-      )}`
-    )
-    console.log(text.join(''))
-  } else if (subcommand === 'add') {
-    const param = parseAddArgs(args)
-    if (!param) {
-      error(
-        `Invalid number of arguments. See: ${chalk.cyan(
-          '`now dns --help`'
-        )} for usage.`
-      )
-      return exit(1)
-    }
-    const record = await domainRecords.create(param.domain, param.data)
-    const elapsed = ms(new Date() - start)
-    console.log(
-      `${chalk.cyan('> Success!')} A new DNS record for domain ${chalk.bold(
-        param.domain
-      )} ${chalk.gray(`(${record.uid})`)} created ${chalk.gray(
-        `[${elapsed}]`
-      )} (${chalk.bold(
-        (currentTeam && currentTeam.slug) || user.username || user.email
-      )})`
-    )
-  } else if (subcommand === 'rm' || subcommand === 'remove') {
-    if (args.length !== 1) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan('`now dns rm <id>`')}`
-      )
-      return exit(1)
-    }
-
-    const record = await domainRecords.getRecord(args[0])
-    if (!record) {
-      error('DNS record not found')
-      return exit(1)
-    }
-
-    const yes = await readConfirmation(
-      record,
-      'The following record will be removed permanently \n'
-    )
-    if (!yes) {
-      error('User abort')
-      return exit(0)
-    }
-
-    await domainRecords.delete(record.domain, record.id)
-    const elapsed = ms(new Date() - start)
-    console.log(
-      `${chalk.cyan('> Success!')} Record ${chalk.gray(
-        `${record.id}`
-      )} removed ${chalk.gray(`[${elapsed}]`)}`
-    )
-  } else {
-    error('Please specify a valid subcommand: ls | add | rm')
-    help()
-    exit(1)
-  }
-  return domainRecords.close()
-}
-
-process.on('uncaughtException', err => {
-  handleError(err)
-  exit(1)
-})
-
-function parseAddArgs(args) {
-  if (!args || args.length < 4) {
-    return null
-  }
-
-  const domain = args[0]
-  const name = args[1] === '@' ? '' : args[1].toString()
-  const type = args[2]
-  const value = args[3]
-
-  if (!(domain && typeof name === 'string' && type)) {
-    return null
-  }
-
-  if (type === 'MX') {
-    if (args.length !== 5) {
-      return null
-    }
-
-    return {
-      domain,
-      data: {
-        name,
-        type,
-        value,
-        mxPriority: args[4]
-      }
-    }
-  } else if (type === 'SRV') {
-    if (args.length !== 7) {
-      return null
-    }
-
-    return {
-      domain,
-      data: {
-        name,
-        type,
-        srv: {
-          priority: value,
-          weight: args[4],
-          port: args[5],
-          target: args[6]
-        }
-      }
-    }
-  }
-
-  if (args.length !== 4) {
-    return null
-  }
-
-  return {
-    domain,
-    data: {
-      name,
-      type,
-      value
-    }
-  }
-}
-
-function readConfirmation(record, msg) {
-  return new Promise(resolve => {
-    const time = chalk.gray(
-      ms(new Date() - new Date(Number(record.created))) + ' ago'
-    )
-    const tbl = table(
-      [
-        [
-          record.id,
-          chalk.bold(
-            `${record.name.length > 0
-              ? record.name + '.'
-              : ''}${record.domain} ${record.type} ${record.value} ${record.mxPriority
-              ? record.mxPriority
-              : ''}`
-          ),
-          time
-        ]
-      ],
-      { align: ['l', 'r', 'l'], hsep: ' '.repeat(6) }
-    )
-
-    process.stdout.write(`> ${msg}`)
-    process.stdout.write('  ' + tbl + '\n')
-
-    process.stdout.write(
-      `${chalk.bold.red('> Are you sure?')} ${chalk.gray('[y/N] ')}`
-    )
-
-    process.stdin
-      .on('data', d => {
-        process.stdin.pause()
-        resolve(d.toString().trim().toLowerCase() === 'y')
-      })
-      .resume()
-  })
-}

bin/now-domains.js

@@ -1,395 +0,0 @@
-#!/usr/bin/env node
-
-// Native
-const { resolve } = require('path')
-
-// Packages
-const chalk = require('chalk')
-const minimist = require('minimist')
-const table = require('text-table')
-const ms = require('ms')
-
-// Ours
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const { error } = require('../lib/error')
-const toHost = require('../lib/to-host')
-const strlen = require('../lib/strlen')
-const NowDomains = require('../lib/domains')
-const exit = require('../lib/utils/exit')
-const logo = require('../lib/utils/output/logo')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug', 'external', 'force'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    external: 'e',
-    force: 'f',
-    token: 't'
-  }
-})
-
-const subcommand = argv._[0]
-
-// Options
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now domains`)} <ls | add | rm | buy> <domain>
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -e, --external          Use external DNS server
-    -f, --force             Skip DNS verification
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Lists all your domains:
-
-      ${chalk.cyan('$ now domains ls')}
-
-  ${chalk.gray('–')} Buy a new domain:
-
-      ${chalk.cyan(`$ now domains buy ${chalk.underline('domain-name.com')}`)}
-
-  ${chalk.gray('–')} Adds a domain name:
-
-      ${chalk.cyan(`$ now domains add ${chalk.underline('domain-name.com')}`)}
-
-      Make sure the domain's DNS nameservers are at least 2 of these:
-
-      ${chalk.gray('–')} ${chalk.underline(
-    'california.zeit.world'
-  )}    ${chalk.dim('173.255.215.107')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'london.zeit.world'
-  )}        ${chalk.dim('178.62.47.76')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'newark.zeit.world'
-  )}        ${chalk.dim('173.255.231.87')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'amsterdam.zeit.world'
-  )}     ${chalk.dim('188.226.197.55')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'dallas.zeit.world'
-  )}        ${chalk.dim('173.192.101.194')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'paris.zeit.world'
-  )}         ${chalk.dim('37.123.115.172')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'singapore.zeit.world'
-  )}     ${chalk.dim('119.81.97.170')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'sydney.zeit.world'
-  )}        ${chalk.dim('52.64.171.200')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'frankfurt.zeit.world'
-  )}     ${chalk.dim('91.109.245.139')}
-      ${chalk.gray('–')} ${chalk.underline(
-    'iowa.zeit.world'
-  )}          ${chalk.dim('23.236.59.22')}
-
-      ${chalk.yellow('NOTE:')} running ${chalk.dim(
-    '`now alias`'
-  )} will automatically register your domain
-      if it's configured with these nameservers (no need to ${chalk.dim(
-        '`domain add`'
-      )}).
-
-      For more details head to ${chalk.underline('https://zeit.world')}.
-
-  ${chalk.gray('–')} Removing a domain:
-
-      ${chalk.cyan('$ now domain rm my-app.com')}
-
-      or
-
-      ${chalk.cyan('$ now domain rm domainId')}
-
-      To get the list of domain ids, use ${chalk.dim('`now domains ls`')}.
-
-  ${chalk.gray(
-    '–'
-  )} Adding and verifying a domain name using zeit.world nameservers:
-
-      ${chalk.cyan('$ now domain add my-app.com')}
-
-      The command will tell you if the domain was verified succesfully. In case the domain was not verified succesfully you should retry adding the domain after some time.
-
-  ${chalk.gray(
-    '–'
-  )} Adding and verifying a domain name using an external nameserver:
-
-      ${chalk.cyan('$ now domain add -e my-app.com')}
-
-      and follow the verification instructions if requested. Finally, rerun the same command after completing the verification step.
-`)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-if (argv.help || !subcommand) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-    try {
-      await run({ token, config })
-    } catch (err) {
-      if (err.userError) {
-        error(err.message)
-      } else {
-        error(`Unknown error: ${err}\n${err.stack}`)
-      }
-      exit(1)
-    }
-  })
-}
-
-async function run({ token, config: { currentTeam, user } }) {
-  const domain = new NowDomains({ apiUrl, token, debug, currentTeam })
-  const args = argv._.slice(1)
-
-  switch (subcommand) {
-    case 'ls':
-    case 'list': {
-      if (args.length !== 0) {
-        error('Invalid number of arguments')
-        return exit(1)
-      }
-
-      const start_ = new Date()
-      const domains = await domain.ls()
-      domains.sort((a, b) => new Date(b.created) - new Date(a.created))
-      const current = new Date()
-      const header = [
-        ['', 'domain', 'dns', 'verified', 'created'].map(s => chalk.dim(s))
-      ]
-      const out = domains.length === 0
-        ? null
-        : table(
-            header.concat(
-              domains.map(domain => {
-                const ns = domain.isExternal ? 'external' : 'zeit.world'
-                const url = chalk.bold(domain.name)
-                const time = chalk.gray(
-                  ms(current - new Date(domain.created)) + ' ago'
-                )
-                return ['', url, ns, domain.verified, time]
-              })
-            ),
-            {
-              align: ['l', 'l', 'l', 'l', 'l'],
-              hsep: ' '.repeat(2),
-              stringLength: strlen
-            }
-          )
-
-      const elapsed_ = ms(new Date() - start_)
-      console.log(
-        `> ${domains.length} domain${domains.length === 1
-          ? ''
-          : 's'} found under ${chalk.bold(
-          (currentTeam && currentTeam.slug) || user.username || user.email
-        )} ${chalk.gray(`[${elapsed_}]`)}`
-      )
-
-      if (out) {
-        console.log('\n' + out + '\n')
-      }
-
-      break
-    }
-    case 'rm':
-    case 'remove': {
-      if (args.length !== 1) {
-        error('Invalid number of arguments')
-        return exit(1)
-      }
-
-      const _target = String(args[0])
-      if (!_target) {
-        const err = new Error('No domain specified')
-        err.userError = true
-        throw err
-      }
-
-      const _domains = await domain.ls()
-      const _domain = findDomain(_target, _domains)
-
-      if (!_domain) {
-        const err = new Error(
-          `Domain not found by "${_target}". Run ${chalk.dim(
-            '`now domains ls`'
-          )} to see your domains.`
-        )
-        err.userError = true
-        throw err
-      }
-
-      try {
-        const confirmation = (await readConfirmation(
-          domain,
-          _domain,
-          _domains
-        )).toLowerCase()
-        if (confirmation !== 'y' && confirmation !== 'yes') {
-          console.log('\n> Aborted')
-          process.exit(0)
-        }
-
-        const start = new Date()
-        await domain.rm(_domain.name)
-        const elapsed = ms(new Date() - start)
-        console.log(
-          `${chalk.cyan('> Success!')} Domain ${chalk.bold(
-            _domain.uid
-          )} removed [${elapsed}]`
-        )
-      } catch (err) {
-        error(err)
-        exit(1)
-      }
-      break
-    }
-    case 'add':
-    case 'set': {
-      if (args.length !== 1) {
-        error('Invalid number of arguments')
-        return exit(1)
-      }
-
-      const start = new Date()
-      const name = String(args[0])
-      const { uid, code, created, verified } = await domain.add(
-        name,
-        argv.force,
-        argv.external
-      )
-      const elapsed = ms(new Date() - start)
-      if (created) {
-        console.log(
-          `${chalk.cyan('> Success!')} Domain ${chalk.bold(
-            chalk.underline(name)
-          )} ${chalk.dim(`(${uid})`)} added [${elapsed}]`
-        )
-      } else if (verified) {
-        console.log(
-          `${chalk.cyan('> Success!')} Domain ${chalk.bold(
-            chalk.underline(name)
-          )} ${chalk.dim(`(${uid})`)} verified [${elapsed}]`
-        )
-      } else if (code === 'not_modified') {
-        console.log(
-          `${chalk.cyan('> Success!')} Domain ${chalk.bold(
-            chalk.underline(name)
-          )} ${chalk.dim(`(${uid})`)} already exists [${elapsed}]`
-        )
-      } else {
-        console.log(
-          '> Verification required: Please rerun this command after some time'
-        )
-      }
-      break
-    }
-    case 'buy': {
-      await require(resolve(__dirname, 'domains', 'buy.js'))({
-        domains: domain,
-        args,
-        currentTeam,
-        user
-      })
-      break
-    }
-    default:
-      error('Please specify a valid subcommand: ls | add | rm')
-      help()
-      exit(1)
-  }
-
-  domain.close()
-}
-
-async function readConfirmation(domain, _domain) {
-  return new Promise(resolve => {
-    const time = chalk.gray(ms(new Date() - new Date(_domain.created)) + ' ago')
-    const tbl = table(
-      [[_domain.uid, chalk.underline(`https://${_domain.name}`), time]],
-      { align: ['l', 'r', 'l'], hsep: ' '.repeat(6) }
-    )
-
-    process.stdout.write('> The following domain will be removed permanently\n')
-    process.stdout.write('  ' + tbl + '\n')
-
-    if (_domain.aliases.length > 0) {
-      process.stdout.write(
-        `> ${chalk.yellow('Warning!')} This domain's ` +
-          `${chalk.bold(
-            _domain.aliases.length +
-              ' alias' +
-              (_domain.aliases.length === 1 ? '' : 'es')
-          )} ` +
-          `will be removed. Run ${chalk.dim('`now alias ls`')} to list.\n`
-      )
-    }
-
-    process.stdout.write(
-      `  ${chalk.bold.red('> Are you sure?')} ${chalk.gray('[y/N] ')}`
-    )
-
-    process.stdin
-      .on('data', d => {
-        process.stdin.pause()
-        resolve(d.toString().trim())
-      })
-      .resume()
-  })
-}
-
-function findDomain(val, list) {
-  return list.find(d => {
-    if (d.uid === val) {
-      if (debug) {
-        console.log(`> [debug] matched domain ${d.uid} by uid`)
-      }
-
-      return true
-    }
-
-    // Match prefix
-    if (d.name === toHost(val)) {
-      if (debug) {
-        console.log(`> [debug] matched domain ${d.uid} by name ${d.name}`)
-      }
-
-      return true
-    }
-
-    return false
-  })
-}

bin/now-list.js

@@ -1,235 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const minimist = require('minimist')
-const chalk = require('chalk')
-const ms = require('ms')
-const printf = require('printf')
-require('epipebomb')()
-const supportsColor = require('supports-color')
-
-// Ours
-const Now = require('../lib')
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const { handleError, error } = require('../lib/error')
-const logo = require('../lib/utils/output/logo')
-const sort = require('../lib/sort-deployments')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug', 'all'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    token: 't'
-  }
-})
-
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now list`)} [app]
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} List all deployments
-
-    ${chalk.cyan('$ now ls')}
-
-  ${chalk.gray('–')} List all deployments for the app ${chalk.dim('`my-app`')}
-
-    ${chalk.cyan('$ now ls my-app')}
-
-  ${chalk.dim('Alias:')} ls
-`)
-}
-
-if (argv.help) {
-  help()
-  process.exit(0)
-}
-
-const app = argv._[0]
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-Promise.resolve().then(async () => {
-  const config = await cfg.read({ token: argv.token })
-
-  let token
-  try {
-    token = config.token || (await login(apiUrl))
-  } catch (err) {
-    error(`Authentication error – ${err.message}`)
-    process.exit(1)
-  }
-
-  try {
-    await list({ token, config })
-  } catch (err) {
-    error(`Unknown error: ${err}\n${err.stack}`)
-    process.exit(1)
-  }
-})
-
-async function list({ token, config: { currentTeam, user } }) {
-  const now = new Now({ apiUrl, token, debug, currentTeam })
-  const start = new Date()
-
-  if (argv.all && !app) {
-    console.log('> You must define an app when using `--all`')
-    process.exit(1)
-  }
-  let deployments
-  try {
-    deployments = await now.list(app)
-  } catch (err) {
-    handleError(err)
-    process.exit(1)
-  }
-
-  if (!deployments || (Array.isArray(deployments) && deployments.length <= 0)) {
-    const match = await now.findDeployment(app)
-    if (match !== null && typeof match !== 'undefined') {
-      deployments = Array.of(match)
-    }
-  }
-  if (!deployments || (Array.isArray(deployments) && deployments.length <= 0)) {
-    const aliases = await now.listAliases()
-
-    const item = aliases.find(e => e.uid === app || e.alias === app)
-    if (item) {
-      const match = await now.findDeployment(item.deploymentId)
-      if (match !== null && typeof match !== 'undefined') {
-        deployments = Array.of(match)
-      }
-    }
-  }
-
-  now.close()
-
-  const apps = new Map()
-
-  if (argv.all) {
-    await Promise.all(
-      deployments.map(async ({ uid }, i) => {
-        deployments[i].instances = await now.listInstances(uid)
-      })
-    )
-  }
-
-  for (const dep of deployments) {
-    const deps = apps.get(dep.name) || []
-    apps.set(dep.name, deps.concat(dep))
-  }
-
-  const sorted = await sort([...apps])
-
-  const urlLength =
-    deployments.reduce((acc, i) => {
-      return Math.max(acc, (i.url && i.url.length) || 0)
-    }, 0) + 5
-  const timeNow = new Date()
-  console.log(
-    `> ${deployments.length} deployment${deployments.length === 1
-      ? ''
-      : 's'} found under ${chalk.bold(
-      (currentTeam && currentTeam.slug) || user.username || user.email
-    )} ${chalk.grey('[' + ms(timeNow - start) + ']')}`
-  )
-
-  let shouldShowAllInfo = false
-  for (const app of apps) {
-    shouldShowAllInfo =
-      app[1].length > 5 ||
-      app.find(depl => {
-        return depl.scale && depl.scale.current > 1
-      })
-    if (shouldShowAllInfo) {
-      break
-    }
-  }
-  if (!argv.all && shouldShowAllInfo) {
-    console.log(
-      `> To expand the list and see instances run ${chalk.cyan(
-        '`now ls --all [app]`'
-      )}`
-    )
-  }
-  console.log()
-  sorted.forEach(([name, deps]) => {
-    const listedDeployments = argv.all ? deps : deps.slice(0, 5)
-    console.log(
-      `${chalk.bold(name)} ${chalk.gray(
-        '(' + listedDeployments.length + ' of ' + deps.length + ' total)'
-      )}`
-    )
-    const urlSpec = `%-${urlLength}s`
-    console.log(
-      printf(
-        ` ${chalk.grey(urlSpec + '  %8s    %-16s %8s')}`,
-        'url',
-        'inst #',
-        'state',
-        'age'
-      )
-    )
-    listedDeployments.forEach(dep => {
-      let state = dep.state
-      let extraSpaceForState = 0
-      if (state === null || typeof state === 'undefined') {
-        state = 'DEPLOYMENT_ERROR'
-      }
-      if (/ERROR/.test(state)) {
-        state = chalk.red(state)
-        extraSpaceForState = 10
-      } else if (state === 'FROZEN') {
-        state = chalk.grey(state)
-        extraSpaceForState = 10
-      }
-      let spec
-      if (supportsColor) {
-        spec = ` %-${urlLength + 10}s %8s    %-${extraSpaceForState + 16}s %8s`
-      } else {
-        spec = ` %-${urlLength + 1}s %8s    %-${16}s %8s`
-      }
-
-      console.log(
-        printf(
-          spec,
-          chalk.underline(dep.url),
-          dep.scale ? dep.scale.current : '✖',
-          state,
-          ms(timeNow - dep.created)
-        )
-      )
-      if (Array.isArray(dep.instances) && dep.instances.length > 0) {
-        dep.instances.forEach(i => {
-          console.log(
-            printf(` %-${urlLength + 10}s`, ` - ${chalk.underline(i.url)}`)
-          )
-        })
-        console.log()
-      }
-    })
-    console.log()
-  })
-}

bin/now-logout.js

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const minimist = require('minimist')
-const chalk = require('chalk')
-const fetch = require('node-fetch')
-const ora = require('ora')
-
-// Utilities
-const cfg = require('../lib/cfg')
-const logo = require('../lib/utils/output/logo')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config'],
-  boolean: ['help'],
-  alias: {
-    help: 'h',
-    config: 'c'
-  }
-})
-
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now logout`)}
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  config file
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Logout from the CLI:
-
-    ${chalk.cyan('$ now logout')}
-`)
-}
-
-if (argv.help) {
-  help()
-  process.exit(0)
-}
-
-const apiUrl = argv.url || 'https://api.zeit.co'
-const endpoint = apiUrl + '/www/user/tokens/'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-const requestHeaders = token => ({
-  headers: {
-    Authorization: `bearer ${token}`
-  }
-})
-
-const getTokenId = async token => {
-  const result = await fetch(endpoint, requestHeaders(token))
-  const tokenList = await result.json()
-
-  if (!tokenList.tokens) {
-    return
-  }
-
-  const tokenInfo = tokenList.tokens.find(t => token === t.token)
-
-  if (!tokenInfo) {
-    return
-  }
-
-  return tokenInfo.id
-}
-
-const revokeToken = async (token, tokenId) => {
-  const details = {
-    method: 'DELETE'
-  }
-
-  Object.assign(details, requestHeaders(token))
-  const result = await fetch(endpoint + encodeURIComponent(tokenId), details)
-
-  if (!result.ok) {
-    console.error('Not able to log out')
-  }
-}
-
-const logout = async () => {
-  const spinner = ora({
-    text: 'Logging out...'
-  }).start()
-
-  const config = await cfg.read()
-
-  try {
-    await cfg.removeFile()
-  } catch (err) {
-    spinner.fail(`Couldn't remove config while logging out`)
-    process.exit(1)
-  }
-
-  let tokenId
-
-  try {
-    tokenId = await getTokenId(argv.token || config.token)
-  } catch (err) {
-    spinner.fail('Not able to get token id on logout')
-    process.exit(1)
-  }
-
-  if (!tokenId) {
-    return
-  }
-
-  try {
-    await revokeToken(argv.token || config.token, tokenId)
-  } catch (err) {
-    spinner.fail('Could not revoke token on logout')
-    process.exit(1)
-  }
-
-  spinner.succeed('Logged out!')
-}
-
-logout()

bin/now-logs.js

@@ -1,290 +0,0 @@
-#!/usr/bin/env node
-
-const qs = require('querystring')
-const minimist = require('minimist')
-const chalk = require('chalk')
-const dateformat = require('dateformat')
-const io = require('socket.io-client')
-const Now = require('../lib')
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const { handleError, error } = require('../lib/error')
-const logo = require('../lib/utils/output/logo')
-const { compare, deserialize } = require('../lib/logs')
-const { maybeURL, normalizeURL, parseInstanceURL } = require('../lib/utils/url')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'query', 'since', 'token', 'until'],
-  boolean: ['help', 'all', 'debug', 'f'],
-  alias: {
-    help: 'h',
-    all: 'a',
-    config: 'c',
-    debug: 'd',
-    token: 't',
-    query: 'q'
-  }
-})
-
-let deploymentIdOrURL = argv._[0]
-
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now logs`)} <deploymentId|url>
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              output usage information
-    -a, --all               include access logs
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  config file
-    -d, --debug             debug mode [off]
-    -f                      wait for additional data [off]
-    -n ${chalk.bold.underline('NUMBER')}               number of logs [1000]
-    -q ${chalk.bold.underline('QUERY')}, --query=${chalk.bold.underline(
-    'QUERY'
-  )} search query
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} login token
-    --since=${chalk.bold.underline(
-      'SINCE'
-    )}           only return logs after date (ISO 8601)
-    --until=${chalk.bold.underline(
-      'UNTIL'
-    )}           only return logs before date (ISO 8601), ignored if the f option is enbled.
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Print logs for the deployment ${chalk.dim(
-    '`deploymentId`'
-  )}
-
-    ${chalk.cyan('$ now logs deploymentId')}
-`)
-}
-
-if (argv.help || !deploymentIdOrURL) {
-  help()
-  process.exit(0)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-const limit = typeof argv.n === 'number' ? argv.n : 1000
-const query = argv.query || ''
-const follow = argv.f
-const types = argv.all ? [] : ['command', 'stdout', 'stderr', 'exit']
-
-let since
-try {
-  since = argv.since ? toSerial(argv.since) : null
-} catch (err) {
-  error(`Invalid date string: ${argv.since}`)
-  process.exit(1)
-}
-
-let until
-try {
-  until = argv.until ? toSerial(argv.until) : null
-} catch (err) {
-  error(`Invalid date string: ${argv.until}`)
-  process.exit(1)
-}
-
-let instanceId
-
-if (maybeURL(deploymentIdOrURL)) {
-  const normalizedURL = normalizeURL(deploymentIdOrURL)
-  if (normalizedURL.includes('/')) {
-    error(`Invalid deployment url: can't include path (${deploymentIdOrURL})`)
-    process.exit(1)
-  }
-
-  ;[deploymentIdOrURL, instanceId] = parseInstanceURL(normalizedURL)
-}
-
-Promise.resolve()
-  .then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || login(apiUrl)
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      process.exit(1)
-    }
-
-    await printLogs({ token, config })
-  })
-  .catch(err => {
-    error(`Unknown error: ${err.stack}`)
-    process.exit(1)
-  })
-
-async function printLogs({ token, config: { currentTeam } }) {
-  let buf = []
-  let init = false
-  let lastLog
-
-  if (!follow) {
-    onLogs(await fetchLogs({ token, currentTeam, since, until }))
-    return
-  }
-
-  const isURL = deploymentIdOrURL.includes('.')
-  const q = qs.stringify({
-    deploymentId: isURL ? '' : deploymentIdOrURL,
-    host: isURL ? deploymentIdOrURL : '',
-    instanceId,
-    types: types.join(','),
-    query
-  })
-
-  const socket = io(`https://log-io.zeit.co?${q}`)
-  socket.on('connect', () => {
-    if (debug) {
-      console.log('> [debug] Socket connected')
-    }
-  })
-
-  socket.on('auth', callback => {
-    if (debug) {
-      console.log('> [debug] Socket authenticate')
-    }
-    callback(token)
-  })
-
-  socket.on('ready', () => {
-    if (debug) {
-      console.log('> [debug] Socket ready')
-    }
-
-    // For the case socket reconnected
-    const _since = lastLog ? lastLog.serial : since
-
-    fetchLogs({ token, currentTeam, since: _since }).then(logs => {
-      init = true
-      const m = {}
-      logs.concat(buf.map(b => b.log)).forEach(l => {
-        m[l.id] = l
-      })
-      buf = []
-      onLogs(Object.values(m))
-    })
-  })
-
-  socket.on('logs', l => {
-    const log = deserialize(l)
-    let timer
-    if (init) {
-      // Wait for other logs for a while
-      // and sort them in the correct order
-      timer = setTimeout(() => {
-        buf.sort((a, b) => compare(a.log, b.log))
-        const idx = buf.findIndex(b => b.log.id === log.id)
-        buf.slice(0, idx + 1).forEach(b => {
-          clearTimeout(b.timer)
-          onLog(b.log)
-        })
-        buf = buf.slice(idx + 1)
-      }, 300)
-    }
-    buf.push({ log, timer })
-  })
-
-  socket.on('disconnect', () => {
-    if (debug) {
-      console.log('> [debug] Socket disconnect')
-    }
-    init = false
-  })
-
-  socket.on('error', err => {
-    if (debug) {
-      console.log('> [debug] Socket error', err.stack)
-    }
-  })
-
-  function onLogs(logs) {
-    logs.sort(compare).forEach(onLog)
-  }
-
-  function onLog(log) {
-    lastLog = log
-    printLog(log)
-  }
-}
-
-function printLog(log) {
-  let data
-  const obj = log.object
-  if (log.type === 'request') {
-    data =
-      `REQ "${obj.method} ${obj.uri} ${obj.protocol}"` +
-      ` ${obj.remoteAddr} - ${obj.remoteUser || ''}` +
-      ` "${obj.referer || ''}" "${obj.userAgent}"`
-  } else if (log.type === 'response') {
-    data =
-      `RES "${obj.method} ${obj.uri} ${obj.protocol}"` +
-      ` ${obj.status} ${obj.bodyBytesSent}`
-  } else {
-    data = obj
-      ? JSON.stringify(obj, null, 2)
-      : (log.text || '').replace(/\n$/, '')
-  }
-
-  const date = dateformat(log.date, 'mm/dd hh:MM TT')
-
-  data.split('\n').forEach((line, i) => {
-    if (i === 0) {
-      console.log(`${chalk.dim(date)}  ${line}`)
-    } else {
-      console.log(`${repeat(' ', date.length)}  ${line}`)
-    }
-  })
-}
-
-async function fetchLogs({ token, currentTeam, since, until } = {}) {
-  const now = new Now({ apiUrl, token, debug, currentTeam })
-
-  let logs
-  try {
-    logs = await now.logs(deploymentIdOrURL, {
-      instanceId,
-      types,
-      limit,
-      query,
-      since,
-      until
-    })
-  } catch (err) {
-    handleError(err)
-    process.exit(1)
-  } finally {
-    now.close()
-  }
-
-  return logs.map(deserialize)
-}
-
-function repeat(s, n) {
-  return new Array(n + 1).join(s)
-}
-
-function toSerial(datestr) {
-  const t = Date.parse(datestr)
-  if (isNaN(t)) {
-    throw new TypeError('Invalid date string')
-  }
-
-  const pidLen = 19
-  const seqLen = 19
-  return t + repeat('0', pidLen + seqLen)
-}

bin/now-remove.js

@@ -1,209 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const minimist = require('minimist')
-const chalk = require('chalk')
-const ms = require('ms')
-const table = require('text-table')
-
-// Ours
-const Now = require('../lib')
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const { handleError, error } = require('../lib/error')
-const logo = require('../lib/utils/output/logo')
-const { normalizeURL } = require('../lib/utils/url')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug', 'hard', 'yes', 'safe'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    token: 't',
-    yes: 'y'
-  }
-})
-
-const ids = argv._
-
-// Options
-const help = () => {
-  console.log(`
-  ${chalk.bold(
-    `${logo} now remove`
-  )} deploymentId|deploymentName [...deploymentId|deploymentName]
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-    -y, --yes               Skip confirmation
-    --safe                  Skip deployments with an active alias
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Remove a deployment identified by ${chalk.dim(
-    '`deploymentId`'
-  )}:
-
-    ${chalk.cyan('$ now rm deploymentId')}
-
-  ${chalk.gray('–')} Remove all deployments with name ${chalk.dim('`my-app`')}:
-
-    ${chalk.cyan('$ now rm my-app')}
-
-  ${chalk.gray('–')} Remove two deployments with IDs ${chalk.dim(
-    '`eyWt6zuSdeus`'
-  )} and ${chalk.dim('`uWHoA9RQ1d1o`')}:
-
-    ${chalk.cyan('$ now rm eyWt6zuSdeus uWHoA9RQ1d1o')}
-
-  ${chalk.dim('Alias:')} rm
-`)
-}
-
-if (argv.help || ids.length === 0) {
-  help()
-  process.exit(0)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-const hard = argv.hard || false
-const skipConfirmation = argv.yes || false
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-Promise.resolve().then(async () => {
-  const config = await cfg.read({ token: argv.token })
-
-  let token
-  try {
-    token = config.token || login(apiUrl)
-  } catch (err) {
-    error(`Authentication error – ${err.message}`)
-    process.exit(1)
-  }
-
-  try {
-    await remove({ token, config })
-  } catch (err) {
-    error(`Unknown error: ${err}\n${err.stack}`)
-    process.exit(1)
-  }
-})
-
-function readConfirmation(matches) {
-  return new Promise(resolve => {
-    process.stdout.write(
-      `> The following deployment${matches.length === 1
-        ? ''
-        : 's'} will be removed permanently:\n`
-    )
-
-    const tbl = table(
-      matches.map(depl => {
-        const time = chalk.gray(ms(new Date() - depl.created) + ' ago')
-        const url = depl.url ? chalk.underline(`https://${depl.url}`) : ''
-        return [depl.uid, url, time]
-      }),
-      { align: ['l', 'r', 'l'], hsep: ' '.repeat(6) }
-    )
-    process.stdout.write(tbl + '\n')
-
-    for (const [index, depl] of matches.entries()) {
-      for (const alias of depl.aliases) {
-        if (argv.safe) {
-          delete matches[index]
-          continue
-        }
-        process.stdout.write(
-          `> ${chalk.yellow('Warning!')} Deployment ${chalk.bold(depl.uid)} ` +
-            `is an alias for ${chalk.underline(
-              `https://${alias.alias}`
-            )} and will be removed.\n`
-        )
-      }
-    }
-
-    process.stdout.write(
-      `${chalk.bold.red('> Are you sure?')} ${chalk.gray('[y/N] ')}`
-    )
-
-    process.stdin
-      .on('data', d => {
-        process.stdin.pause()
-        resolve(d.toString().trim())
-      })
-      .resume()
-  })
-}
-
-async function remove({ token, config: { currentTeam } }) {
-  const now = new Now({ apiUrl, token, debug, currentTeam })
-
-  const deployments = await now.list()
-
-  const matches = deployments.filter(d => {
-    return ids.some(id => {
-      return d.uid === id || d.name === id || d.url === normalizeURL(id)
-    })
-  })
-
-  if (matches.length === 0) {
-    error(
-      `Could not find any deployments matching ${ids
-        .map(id => chalk.bold(`"${id}"`))
-        .join(', ')}. Run ${chalk.dim(`\`now ls\``)} to list.`
-    )
-    return process.exit(1)
-  }
-
-  const aliases = await Promise.all(
-    matches.map(depl => now.listAliases(depl.uid))
-  )
-  for (let i = 0; i < matches.length; i++) {
-    matches[i].aliases = aliases[i]
-  }
-
-  try {
-    if (!skipConfirmation) {
-      const confirmation = (await readConfirmation(matches)).toLowerCase()
-
-      if (confirmation !== 'y' && confirmation !== 'yes') {
-        console.log('\n> Aborted')
-        process.exit(0)
-      }
-    }
-
-    const start = new Date()
-
-    await Promise.all(matches.map(depl => now.remove(depl.uid, { hard })))
-
-    const elapsed = ms(new Date() - start)
-    console.log(`${chalk.cyan('> Success!')} [${elapsed}]`)
-    console.log(
-      table(
-        matches.map(depl => {
-          return [`Deployment ${chalk.bold(depl.uid)} removed`]
-        })
-      )
-    )
-  } catch (err) {
-    handleError(err)
-    process.exit(1)
-  }
-
-  now.close()
-}

bin/now-scale.js

@@ -1,379 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const chalk = require('chalk')
-const isURL = require('is-url')
-const minimist = require('minimist')
-const ms = require('ms')
-const printf = require('printf')
-require('epipebomb')()
-const supportsColor = require('supports-color')
-
-// Ours
-const cfg = require('../lib/cfg')
-const { handleError, error } = require('../lib/error')
-const NowScale = require('../lib/scale')
-const login = require('../lib/login')
-const exit = require('../lib/utils/exit')
-const logo = require('../lib/utils/output/logo')
-const info = require('../lib/scale-info')
-const sort = require('../lib/sort-deployments')
-const success = require('../lib/utils/output/success')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug'],
-  alias: { help: 'h', config: 'c', debug: 'd', token: 't' }
-})
-
-let id = argv._[0]
-const scaleArg = argv._[1]
-const optionalScaleArg = argv._[2]
-
-// Options
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now scale`)} ls
-  ${chalk.bold(`${logo} now scale`)} <url>
-  ${chalk.bold(`${logo} now scale`)} <url> <min> [max]
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Create an deployment with 3 instances, never sleeps:
-
-    ${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh 3')}
-
-  ${chalk.gray('–')} Create an automatically scaling deployment:
-
-    ${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh 1 5')}
-
-  ${chalk.gray(
-    '–'
-  )} Create an automatically scaling deployment without specifying max:
-
-    ${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh 1 auto')}
-
-  ${chalk.gray(
-    '–'
-  )} Create an automatically scaling deployment without specifying min or max:
-
-    ${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh auto')}
-
-  ${chalk.gray(
-    '–'
-  )} Create an deployment that is always active and never "sleeps":
-
-    ${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh 1')}
-  `)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-if (argv.help) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-
-    try {
-      await run({ token, config })
-    } catch (err) {
-      if (err.userError) {
-        error(err.message)
-      } else {
-        error(`Unknown error: ${err}\n${err.stack}`)
-      }
-      exit(1)
-    }
-  })
-}
-
-function guessParams() {
-  if (Number.isInteger(scaleArg) && !optionalScaleArg) {
-    return { min: scaleArg, max: scaleArg }
-  } else if (Number.isInteger(scaleArg) && Number.isInteger(optionalScaleArg)) {
-    return { min: scaleArg, max: optionalScaleArg }
-  } else if (Number.isInteger(scaleArg) && optionalScaleArg === 'auto') {
-    return { min: scaleArg, max: 'auto' }
-  } else if (
-    (!scaleArg && !optionalScaleArg) ||
-    (scaleArg === 'auto' && !optionalScaleArg)
-  ) {
-    return { min: 1, max: 'auto' }
-  }
-  help()
-  process.exit(1)
-}
-
-function isHostNameOrId(str) {
-  return (
-    /(https?:\/\/)?((?:(?=[a-z0-9-]{1,63}\.)(?:xn--)?[a-z0-9]+(?:-[a-z0-9]+)*\.)+[a-z]{2,63})/.test(
-      str
-    ) || str.length === 28
-  )
-}
-
-async function run({ token, config: { currentTeam } }) {
-  const scale = new NowScale({ apiUrl, token, debug, currentTeam })
-  const start = Date.now()
-
-  if (id === 'ls') {
-    await list(scale)
-    process.exit(0)
-  } else if (id === 'info') {
-    await info(scale)
-    process.exit(0)
-  } else if (id && isHostNameOrId(id)) {
-    // Normalize URL by removing slash from the end
-    if (isURL(id)) {
-      id = id.replace(/^https:\/\//i, '')
-      if (id.slice(-1) === '/') {
-        id = id.slice(0, -1)
-      }
-    }
-  } else {
-    error('Please specify a deployment: now scale <id|url>')
-    help()
-    exit(1)
-  }
-
-  const deployments = await scale.list()
-
-  let match = deployments.find(d => {
-    // `url` should match the hostname of the deployment
-    let u = id.replace(/^https:\/\//i, '')
-
-    if (u.indexOf('.') === -1) {
-      // `.now.sh` domain is implied if just the subdomain is given
-      u += '.now.sh'
-    }
-    return d.uid === id || d.name === id || d.url === u
-  })
-
-  if (!match) {
-    // Maybe it's an alias
-    const aliasDeployment = (await scale.listAliases()).find(
-      e => e.alias === id
-    )
-    if (!aliasDeployment) {
-      error(`Could not find any deployments matching ${id}`)
-      return process.exit(1)
-    }
-    match = deployments.find(d => {
-      return d.uid === aliasDeployment.deploymentId
-    })
-  }
-
-  const { min, max } = guessParams()
-
-  if (
-    !(Number.isInteger(min) || min === 'auto') &&
-    !(Number.isInteger(max) || max === 'auto')
-  ) {
-    help()
-    return exit(1)
-  }
-
-  if (match.type === 'STATIC') {
-    if (min === 0 && max === 0) {
-      error("Static deployments can't be FROZEN. Use `now rm` to remove")
-      return process.exit(1)
-    }
-    console.log('> Static deployments are automatically scaled!')
-    return process.exit(0)
-  }
-
-  const {
-    max: currentMax,
-    min: currentMin,
-    current: currentCurrent
-  } = match.scale
-  if (
-    max === currentMax &&
-    min === currentMin &&
-    Number.isInteger(min) &&
-    currentCurrent >= min &&
-    Number.isInteger(max) &&
-    currentCurrent <= max
-  ) {
-    // Nothing to do, let's print the rules
-    printScaleingRules(match.url, currentCurrent, min, max)
-    return
-  }
-
-  if ((match.state === 'FROZEN' || match.scale.current === 0) && min > 0) {
-    console.log(
-      `> Deployment is currently in 0 replicas, preparing deployment for scaling...`
-    )
-    if (match.scale.max < 1) {
-      await scale.setScale(match.uid, { min: 0, max: 1 })
-    }
-    await scale.unfreeze(match)
-  }
-
-  const { min: newMin, max: newMax } = await scale.setScale(match.uid, {
-    min,
-    max
-  })
-
-  const elapsed = ms(new Date() - start)
-
-  const currentReplicas = match.scale.current
-  printScaleingRules(match.url, currentReplicas, newMin, newMax, elapsed)
-  await info(scale, match.url)
-
-  scale.close()
-}
-function printScaleingRules(url, currentReplicas, min, max, elapsed) {
-  const log = console.log
-  success(
-    `Configured scaling rules ${chalk.gray(elapsed ? '[' + elapsed + ']' : '')}`
-  )
-  log()
-  log(
-    `${chalk.bold(url)} (${chalk.gray(currentReplicas)} ${chalk.gray(
-      'current'
-    )})`
-  )
-  log(printf('%6s %s', 'min', chalk.bold(min)))
-  log(printf('%6s %s', 'max', chalk.bold(max)))
-  log(printf('%6s %s', 'auto', chalk.bold(min === max ? '✖' : '✔')))
-  log()
-}
-
-async function list(scale) {
-  let deployments
-  try {
-    const app = argv._[1]
-    deployments = await scale.list(app)
-  } catch (err) {
-    handleError(err)
-    process.exit(1)
-  }
-
-  scale.close()
-
-  const apps = new Map()
-
-  for (const dep of deployments) {
-    const deps = apps.get(dep.name) || []
-    apps.set(dep.name, deps.concat(dep))
-  }
-
-  const sorted = await sort([...apps])
-
-  const timeNow = new Date()
-  const urlLength =
-    deployments.reduce((acc, i) => {
-      return Math.max(acc, (i.url && i.url.length) || 0)
-    }, 0) + 5
-
-  for (const app of sorted) {
-    const depls = argv.all ? app[1] : app[1].slice(0, 5)
-    console.log(
-      `${chalk.bold(app[0])} ${chalk.gray(
-        '(' + depls.length + ' of ' + app[1].length + ' total)'
-      )}`
-    )
-    console.log()
-    const urlSpec = `%-${urlLength}s`
-    console.log(
-      printf(
-        ` ${chalk.grey(urlSpec + '  %8s %8s %8s %8s %8s')}`,
-        'url',
-        'cur',
-        'min',
-        'max',
-        'auto',
-        'age'
-      )
-    )
-    for (const instance of depls) {
-      if (!instance.scale) {
-        let spec
-        if (supportsColor) {
-          spec = ` %-${urlLength + 10}s %8s %8s %8s %8s %8s`
-        } else {
-          spec = ` %-${urlLength + 1}s %8s %8s %8s %8s %8s`
-        }
-        const infinite = '∞'
-        console.log(
-          printf(
-            spec,
-            chalk.underline(instance.url),
-            infinite,
-            1,
-            infinite,
-            '✔',
-            ms(timeNow - instance.created)
-          )
-        )
-      } else if (instance.scale.current > 0) {
-        let spec
-        if (supportsColor) {
-          spec = ` %-${urlLength + 10}s %8s %8s %8s %8s %8s`
-        } else {
-          spec = ` %-${urlLength + 1}s %8s %8s %8s %8s %8s`
-        }
-        console.log(
-          printf(
-            spec,
-            chalk.underline(instance.url),
-            instance.scale.current,
-            instance.scale.min,
-            instance.scale.max,
-            instance.scale.max === instance.scale.min ? '✖' : '✔',
-            ms(timeNow - instance.created)
-          )
-        )
-      } else {
-        let spec
-        if (supportsColor) {
-          spec = ` %-${urlLength + 10}s ${chalk.gray('%8s %8s %8s %8s %8s')}`
-        } else {
-          spec = ` %-${urlLength + 1}s ${chalk.gray('%8s %8s %8s %8s %8s')}`
-        }
-        console.log(
-          printf(
-            spec,
-            chalk.underline(instance.url),
-            instance.scale.current,
-            instance.scale.min,
-            instance.scale.max,
-            instance.scale.max === instance.scale.min ? '✖' : '✔',
-            ms(timeNow - instance.created)
-          )
-        )
-      }
-    }
-    console.log()
-  }
-}
-
-process.on('uncaughtException', err => {
-  handleError(err)
-  exit(1)
-})

bin/now-secrets.js

@@ -1,297 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const chalk = require('chalk')
-const table = require('text-table')
-const minimist = require('minimist')
-const ms = require('ms')
-
-// Ours
-const strlen = require('../lib/strlen')
-const cfg = require('../lib/cfg')
-const { handleError, error } = require('../lib/error')
-const NowSecrets = require('../lib/secrets')
-const login = require('../lib/login')
-const exit = require('../lib/utils/exit')
-const logo = require('../lib/utils/output/logo')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug', 'base64'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    base64: 'b',
-    token: 't'
-  }
-})
-
-const subcommand = argv._[0]
-
-// Options
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now secrets`)} <ls | add | rename | rm> <secret>
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -b, --base64            Treat value as base64-encoded
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Lists all your secrets:
-
-    ${chalk.cyan('$ now secrets ls')}
-
-  ${chalk.gray('–')} Adds a new secret:
-
-    ${chalk.cyan('$ now secrets add my-secret "my value"')}
-
-    ${chalk.gray(
-      '–'
-    )} Once added, a secret's value can't be retrieved in plaintext anymore
-    ${chalk.gray(
-      '–'
-    )} If the secret's value is more than one word, wrap it in quotes
-    ${chalk.gray('–')} Actually, when in doubt, wrap your value in quotes
-
-  ${chalk.gray('–')} Exposes a secret as an env variable:
-
-    ${chalk.cyan(`$ now -e MY_SECRET=${chalk.bold('@my-secret')}`)}
-
-    Notice the ${chalk.cyan.bold(
-      '`@`'
-    )} symbol which makes the value a secret reference.
-
-  ${chalk.gray('–')} Renames a secret:
-
-    ${chalk.cyan(`$ now secrets rename my-secret my-renamed-secret`)}
-
-  ${chalk.gray('–')} Removes a secret:
-
-    ${chalk.cyan(`$ now secrets rm my-secret`)}
-`)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-if (argv.help || !subcommand) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-
-    try {
-      await run({ token, config })
-    } catch (err) {
-      handleError(err)
-      exit(1)
-    }
-  })
-}
-
-async function run({ token, config: { currentTeam, user } }) {
-  const secrets = new NowSecrets({ apiUrl, token, debug, currentTeam })
-  const args = argv._.slice(1)
-  const start = Date.now()
-
-  if (subcommand === 'ls' || subcommand === 'list') {
-    if (args.length !== 0) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan('`now secret ls`')}`
-      )
-      return exit(1)
-    }
-
-    const list = await secrets.ls()
-    const elapsed = ms(new Date() - start)
-
-    console.log(
-      `> ${list.length} secret${list.length === 1
-        ? ''
-        : 's'} found under ${chalk.bold(
-        (currentTeam && currentTeam.slug) || user.username || user.email
-      )} ${chalk.gray(`[${elapsed}]`)}`
-    )
-
-    if (list.length > 0) {
-      const cur = Date.now()
-      const header = [['', 'id', 'name', 'created'].map(s => chalk.dim(s))]
-      const out = table(
-        header.concat(
-          list.map(secret => {
-            return [
-              '',
-              secret.uid,
-              chalk.bold(secret.name),
-              chalk.gray(ms(cur - new Date(secret.created)) + ' ago')
-            ]
-          })
-        ),
-        {
-          align: ['l', 'r', 'l', 'l'],
-          hsep: ' '.repeat(2),
-          stringLength: strlen
-        }
-      )
-
-      if (out) {
-        console.log('\n' + out + '\n')
-      }
-    }
-    return secrets.close()
-  }
-
-  if (subcommand === 'rm' || subcommand === 'remove') {
-    if (args.length !== 1) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan(
-          '`now secret rm <id | name>`'
-        )}`
-      )
-      return exit(1)
-    }
-    const list = await secrets.ls()
-    const theSecret = list.filter(secret => {
-      return secret.uid === args[0] || secret.name === args[0]
-    })[0]
-
-    if (theSecret) {
-      const yes = await readConfirmation(theSecret)
-      if (!yes) {
-        error('User abort')
-        return exit(0)
-      }
-    } else {
-      error(`No secret found by id or name "${args[0]}"`)
-      return exit(1)
-    }
-
-    const secret = await secrets.rm(args[0])
-    const elapsed = ms(new Date() - start)
-    console.log(
-      `${chalk.cyan('> Success!')} Secret ${chalk.bold(
-        secret.name
-      )} ${chalk.gray(`(${secret.uid})`)} removed ${chalk.gray(`[${elapsed}]`)}`
-    )
-    return secrets.close()
-  }
-
-  if (subcommand === 'rename') {
-    if (args.length !== 2) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan(
-          '`now secret rename <old-name> <new-name>`'
-        )}`
-      )
-      return exit(1)
-    }
-    const secret = await secrets.rename(args[0], args[1])
-    const elapsed = ms(new Date() - start)
-    console.log(
-      `${chalk.cyan('> Success!')} Secret ${chalk.bold(
-        secret.oldName
-      )} ${chalk.gray(`(${secret.uid})`)} renamed to ${chalk.bold(
-        args[1]
-      )} ${chalk.gray(`[${elapsed}]`)}`
-    )
-    return secrets.close()
-  }
-
-  if (subcommand === 'add' || subcommand === 'set') {
-    if (args.length !== 2) {
-      error(
-        `Invalid number of arguments. Usage: ${chalk.cyan(
-          '`now secret add <name> <value>`'
-        )}`
-      )
-
-      if (args.length > 2) {
-        const example = chalk.cyan(`$ now secret add ${args[0]}`)
-        console.log(
-          `> If your secret has spaces, make sure to wrap it in quotes. Example: \n  ${example} `
-        )
-      }
-
-      return exit(1)
-    }
-
-    const [name, value_] = args
-    let value
-
-    if (argv.base64) {
-      value = { base64: value_ }
-    } else {
-      value = value_
-    }
-
-    const secret = await secrets.add(name, value)
-    const elapsed = ms(new Date() - start)
-
-    console.log(
-      `${chalk.cyan('> Success!')} Secret ${chalk.bold(
-        name.toLowerCase()
-      )} ${chalk.gray(`(${secret.uid})`)} added (${chalk.bold(
-        (currentTeam && currentTeam.slug) || user.username || user.email
-      )}) ${chalk.gray(`[${elapsed}]`)}`
-    )
-    return secrets.close()
-  }
-
-  error('Please specify a valid subcommand: ls | add | rename | rm')
-  help()
-  exit(1)
-}
-
-process.on('uncaughtException', err => {
-  handleError(err)
-  exit(1)
-})
-
-function readConfirmation(secret) {
-  return new Promise(resolve => {
-    const time = chalk.gray(ms(new Date() - new Date(secret.created)) + ' ago')
-    const tbl = table([[secret.uid, chalk.bold(secret.name), time]], {
-      align: ['l', 'r', 'l'],
-      hsep: ' '.repeat(6)
-    })
-
-    process.stdout.write('> The following secret will be removed permanently\n')
-    process.stdout.write('  ' + tbl + '\n')
-
-    process.stdout.write(
-      `${chalk.bold.red('> Are you sure?')} ${chalk.gray('[y/N] ')}`
-    )
-
-    process.stdin
-      .on('data', d => {
-        process.stdin.pause()
-        resolve(d.toString().trim().toLowerCase() === 'y')
-      })
-      .resume()
-  })
-}

bin/now-teams.js

@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-
-// Native
-const { resolve } = require('path')
-
-// Packages
-const chalk = require('chalk')
-const minimist = require('minimist')
-
-// Ours
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const error = require('../lib/utils/output/error')
-const NowTeams = require('../lib/teams')
-const logo = require('../lib/utils/output/logo')
-const exit = require('../lib/utils/exit')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    token: 't',
-    switch: 'change'
-  }
-})
-
-const subcommand = argv._[0]
-
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now teams`)} <add | ls | rm | invite>
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Add a new team:
-
-      ${chalk.cyan('$ now teams add')}
-
-  ${chalk.gray('–')} Switch to a team:
-
-      ${chalk.cyan(`$ now switch <id>`)}
-
-      ${chalk.gray('–')} If the id is omitted, you can choose interactively
-
-      ${chalk.yellow(
-        'NOTE:'
-      )} When you switch, everything you add, list or remove will be scoped that team!
-
-  ${chalk.gray('–')} Invite new members (interactively):
-
-      ${chalk.cyan(`$ now teams invite`)}
-
-  ${chalk.gray('–')} Invite a specific email:
-
-      ${chalk.cyan(`$ now teams invite geist@zeit.co`)}
-
-  ${chalk.gray('–')} Remove a team:
-
-      ${chalk.cyan(`$ now teams rm <id>`)}
-
-      ${chalk.gray('–')} If the id is omitted, you can choose interactively
-  `)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-if (argv.help || !subcommand) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-
-    try {
-      await run({ token, config })
-    } catch (err) {
-      if (err.userError) {
-        error(err.message)
-      } else {
-        error(`Unknown error: ${err.stack}`)
-      }
-      exit(1)
-    }
-  })
-}
-
-async function run({ token, config: { currentTeam } }) {
-  const teams = new NowTeams({ apiUrl, token, debug, currentTeam })
-  const args = argv._.slice(1)
-
-  switch (subcommand) {
-    case 'list':
-    case 'ls': {
-      await require(resolve(__dirname, 'teams', 'list.js'))({
-        teams,
-        token
-      })
-      break
-    }
-    case 'switch':
-    case 'change': {
-      await require(resolve(__dirname, 'teams', 'switch.js'))({
-        teams,
-        args,
-        token
-      })
-      break
-    }
-    case 'add':
-    case 'create': {
-      await require(resolve(__dirname, 'teams', 'add.js'))({ teams, token })
-      break
-    }
-
-    case 'invite': {
-      await require(resolve(__dirname, 'teams', 'invite.js'))({
-        teams,
-        args,
-        token
-      })
-      break
-    }
-
-    default: {
-      let code = 0
-      if (subcommand !== 'help') {
-        error('Please specify a valid subcommand: ls | add | rm | set-default')
-        code = 1
-      }
-      help()
-      exit(code)
-    }
-  }
-}

bin/now-upgrade.js

@@ -1,251 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const chalk = require('chalk')
-const minimist = require('minimist')
-const ms = require('ms')
-
-// Ours
-const login = require('../lib/login')
-const cfg = require('../lib/cfg')
-const NowPlans = require('../lib/plans')
-const indent = require('../lib/indent')
-const listInput = require('../lib/utils/input/list')
-const code = require('../lib/utils/output/code')
-const error = require('../lib/utils/output/error')
-const success = require('../lib/utils/output/success')
-const cmd = require('../lib/utils/output/cmd')
-const logo = require('../lib/utils/output/logo')
-
-const { bold } = chalk
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    token: 't'
-  }
-})
-
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now upgrade`)} [plan]
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} List available plans and pick one interactively
-
-      ${chalk.cyan('$ now upgrade')}
-
-      ${chalk.yellow('NOTE:')} ${chalk.gray(
-    'Make sure you have a payment method, or add one:'
-  )}
-
-      ${chalk.cyan(`$ now billing add`)}
-
-  ${chalk.gray('–')} Pick a specific plan (premium):
-
-      ${chalk.cyan(`$ now upgrade premium`)}
-  `)
-}
-
-// Options
-const debug = argv.debug
-const apiUrl = argv.url || 'https://api.zeit.co'
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-const exit = code => {
-  // We give stdout some time to flush out
-  // because there's a node bug where
-  // stdout writes are asynchronous
-  // https://github.com/nodejs/node/issues/6456
-  setTimeout(() => process.exit(code || 0), 100)
-}
-
-if (argv.help) {
-  help()
-  exit(0)
-} else {
-  Promise.resolve().then(async () => {
-    const config = await cfg.read({ token: argv.token })
-
-    let token
-    try {
-      token = config.token || (await login(apiUrl))
-    } catch (err) {
-      error(`Authentication error – ${err.message}`)
-      exit(1)
-    }
-
-    try {
-      await run({ token, config })
-    } catch (err) {
-      if (err.userError) {
-        error(err.message)
-      } else {
-        error(`Unknown error: ${err.stack}`)
-      }
-      exit(1)
-    }
-  })
-}
-
-function buildInquirerChoices(current, until) {
-  if (until) {
-    until = until.split(' ')
-    until = ' for ' + chalk.bold(until[0]) + ' more ' + until[1]
-  } else {
-    until = ''
-  }
-
-  const currentText = bold('(current)')
-  let ossName = `OSS ${bold('FREE')}`
-  let premiumName = `Premium ${bold('$15')}`
-  let proName = `Pro ${bold('$50')}`
-  let advancedName = `Advanced ${bold('$200')}`
-
-  switch (current) {
-    case 'oss': {
-      ossName += indent(currentText, 6)
-      break
-    }
-    case 'premium': {
-      premiumName += indent(currentText, 3)
-      break
-    }
-    case 'pro': {
-      proName += indent(currentText, 7)
-      break
-    }
-    case 'advanced': {
-      advancedName += indent(currentText, 1)
-      break
-    }
-    default: {
-      ossName += indent(currentText, 6)
-    }
-  }
-
-  return [
-    {
-      name: ossName,
-      value: 'oss',
-      short: `OSS ${bold('FREE')}`
-    },
-    {
-      name: premiumName,
-      value: 'premium',
-      short: `Premium ${bold('$15')}`
-    },
-    {
-      name: proName,
-      value: 'pro',
-      short: `Pro ${bold('$50')}`
-    },
-    {
-      name: advancedName,
-      value: 'advanced',
-      short: `Advanced ${bold('$200')}`
-    }
-  ]
-}
-
-async function run({ token, config: { currentTeam, user } }) {
-  const args = argv._
-  if (args.length > 1) {
-    error('Invalid number of arguments')
-    return exit(1)
-  }
-
-  const start = new Date()
-  const plans = new NowPlans({ apiUrl, token, debug, currentTeam })
-
-  let planId = args[0]
-
-  if (![undefined, 'oss', 'premium', 'pro', 'advanced'].includes(planId)) {
-    error(`Invalid plan name – should be ${code('oss')} or ${code('premium')}`)
-    return exit(1)
-  }
-
-  const currentPlan = await plans.getCurrent()
-
-  if (planId === undefined) {
-    const elapsed = ms(new Date() - start)
-
-    let message = `For more info, please head to https://zeit.co`
-    message = currentTeam
-      ? `${message}/${currentTeam.slug}/settings/plan`
-      : `${message}/account/plan`
-    message += `\n> Select a plan for ${bold(
-      (currentTeam && currentTeam.slug) || user.username || user.email
-    )} ${chalk.gray(`[${elapsed}]`)}`
-    const choices = buildInquirerChoices(currentPlan.id, currentPlan.until)
-
-    planId = await listInput({
-      message,
-      choices,
-      separator: false,
-      abort: 'end'
-    })
-  }
-
-  if (
-    planId === undefined ||
-    (planId === currentPlan.id && currentPlan.until === undefined)
-  ) {
-    return console.log('No changes made')
-  }
-
-  let newPlan
-
-  try {
-    newPlan = await plans.set(planId)
-  } catch (err) {
-    if (err.code === 'customer_not_found' || err.code === 'source_not_found') {
-      error(
-        `You have no payment methods available. Run ${cmd(
-          'now billing add'
-        )} to add one`
-      )
-    } else {
-      error(`An unknow error occured. Please try again later ${err.message}`)
-    }
-    plans.close()
-    return
-  }
-
-  if (currentPlan.until && newPlan.id !== 'oss') {
-    success(
-      `The cancelation has been undone. You're back on the ${chalk.bold(
-        `${newPlan.name} plan`
-      )}`
-    )
-  } else if (newPlan.until) {
-    success(
-      `Your plan will be switched to ${chalk.bold(
-        newPlan.name
-      )} in ${chalk.bold(newPlan.until)}. Your card will not be charged again`
-    )
-  } else {
-    success(`You're now on the ${chalk.bold(`${newPlan.name} plan`)}`)
-  }
-
-  plans.close()
-}

bin/now-whoami.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-// Packages
-const minimist = require('minimist')
-const chalk = require('chalk')
-
-// Ours
-const cfg = require('../lib/cfg')
-const exit = require('../lib/utils/exit')
-const cmd = require('../lib/utils/output/cmd')
-const logo = require('../lib/utils/output/logo')
-
-const argv = minimist(process.argv.slice(2), {
-  string: ['config', 'token'],
-  boolean: ['help', 'debug', 'all'],
-  alias: {
-    help: 'h',
-    config: 'c',
-    debug: 'd',
-    token: 't'
-  }
-})
-
-const help = () => {
-  console.log(`
-  ${chalk.bold(`${logo} now whoami`)}
-
-  ${chalk.dim('Options:')}
-
-    -h, --help              Output usage information
-    -c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
-    'FILE'
-  )}  Config file
-    -d, --debug             Debug mode [off]
-    -t ${chalk.bold.underline('TOKEN')}, --token=${chalk.bold.underline(
-    'TOKEN'
-  )} Login token
-
-  ${chalk.dim('Examples:')}
-
-  ${chalk.gray('–')} Show the current team context
-
-    ${chalk.cyan('$ now whoami')}
-`)
-}
-
-if (argv.help) {
-  help()
-  process.exit(0)
-}
-
-if (argv.config) {
-  cfg.setConfigFile(argv.config)
-}
-
-async function whoami() {
-  const config = await cfg.read({ token: argv.token })
-  if (!config || !config.token) {
-    console.log(
-      `> Not currently logged in! Please run ${cmd('now --login')}.\n`
-    )
-    return exit(1)
-  }
-
-  if (process.stdout.isTTY) {
-    process.stdout.write('> ')
-  }
-
-  const { user } = config
-  const name = user.username || user.email
-  console.log(name)
-}
-
-whoami()

bin/now.js

@@ -1,142 +0,0 @@
-#!/usr/bin/env node
-
-// Native
-const { resolve } = require('path')
-
-// Packages
-const updateNotifier = require('update-notifier')
-const chalk = require('chalk')
-
-// Check if the current path exists and throw and error
-// if the user is trying to deploy a non-existing path!
-// This needs to be done exactly in this place, because
-// the utility imports are taking advantage of it
-try {
-  process.cwd()
-} catch (err) {
-  if (err.code === 'ENOENT' && err.syscall === 'uv_cwd') {
-    console.log(`Current path doesn't exist!`)
-  } else {
-    console.log(err)
-  }
-
-  process.exit(1)
-}
-
-// Utilities
-const pkg = require('../lib/pkg')
-
-if (process.pkg) {
-  const notifier = updateNotifier({ pkg })
-  const update = notifier.update
-
-  if (update) {
-    let message = `Update available! ${chalk.red(
-      update.current
-    )} → ${chalk.green(update.latest)} \n`
-    message += `${chalk.magenta(
-      'Changelog:'
-    )} https://github.com/zeit/now-cli/releases/tag/${update.latest}\n`
-
-    if (pkg._npmPkg) {
-      message += `Run ${chalk.magenta('npm i -g now')} to update!`
-    } else {
-      message += `Please download binaries from https://zeit.co/download`
-    }
-
-    notifier.notify({ message })
-  }
-}
-
-// This command will be run if no other sub command is specified
-const defaultCommand = 'deploy'
-
-const commands = new Set([
-  defaultCommand,
-  'help',
-  'list',
-  'ls',
-  'rm',
-  'remove',
-  'alias',
-  'aliases',
-  'ln',
-  'domain',
-  'domains',
-  'dns',
-  'cert',
-  'certs',
-  'secret',
-  'secrets',
-  'cc',
-  'billing',
-  'upgrade',
-  'downgrade',
-  'team',
-  'teams',
-  'switch',
-  'log',
-  'logs',
-  'scale',
-  'logout',
-  'whoami'
-])
-
-const aliases = new Map([
-  ['ls', 'list'],
-  ['rm', 'remove'],
-  ['ln', 'alias'],
-  ['aliases', 'alias'],
-  ['domain', 'domains'],
-  ['cert', 'certs'],
-  ['secret', 'secrets'],
-  ['cc', 'billing'],
-  ['downgrade', 'upgrade'],
-  ['team', 'teams'],
-  ['switch', 'teams switch'],
-  ['log', 'logs']
-])
-
-let cmd = defaultCommand
-let args = process.argv.slice(2)
-const index = args.findIndex(a => commands.has(a))
-
-if (index > -1) {
-  cmd = args[index]
-  args.splice(index, 1)
-
-  if (cmd === 'help') {
-    if (index < args.length && commands.has(args[index])) {
-      cmd = args[index]
-      args.splice(index, 1)
-    } else {
-      cmd = defaultCommand
-    }
-
-    args.unshift('--help')
-  }
-
-  cmd = aliases.get(cmd) || cmd
-  if (cmd.includes(' ')) {
-    const parts = cmd.split(' ')
-    cmd = parts.shift()
-    args = [].concat(parts, args)
-  }
-}
-
-// Don't throw a useless error message when running `now help help`
-// rather show the general help and be useful
-if (cmd === 'help') {
-  cmd = 'deploy'
-} else if (cmd === defaultCommand && args[0] === 'login') {
-  args[0] = '--login'
-}
-
-const bin = resolve(__dirname, 'now-' + cmd + '.js')
-
-// Prepare process.argv for subcommand
-process.argv = process.argv.slice(0, 2).concat(args)
-
-// Load sub command
-// With custom parameter to make "pkg" happy
-require(bin, 'may-exclude')

bin/teams/add.js

@@ -1,135 +0,0 @@
-// Packages
-const chalk = require('chalk')
-
-// Ours
-const stamp = require('../../lib/utils/output/stamp')
-const info = require('../../lib/utils/output/info')
-const error = require('../../lib/utils/output/error')
-const wait = require('../../lib/utils/output/wait')
-const rightPad = require('../../lib/utils/output/right-pad')
-const eraseLines = require('../../lib/utils/output/erase-lines')
-const { tick } = require('../../lib/utils/output/chars')
-const success = require('../../lib/utils/output/success')
-const cmd = require('../../lib/utils/output/cmd')
-const note = require('../../lib/utils/output/note')
-const uid = require('../../lib/utils/output/uid')
-const textInput = require('../../lib/utils/input/text')
-const exit = require('../../lib/utils/exit')
-const cfg = require('../../lib/cfg')
-
-function validateSlugKeypress(data, value) {
-  // TODO: the `value` here should contain the current value + the keypress
-  // should be fixed on utils/input/text.js
-  return /^[a-zA-Z]+[a-zA-Z0-9_-]*$/.test(value + data)
-}
-
-function gracefulExit() {
-  console.log() // Blank line
-  note(
-    `Your team is now active for all ${cmd('now')} commands!\n  Run ${cmd(
-      'now switch'
-    )} to change it in the future.`
-  )
-  return exit()
-}
-
-const teamUrlPrefix = rightPad('Team URL', 14) + chalk.gray('zeit.co/')
-const teamNamePrefix = rightPad('Team Name', 14)
-
-module.exports = async function({ teams, token }) {
-  let slug
-  let team
-  let elapsed
-  let stopSpinner
-
-  info(
-    `Pick a team identifier for its url (e.g.: ${chalk.cyan('`zeit.co/acme`')})`
-  )
-  do {
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      slug = await textInput({
-        label: `- ${teamUrlPrefix}`,
-        validateKeypress: validateSlugKeypress,
-        initialValue: slug,
-        valid: team,
-        forceLowerCase: true
-      })
-    } catch (err) {
-      if (err.message === 'USER_ABORT') {
-        info('Aborted')
-        return exit()
-      }
-      throw err
-    }
-    elapsed = stamp()
-    stopSpinner = wait(teamUrlPrefix + slug)
-
-    let res
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      res = await teams.create({ slug })
-      stopSpinner()
-      team = res
-    } catch (err) {
-      stopSpinner()
-      eraseLines(2)
-      error(err.message)
-    }
-  } while (!team)
-
-  eraseLines(2)
-  success(`Team created ${uid(team.id)} ${elapsed()}`)
-  console.log(chalk.cyan(`${tick} `) + teamUrlPrefix + slug + '\n')
-
-  info('Pick a display name for your team')
-  let name
-  try {
-    name = await textInput({
-      label: `- ${teamNamePrefix}`,
-      validateValue: value => value.trim().length > 0
-    })
-  } catch (err) {
-    if (err.message === 'USER_ABORT') {
-      info('No name specified')
-      gracefulExit()
-    } else {
-      throw err
-    }
-  }
-  elapsed = stamp()
-  stopSpinner = wait(teamNamePrefix + name)
-  const res = await teams.edit({ id: team.id, name })
-  stopSpinner()
-
-  eraseLines(2)
-  if (res.error) {
-    error(res.error.message)
-    console.log(`${chalk.red(`✖ ${teamNamePrefix}`)}${name}`)
-    exit(1)
-    // TODO: maybe we want to ask the user to retry? not sure if
-    // there's a scenario where that would be wanted
-  }
-
-  team = Object.assign(team, res)
-
-  success(`Team name saved ${elapsed()}`)
-  console.log(chalk.cyan(`${tick} `) + teamNamePrefix + team.name + '\n')
-
-  stopSpinner = wait('Saving')
-  await cfg.merge({ currentTeam: team })
-  stopSpinner()
-
-  await require('./invite')({
-    teams,
-    args: [],
-    token,
-    introMsg:
-      'Invite your team mates! When done, press enter on an empty field',
-    noopMsg: `You can invite team mates later by running ${cmd(
-      'now teams invite'
-    )}`
-  })
-
-  gracefulExit()
-}

bin/teams/invite.js

@@ -1,160 +0,0 @@
-// Packages
-const chalk = require('chalk')
-
-// Ours
-const regexes = require('../../lib/utils/input/regexes')
-const wait = require('../../lib/utils/output/wait')
-const cfg = require('../../lib/cfg')
-const fatalError = require('../../lib/utils/fatal-error')
-const cmd = require('../../lib/utils/output/cmd')
-const info = require('../../lib/utils/output/info')
-const stamp = require('../../lib/utils/output/stamp')
-const param = require('../../lib/utils/output/param')
-const { tick } = require('../../lib/utils/output/chars')
-const rightPad = require('../../lib/utils/output/right-pad')
-const textInput = require('../../lib/utils/input/text')
-const eraseLines = require('../../lib/utils/output/erase-lines')
-const success = require('../../lib/utils/output/success')
-const error = require('../../lib/utils/output/error')
-
-function validateEmail(data) {
-  return regexes.email.test(data.trim()) || data.length === 0
-}
-
-const domains = Array.from(
-  new Set([
-    'aol.com',
-    'gmail.com',
-    'google.com',
-    'yahoo.com',
-    'ymail.com',
-    'hotmail.com',
-    'live.com',
-    'outlook.com',
-    'inbox.com',
-    'mail.com',
-    'gmx.com',
-    'icloud.com'
-  ])
-)
-
-function emailAutoComplete(value, teamSlug) {
-  const parts = value.split('@')
-
-  if (parts.length === 2 && parts[1].length > 0) {
-    const [, host] = parts
-    let suggestion = false
-
-    domains.unshift(teamSlug)
-    for (const domain of domains) {
-      if (domain.startsWith(host)) {
-        suggestion = domain.substr(host.length)
-        break
-      }
-    }
-
-    domains.shift()
-    return suggestion
-  }
-
-  return false
-}
-
-module.exports = async function(
-  { teams, args, token, introMsg, noopMsg = 'No changes made' } = {}
-) {
-  const { user, currentTeam } = await cfg.read({ token })
-
-  domains.push(user.email.split('@')[1])
-
-  if (!currentTeam) {
-    let err = `You can't run this command under ${param(
-      user.username || user.email
-    )}.\n`
-    err += `${chalk.gray('>')} Run ${cmd('now switch')} to choose to a team.`
-    return fatalError(err)
-  }
-
-  info(introMsg || `Inviting team members to ${chalk.bold(currentTeam.name)}`)
-
-  if (args.length > 0) {
-    for (const email of args) {
-      if (regexes.email.test(email)) {
-        const stopSpinner = wait(email)
-        const elapsed = stamp()
-        // eslint-disable-next-line no-await-in-loop
-        await teams.inviteUser({ teamId: currentTeam.id, email })
-        stopSpinner()
-        console.log(`${chalk.cyan(tick)} ${email} ${elapsed()}`)
-      } else {
-        console.log(`${chalk.red(`✖ ${email}`)} ${chalk.gray('[invalid]')}`)
-      }
-    }
-    return
-  }
-
-  const inviteUserPrefix = rightPad('Invite User', 14)
-  const emails = []
-  let hasError = false
-  let email
-  do {
-    email = ''
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      email = await textInput({
-        label: `- ${inviteUserPrefix}`,
-        validateValue: validateEmail,
-        autoComplete: value => emailAutoComplete(value, currentTeam.slug)
-      })
-    } catch (err) {
-      if (err.message !== 'USER_ABORT') {
-        throw err
-      }
-    }
-    let elapsed
-    let stopSpinner
-    if (email) {
-      elapsed = stamp()
-      stopSpinner = wait(inviteUserPrefix + email)
-      try {
-        // eslint-disable-next-line no-await-in-loop
-        await teams.inviteUser({ teamId: currentTeam.id, email })
-        stopSpinner()
-        email = `${email} ${elapsed()}`
-        emails.push(email)
-        console.log(`${chalk.cyan(tick)} ${inviteUserPrefix}${email}`)
-        if (hasError) {
-          hasError = false
-          eraseLines(emails.length + 2)
-          info(
-            introMsg ||
-              `Inviting team members to ${chalk.bold(currentTeam.name)}`
-          )
-          for (const email of emails) {
-            console.log(`${chalk.cyan(tick)} ${inviteUserPrefix}${email}`)
-          }
-        }
-      } catch (err) {
-        stopSpinner()
-        eraseLines(emails.length + 2)
-        error(err.message)
-        hasError = true
-        for (const email of emails) {
-          console.log(`${chalk.cyan(tick)} ${inviteUserPrefix}${email}`)
-        }
-      }
-    }
-  } while (email !== '')
-
-  eraseLines(emails.length + 2)
-
-  const n = emails.length
-  if (emails.length === 0) {
-    info(noopMsg)
-  } else {
-    success(`Invited ${n} team mate${n > 1 ? 's' : ''}`)
-    for (const email of emails) {
-      console.log(`${chalk.cyan(tick)} ${inviteUserPrefix}${email}`)
-    }
-  }
-}

bin/teams/list.js

@@ -1,62 +0,0 @@
-const chalk = require('chalk')
-
-const wait = require('../../lib/utils/output/wait')
-const cfg = require('../../lib/cfg')
-const info = require('../../lib/utils/output/info')
-const error = require('../../lib/utils/output/error')
-const { tick: tickChar } = require('../../lib/utils/output/chars')
-const table = require('../../lib/utils/output/table')
-
-module.exports = async function({ teams, token }) {
-  const stopSpinner = wait('Fetching teams')
-  const list = (await teams.ls()).teams
-  let { user, currentTeam } = await cfg.read({ token })
-  const accountIsCurrent = !currentTeam
-  stopSpinner()
-
-  if (accountIsCurrent) {
-    currentTeam = {
-      slug: user.username || user.email
-    }
-  }
-
-  const teamList = list.map(({ slug, name }) => {
-    return {
-      name,
-      value: slug,
-      current: slug === currentTeam.slug ? tickChar : ''
-    }
-  })
-
-  teamList.unshift({
-    name: user.email,
-    value: user.username || user.email,
-    current: (accountIsCurrent && tickChar) || ''
-  })
-
-  // Let's bring the current team to the beginning of the list
-  if (!accountIsCurrent) {
-    const index = teamList.findIndex(
-      choice => choice.value === currentTeam.slug
-    )
-    const choice = teamList.splice(index, 1)[0]
-    teamList.unshift(choice)
-  }
-
-  // Printing
-  const count = teamList.length
-  if (!count) {
-    // Maybe should not happen
-    error(`No team found`)
-    return
-  }
-
-  info(`${chalk.bold(count)} team${count > 1 ? 's' : ''} found`)
-  console.log()
-
-  table(
-    ['', 'id', 'email / name'],
-    teamList.map(team => [team.current, team.value, team.name]),
-    [1, 5]
-  )
-}

bin/teams/switch.js

@@ -1,124 +0,0 @@
-const chalk = require('chalk')
-
-const wait = require('../../lib/utils/output/wait')
-const listInput = require('../../lib/utils/input/list')
-const cfg = require('../../lib/cfg')
-const exit = require('../../lib/utils/exit')
-const success = require('../../lib/utils/output/success')
-const info = require('../../lib/utils/output/info')
-const error = require('../../lib/utils/output/error')
-const param = require('../../lib/utils/output/param')
-
-async function updateCurrentTeam({ cfg, newTeam } = {}) {
-  delete newTeam.created
-  delete newTeam.creator_id
-  await cfg.merge({ currentTeam: newTeam })
-}
-
-module.exports = async function({ teams, args, token }) {
-  let stopSpinner = wait('Fetching teams')
-  const list = (await teams.ls()).teams
-  let { user, currentTeam } = await cfg.read({ token })
-  const accountIsCurrent = !currentTeam
-  stopSpinner()
-
-  if (accountIsCurrent) {
-    currentTeam = {
-      slug: user.username || user.email
-    }
-  }
-
-  if (args.length !== 0) {
-    const desiredSlug = args[0]
-
-    const newTeam = list.find(team => team.slug === desiredSlug)
-    if (newTeam) {
-      await updateCurrentTeam({ cfg, newTeam })
-      success(`The team ${chalk.bold(newTeam.name)} is now active!`)
-      return exit()
-    }
-    if (desiredSlug === user.username) {
-      stopSpinner = wait('Saving')
-      await cfg.remove('currentTeam')
-      stopSpinner()
-      return success(`Your account (${chalk.bold(desiredSlug)}) is now active!`)
-    }
-    error(`Could not find membership for team ${param(desiredSlug)}`)
-    return exit(1)
-  }
-
-  const choices = list.map(({ slug, name }) => {
-    name = `${slug} (${name})`
-    if (slug === currentTeam.slug) {
-      name += ` ${chalk.bold('(current)')}`
-    }
-
-    return {
-      name,
-      value: slug,
-      short: slug
-    }
-  })
-
-  const suffix = accountIsCurrent ? ` ${chalk.bold('(current)')}` : ''
-
-  const userEntryName = user.username
-    ? `${user.username} (${user.email})${suffix}`
-    : user.email
-
-  choices.unshift({
-    name: userEntryName,
-    value: user.email,
-    short: user.username
-  })
-
-  // Let's bring the current team to the beginning of the list
-  if (!accountIsCurrent) {
-    const index = choices.findIndex(choice => choice.value === currentTeam.slug)
-    const choice = choices.splice(index, 1)[0]
-    choices.unshift(choice)
-  }
-
-  let message
-
-  if (currentTeam) {
-    message = `Switch to:`
-  }
-
-  const choice = await listInput({
-    message,
-    choices,
-    separator: false
-  })
-
-  // Abort
-  if (!choice) {
-    info('No changes made')
-    return exit()
-  }
-
-  const newTeam = list.find(item => item.slug === choice)
-
-  // Switch to account
-  if (!newTeam) {
-    if (currentTeam.slug === user.username || currentTeam.slug === user.email) {
-      info('No changes made')
-      return exit()
-    }
-    stopSpinner = wait('Saving')
-    await cfg.remove('currentTeam')
-    stopSpinner()
-    return success(`Your account (${chalk.bold(choice)}) is now active!`)
-  }
-
-  if (newTeam.slug === currentTeam.slug) {
-    info('No changes made')
-    return exit()
-  }
-
-  stopSpinner = wait('Saving')
-  await updateCurrentTeam({ cfg, newTeam })
-  stopSpinner()
-
-  success(`The team ${chalk.bold(newTeam.name)} is now active!`)
-}

download/install.js

@@ -1,30 +0,0 @@
-/* eslint-disable no-var */
-
-// Native
-var path = require('path')
-var fs = require('fs')
-
-var dist = path.join(__dirname, 'dist')
-var src = path.join(__dirname, 'src')
-
-// Don't install when developing locally
-if (fs.existsSync(src)) {
-  // eslint-disable-next-line unicorn/no-process-exit
-  process.exit(0)
-}
-
-var download = path.join(dist, 'download.js')
-
-try {
-  fs.mkdirSync(dist)
-} catch (err) {
-  if (err.code !== 'EEXIST') {
-    throw err
-  }
-}
-
-fs.closeSync(
-  fs.openSync(download, 'a')
-)
-
-require(download)

download/src/chmod.js

@@ -1,9 +0,0 @@
-import fs from 'fs'
-
-export default function (file) {
-  const s = fs.statSync(file)
-  const newMode = s.mode | 64 | 8 | 1
-  if (s.mode === newMode) return
-  const base8 = newMode.toString(8).slice(-3)
-  fs.chmodSync(file, base8)
-}

download/src/index.js

@@ -1,110 +0,0 @@
-/* eslint-disable unicorn/no-process-exit */
-
-// Native
-import fs from 'fs'
-import path from 'path'
-
-// Packages
-import onDeath from 'death'
-import fetch from 'node-fetch'
-
-// Utilities
-import plusxSync from './chmod'
-import { disableProgress, enableProgress, info, showProgress } from './log'
-
-const now = path.join(__dirname, 'now')
-const targetWin32 = path.join(__dirname, 'now.exe')
-const target = process.platform === 'win32' ? targetWin32 : now
-const partial = target + '.partial'
-
-const packagePath = path.join(__dirname, '../../package.json')
-const packageJSON = JSON.parse(fs.readFileSync(packagePath, 'utf8'))
-
-const platformToName = {
-  darwin: 'now-macos',
-  linux: 'now-linux',
-  win32: 'now-win.exe'
-}
-
-async function main() {
-  fs.writeFileSync(
-    now,
-    '#!/usr/bin/env node\n' +
-      'console.log("Please wait until the \'now\' installation completes!")\n'
-  )
-
-  onDeath(() => {
-    fs.writeFileSync(
-      now,
-      '#!/usr/bin/env node\n' +
-        'console.log("The \'now\' installation did not complete successfully.")\n' +
-        'console.log("Please run \'npm i -g now\' to reinstall!")\n'
-    )
-    process.exit();
-  })
-
-  info('For the sources, check out: https://github.com/zeit/now-cli')
-
-  // Print an empty line
-  console.log('')
-
-  enableProgress('Downloading now CLI ' + packageJSON.version)
-  showProgress(0)
-
-  const name = platformToName[process.platform]
-  const url = `https://github.com/zeit/now-cli/releases/download/${packageJSON.version}/${name}`
-  const resp = await fetch(url)
-
-  if (resp.status !== 200) {
-    disableProgress()
-    throw new Error(resp.statusText + ' ' + url)
-  }
-
-  const size = resp.headers.get('content-length')
-  const ws = fs.createWriteStream(partial)
-
-  await new Promise((resolve, reject) => {
-    let bytesRead = 0
-
-    resp.body.on('data', chunk => {
-      bytesRead += chunk.length
-      showProgress(100 * bytesRead / size)
-    }).on('error', error => {
-      disableProgress()
-      reject(error)
-    })
-
-    resp.body.pipe(ws)
-
-    ws.on('close', () => {
-      showProgress(100)
-      disableProgress()
-      resolve()
-    }).on('error', error => {
-      disableProgress()
-      reject(error)
-    })
-  })
-
-  fs.renameSync(partial, target)
-
-  if (process.platform === 'win32') {
-    fs.writeFileSync(
-      now,
-      '#!/usr/bin/env node\n' +
-        'var chip = require("child_process")\n' +
-        'var args = process.argv.slice(2)\n' +
-        'var opts = { stdio: "inherit" }\n' +
-        'var r = chip.spawnSync(__dirname + "/now.exe", args, opts)\n' +
-        'if (r.error) throw r.error\n' +
-        'process.exit(r.status)\n'
-    )
-  } else {
-    plusxSync(now)
-  }
-}
-
-main().catch(err => {
-  console.error(err)
-  process.exit(2)
-})

download/src/log.js

@@ -1,38 +0,0 @@
-// Packages
-import assert from 'assert'
-import Progress from 'progress'
-
-let bar
-
-export function enableProgress(text) {
-  assert(!bar)
-  // OLD: text += ' '.repeat(28 - text.length);
-  bar = new Progress(`> ${text} [:bar] :percent`, {
-    stream: process.stdout,
-    width: 20,
-    complete: '=',
-    incomplete: ' ',
-    total: 100
-  })
-}
-
-export function info(text) {
-  console.log(`> ${text}`)
-}
-
-export function showProgress(percentage) {
-  assert(bar)
-  bar.update(percentage / 100)
-}
-
-export function disableProgress() {
-  assert(bar)
-
-  // It is auto-completed once it updates to 100
-  // otherwise it outputs a blank line
-  if (!bar.complete) {
-    bar.update(1)
-  }
-
-  bar = undefined
-}

download/webpack.js

@@ -1,40 +0,0 @@
-const path = require('path')
-const webpack = require('webpack')
-
-module.exports = {
-  target: 'node',
-  node: {
-    __dirname: false,
-    __filename: false
-  },
-  entry: [
-    './src/index.js'
-  ],
-  output: {
-    path: path.join(__dirname, 'dist'),
-    filename: 'download.js'
-  },
-  module: {
-    loaders: [ {
-      test: /.js$/,
-      loader: 'babel-loader',
-      exclude: /node_modules/,
-      query: {
-        plugins: [
-          'transform-async-to-generator',
-          'transform-runtime'
-        ],
-        presets: [
-          'es2015'
-        ]
-      }
-    } ]
-  },
-  plugins: [
-    new webpack.DefinePlugin({
-      'process.env': {
-        NODE_ENV: JSON.stringify('production')
-      }
-    })
-  ]
-}

errors/cant-solve-challenge.md

@@ -0,0 +1,27 @@
+# The DNS Challenge Could Not Be Solved
+
+## Why This Error Occurred
+
+When generating a certificate, we have to prove ownership over the domain
+for the Certificate Authority (CA) that issues it. This error means that
+the provider couldn’t solve the requested challenges.
+
+## How to Fix It
+
+If your domain is pointing to ZEIT World DNS and you’re getting this error,
+it could be that:
+
+- The domain was acquired recently, and it might not be ready for use yet.
+- Required DNS records have not propagated yet.
+
+When running into this, ensure that your nameservers are configured correctly. Also, if you bought the domain recently or have made changes, please be patient,
+it might take a while for these to be ready.
+
+If your domain is _not_ pointing to ZEIT World DNS and you’re getting this
+error, the following methods could help:
+
+- When solving challenges *manually*, ensure that the TXT
+records required to solve the challenges exist and are propagated. You can do so by querying the nameservers with `nslookup -q=TXT _acme-challenge.domain.com` depending on the Common Names you want for your certificate.
+
+- If you are not solving the challenges manually you must ensure that you have an
+`ALIAS` and `CNAME` records in place. Ensure also that you have disabled automatic redirects to `https` and ensure all changes were propagated.

errors/deploy-invalid-dc.md

@@ -0,0 +1,37 @@
+# Invalid Region or DC Identifier
+
+#### Why This Error Occurred
+
+When supplying `regions` or `scale` settings, you
+used an unknown or invalid dc identifier.
+
+#### Possible Ways to Fix It
+
+Check your `now.json` or `--regions` flag and
+make sure you are using a valid string. Regions
+and DCs have to be in *lowercase*.
+
+**Valid region identifiers**:
+
+- `all` (special, used to scale to all DCs, can only appear once)
+- `sfo`
+- `bru`
+- `gru`
+- `iad`
+
+In `now-cli`, they currently are transformed to 
+DC identifiers before being sent to our APIs.
+
+**Valid DC identifiers**:
+
+- `sfo1`
+- `bru1`
+- `gru1`
+- `iad1`
+
+When passing multiple `--regions` as a CLI parameter,
+make sure they're separated by a comma (`,`). For example:
+
+```console
+now --regions sfo,bru,gru
+```

errors/dns-configuration-error.md

@@ -0,0 +1,23 @@
+# The DNS Configuration can't be verified
+
+## Why This Error Occurred
+
+When generating a certificate, we have to prove ownership over the domain
+for the Certificate Authority (CA) that issues it. We also run some pretests
+to make sure the DNS is properly configured before submitting the request to 
+the CA. This error means that these pretests did not succeed.
+
+## How to Fix It
+
+If your domain is pointing to ZEIT World DNS and you’re getting this error,
+it could be that:
+
+- The domain was acquired recently, and it might not be ready for use yet.
+- Required DNS records have not propagated yet.
+
+When running into this, ensure that your nameservers have configuration is correct. Also, if you bought the domain recently or have made changes, please be patient,
+it might take a while for these to be ready.
+
+If your domain is _not_ pointing to ZEIT World DNS and you’re getting this
+error, you must ensure that you have an `ALIAS` and `CNAME` records in place.
+Ensure also that you have disabled automatic redirects to `https` and ensure all changes were propagated.

errors/domain-verification.md

@@ -0,0 +1,21 @@
+# Domain Verification
+
+#### Why This Error Occurred
+
+The domain you supplied cannot be verified using either the intended set of nameservers of the given verification TXT record.
+
+#### Possible Ways to Fix It
+
+Apply the intended set of nameservers to your domain or add the given TXT verification record through your domain provider.
+
+You can retrieve both the intended nameservers and TXT verification record for the domain you wish to verify by running `now domains inspect <domain>`.
+
+When you have added either verification method to your domain, you can run `now domains verify <domain>` again to complete verification for your domain.
+
+ZEIT will also automatically check periodically that your domain has been verified and automatically mark it as such if we detect either verification method on the domain.
+
+If you would not like to verify your domain, you can remove it from your account using `now domains rm <domain>`.
+
+#### Resources
+- [ZEIT Domains Documentation](https://zeit.co/docs/v2/domains-and-aliases/adding-a-domain/)
+- [Zero-Downtime Domain Migration Guide](https://zeit.co/docs/v2/domains-and-aliases/zero-downtime-domain-migration/)

errors/env-no-secret.md

@@ -0,0 +1,17 @@
+# Secret Not Found
+
+#### Why This Error Occurred
+
+You specified the `--env` or `-e` flag with the value of a secret. However, the secret doesn't exist in the current scope you're in.
+
+#### Possible Ways to Fix It
+
+Make sure to specify the environment variable and secret like that:
+
+```bash
+now -e VARIABLE_NAME=@secret-name
+```
+
+In addition, ensure that the secret (`@secret-name` in the example above) exists in the current scope (the team or user account that you're using).
+
+You can run `now switch` or `--scope` to switch to a different team or user.

errors/env-value-invalid-type.md

@@ -0,0 +1,21 @@
+# Bad Type in Env Value
+
+#### Why This Error Occurred
+
+You supplied a value in the `env` of your deployment whose type is not allowed.
+
+This occurs for example if you use a `Boolean` as a type:
+
+```json
+{
+  "env": {
+    "VALID": 1,
+    "INVALID": true
+  }
+}
+```
+
+#### Possible Ways to Fix It
+
+The only accepted types are `String` or `Number`. If you're using a
+`Boolean`, consider using `1` (`Number`) or `"true"` (`String`).

errors/missing-dotenv-target.md

@@ -0,0 +1,9 @@
+# Missing `--dotenv` Target
+
+#### Why This Error Occurred
+
+You specified a path as the value for the `--dotenv` flag, but the target of the path doesn't exist.
+
+#### Possible Ways to Fix It
+
+Make sure the target file you've specified exists and is readable by Now CLI. In addition, please ensure that the filename starts with a dot (example: `.env`) - then it should work.

errors/missing-env-file.md

@@ -0,0 +1,26 @@
+# Missing Environment Variables While Developing
+
+#### Why This Error Occurred
+You ran `now dev` inside a project that contains a `now.json` file with `env` or `build.env` properties that use [Now Secrets](https://zeit.co/docs/v2/deployments/environment-variables-and-secrets).
+
+In order to use environment variables in your project locally that have values defined using the Now Secrets format (e.g. `@my-secret-value`), you will need to provide the value as an environment variable using a `.env` or `.env.build` file.
+
+We require this to ensure your app works as you intend it to, in the Now Dev environment, and to provide you with a way to mirror or separate private environment variables within your applications, for example when connecting to a database.
+
+Read below for how to address this error.
+
+#### Possible Ways to Fix It
+
+The error message will list environment variables that are required and which file they are required to be included in (either `.env` or `.env.build`).
+
+If the file does not exist yet, please create the file that the error message mentions and insert the missing environment variable into it.
+
+For example, if the error message shows that the environment variable `TEST` is missing from `.env`, then the `.env` file should look like this:
+
+```
+TEST=value
+```
+
+In the above example, `TEST` represents the name of the environment variable and `value` its value.
+
+For more information on Environment Variables in development, [see the documentation](https://zeit.co/docs/v2/development/environment-variables/).

errors/missing-env-key-value.md

@@ -0,0 +1,19 @@
+# Missing Env Key and Value
+
+#### Why This Error Occurred
+
+You specified the `--env` or `-e` flag and didn't add a name and value for the environment variable.
+
+#### Possible Ways to Fix It
+
+Make sure to set the name and value of the variable like this:
+
+```bash
+now -e VARIABLE_NAME="VALUE"
+```
+
+You can also specify a environment variable that contains a secret:
+
+```bash
+now -e VARIABLE_NAME=@secret-name
+```

errors/missing-scope-value.md

@@ -0,0 +1,11 @@
+# Missing Scope Value
+
+#### Why This Error Occurred
+
+The `--scope` flag was specified, but there's no value for it available.
+
+#### Possible Ways to Fix It
+
+In order to make it work, you need to specify a value for the `--scope` flag. This needs to be the slug or ID of the team as which you'd like to act or the username or ID of a user you'd like to act as.
+
+As an example, if your team URL is `https://zeit.co/teams/zeit`, you would set `--scope` to `zeit`.

errors/missing-token-value.md

@@ -0,0 +1,11 @@
+# Missing Token Value
+
+#### Why This Error Occurred
+
+The `--token` flag was specified, but there's no value for it available.
+
+#### Possible Ways to Fix It
+
+In order to make it work, you need to specify a value for the `--token` flag. This needs to be the token of the user account as which you'd like to act.
+
+You can either get the token from the `./now/auth.json` file located in your user directory or [from the dashboard](https://zeit.co/account/tokens).

errors/no-credentials-found.md

@@ -0,0 +1,10 @@
+# No Credentials Found
+
+#### Why This Error Occurred
+
+You're running Now CLI in a non-terminal context and there are no credentials available. This means that Now CLI is not able to authenticate against our service.
+
+#### Possible Ways to Fix It
+
+- Specify a value for the `--token` flag (this needs to be the token of the user account as which you'd like to act). You can either get the token from the `./now/auth.json` file located in your user directory or [from the dashboard](https://zeit.co/account/tokens).
+- Ensure that both `~/now/auth.json` and `~/now/config.json` exist

errors/no-open-port-found.md

@@ -0,0 +1,10 @@
+# No Open Port Found
+
+#### Why This Error Occurred
+
+Your application code exited or timed out before binding to a port number.
+
+#### Possible Ways to Fix It
+
+- For Node.js deployments, a call to [`Server#listen()`](https://nodejs.org/dist/latest/docs/api/http.html#http_server_listen) might be missing.
+- For Docker deployments, there might be a mismatch from what the `EXPOSE` directive specifies compared to what your application binds to.

errors/no-token-allowed.md

@@ -0,0 +1,11 @@
+# No Token Allowed
+
+#### Why This Error Occurred
+
+You tried to run a command that doesn't allow the `--token` flag (like `now switch`). This is not allowed because commands like these are influencing the configuration files.
+
+In turn, they would have to take the value of the `--token` flag into consideration (which is not a good idea, because flags in Now CLI should never change the configuration).
+
+#### Possible Ways to Fix It
+
+Specify a value for the `--scope` flag. This needs to be the slug or ID of the team as which you'd like to act (as an example, if your team URL is `https://zeit.co/teams/zeit`, the value can be `zeit`) or the username or ID of a user you'd like to act as.

errors/now-dev-as-dev-script.md

@@ -0,0 +1,9 @@
+# `now dev` as `dev` script
+
+#### Why This Error Occurred
+
+The `package.json` file of the used project invokes `now dev` as `dev` script. This would cause `now dev` to recursively invoke itself.
+
+#### Possible Ways to Fix It
+
+Adjust the `dev` script inside the `package.json` file to match what your framework uses to begin development mode, e.g. `next` for Next.js or `gatsby develop` for Gatsby.

errors/now-next-legacy-mode.md

@@ -0,0 +1,72 @@
+# `@now/next` Legacy Mode
+
+#### Why This Warning Occurred
+
+`@now/next` has two modes: `legacy` and `serverless`. You will always want to use the `serverless` mode. `legacy` is to provide backwards compatibility with previous `@now/next` versions.
+
+The differences:
+
+Legacy:
+
+- Minimal lambda size of `2.2Mb` (approximately)
+- Forces `next@v7.0.2-canary.49` and `next-server@v7.0.2-canary.49`
+- Forces all `dependencies` to be `devDependencies`
+- Loads `next.config.js` on bootup, breaking sometimes when users didn't use `phases` to load files
+- Used `next-server` which is the full Next.js server with routing etc.
+- Runs `npm install`
+- Runs `npm run now-build`
+- Runs `npm install --production` after build
+
+Serverless:
+
+- Minimal lambda size of `49Kb` (approximately)
+- Uses Next.js build targets (`target: 'serverless'`) in `next.config.js`. [documentation](https://github.com/zeit/next.js#summary)
+- Does not make changes to your application dependencies
+- Does not load `next.config.js` ([as per the serverless target documentation](https://github.com/zeit/next.js#summary))
+- Runs `npm install`
+- Runs `npm run now-build`
+- Does not run `npm install --production` as the output from the build is all that's needed to bundle lambdas.
+- No runtime dependencies, meaning smaller lambda functions
+- Optimized for fast [cold start](https://zeit.co/blog/serverless-ssr#cold-start)
+
+#### Possible Ways to Fix It
+
+In order to create the smallest possible lambdas Next.js has to be configured to build for the `serverless` target.
+
+1. Serverless Next.js requires Next.js 8 or later, to upgrade you can install the `latest` version:
+
+```
+npm install next --save
+```
+
+2. Add the `now-build` script to your `package.json`
+
+```json
+{
+  "scripts": {
+    "now-build": "next build"
+  }
+}
+```
+
+3. Add `target: 'serverless'` to `next.config.js`
+
+```js
+module.exports = {
+  target: 'serverless',
+  // Other options are still valid
+};
+```
+
+4. Optionally make sure the `"src"` in `"builds"` points to your application `package.json`
+
+```js
+{
+  "version": 2,
+  "builds": [{ "src": "package.json", "use": "@now/next" }]
+}
+```
+
+### Useful Links
+
+- [Serverless target implementation](https://github.com/zeit/now-builders/pull/150)

errors/now-next-no-serverless-pages-built.md

@@ -0,0 +1,45 @@
+# `@now/next` No Serverless Pages Built
+
+#### Why This Error Occurred
+
+This error occurs when you have your application is not configured for Serverless Next.js build output.
+
+#### Possible Ways to Fix It
+
+In order to create the smallest possible lambdas Next.js has to be configured to build for the `serverless` target.
+
+1. Serverless Next.js requires Next.js 8 or later, to upgrade you can install the `latest` version:
+
+```
+npm install next --save
+```
+
+2. Add the `now-build` script to your `package.json`
+
+```json
+{
+  "scripts": {
+    "now-build": "next build"
+  }
+}
+```
+
+3. Add `target: 'serverless'` to `next.config.js`
+
+```js
+module.exports = {
+  target: 'serverless',
+  // Other options
+};
+```
+
+4. Remove `distDir` from `next.config.js` as `@now/next` can't parse this file and expects your build output at `/.next`
+
+5. Optionally make sure the `"src"` in `"builds"` points to your application `package.json`
+
+```js
+{
+  "version": 2,
+  "builds": [{ "src": "package.json", "use": "@now/next" }]
+}
+```

errors/now-static-build-failed-to-detect-a-server.md

@@ -0,0 +1,38 @@
+# `@now/static-build` Failed to detect a server running
+
+#### Why This Warning Occurred
+
+When running `now dev`, the `@now/static-build` builder proxies relevant HTTP
+requests to the server that is created by the `now-dev` script in the
+`package.json` file.
+
+In order for `now dev` to know which port the server is running on, the builder
+is provided a `$PORT` environment variable that the server _must_ bind to. The
+error "Failed to detect a server running on port" is printed if the builder fails
+to detect a server listening on that specific port within five minutes.
+
+#### Possible Ways to Fix It
+
+Please ensure that your `now-dev` script binds the spawned development server on
+the provided `$PORT` that the builder expects the server to bind to.
+
+For example, if you are using Gatsby, your `now-dev` script must use the `-p`
+(port) option to bind to the `$PORT` specified from the builder:
+
+```
+{
+  ...
+  "scripts": {
+    ...
+    "now-dev": "gatsby develop -p $PORT"
+  }
+}
+```
+
+Consult your static builder program's `--help` or documentation to figure out what
+the command line flag to bind to a specific port is (in many cases, it is one of:
+`-p` / `-P` / `--port`).
+
+### Useful Links
+
+- [`@now/static-build` Local Development Documentation](https://zeit.co/docs/v2/deployments/official-builders/static-build-now-static-build#local-development)

errors/path-not-deployable.md

@@ -0,0 +1,15 @@
+# Path Not Deployable
+
+#### Why This Error Occurred
+
+You either tried to run Now CLI inside a directory that should never be deployed, or you specified a directory that should never be deployed like this: `now <directory>`.
+
+#### Possible Ways to Fix It
+
+Make sure that you're not trying to deploy one of these directories:
+
+- User
+- Downloads
+- Desktop
+
+These directories are not supported for security reasons.

errors/regions-and-scale-at-once.md

@@ -0,0 +1,32 @@
+# Can't Set `regions` and `scale` Options Simultaneously
+
+#### Why This Error Occurred
+
+Your deployment's configuration contains a `regions` and `scale`
+configuration simultaneously.
+
+#### Possible Ways to Fix It
+
+The `regions` setting is intended to be used to scale the
+deployment to the supplied regions or datacenters identifiers
+with default scale settings.
+
+```json
+{
+  "regions": ["sfo", "bru", "gru", "iad"]
+}
+```
+
+The `scale` object allows you to be more granular: you can decide a
+`min` and `max` number of instances per region:
+
+```json
+{
+  "scale": {
+    "sfo": { "min": 0, "max": 10 }
+  }
+}
+```
+
+To solve this problem, use only one of the two ways of deciding
+where to scale your deployment to.

errors/scale-invalid-dc.md

@@ -0,0 +1,36 @@
+# Invalid Region or DC Identifier
+
+#### Why This Error Occurred
+
+When supplying a region or DC identifier in `now scale`,
+we weren't able to recognize the value as valid.
+
+#### Possible Ways to Fix It
+
+Check your `now scale` command make sure you are using a
+valid string after the URL. Regions
+and DCs have to be in *lowercase*.
+
+**Valid region identifiers**:
+
+- `all` (special, used to scale to all DCs, can only appear once)
+- `sfo`
+- `bru`
+- `gru`
+- `iad`
+
+In `now-cli`, they currently are transformed to
+DC identifiers before being sent to our APIs.
+
+**Valid DC identifiers**:
+
+- `sfo1`
+- `bru1`
+- `gru1`
+- `iad1`
+
+To pass multiple ones, use a comma:
+
+```
+now scale my-url-123.now.sh sfo,bru,gru 1 5
+```

errors/scale-ls.md

@@ -0,0 +1,31 @@
+# `now scale ls` is deprecated
+
+#### Why This Error Occurred
+
+We have stopped supporting this command, in favor of
+better alternatives.
+
+`now scale ls` used to list all the scaling rules
+for all your deployments. The output would be too long,
+and it would often be hard to find the information
+you needed in a long list of items.
+
+#### Possible Ways to Fix It
+
+Instead of using `now scale ls` to list all your deployments
+and their scaling rules, first use `now ls` to find
+your deployment:
+
+```console
+now ls
+```
+
+Then, select the URL of your deployment, which uniquely identifies it, and run:
+
+```console
+now inspect my-deployment-12345.now.sh
+```
+
+The `inspect` subcommand will give you your deployment's scale information, including what datacenters it's enabled on, the
+current number of instances and minimums/maximums.
+

errors/scaling-path-alias.md

@@ -0,0 +1,12 @@
+# Scaling path alias
+
+#### Why This Error Occurred
+
+You tried to use `now scale` on a path alias (`now alias -r rules.json`). 
+
+#### Possible Ways to Fix It
+
+Path aliases are routes to instances. Instances can be scaled independent from each other.
+You can view path aliases by running `now alias ls <id>`.
+
+Documentation for Path Aliases can be found [here](https://zeit.co/docs/features/path-aliases).

errors/scope-not-accessible.md

@@ -0,0 +1,10 @@
+# Scope Not Accessible
+
+#### Why This Error Occurred
+
+You specified the `--scope` flag and specified the ID or slug of a team that you're not a part of or a user whose account you don't own. This problem could also occur if your user credentials aren't valid anymore.
+
+#### Possible Ways to Fix It
+
+- Make sure commands like `now ls` work just fine. This will ensure that your user credentials are valid. If it's not working correctly, please log in again using `now login`.
+- Ensure that the scope you specified using `--scope` shows up in the output of `now switch`. If it doesn't, you're either not part of the team (if you specified a team) or you logged into the wrong user account.

errors/scope-not-existent.md

@@ -0,0 +1,11 @@
+# Scope Not Existent
+
+#### Why This Error Occurred
+
+You specified the `--scope` flag and specified the ID or slug of a team that does not exist or that you're not a part of. Similarly you might have specified the ID or username of user whose account you don't own.
+
+#### Possible Ways to Fix It
+
+If you're sure the specified team exists, please make sure that you're a part of it (ask an owner of the team to invite you). If you specified the identifier of a user, make sure you are actually the owner of this account.
+
+Otherwise, either create a team with the specified slug or ensure that the identifier is correct if you're sure that the scope exists.

errors/solve-challenges-manually.md

@@ -0,0 +1,20 @@
+# DNS Challenges must be solved manually
+
+## Why This Error Occurred
+
+When generating a certificate, we have to prove ownership over the domain
+for the Certificate Authority (CA) that issues it. In the case of Wildcard Certificates, 
+the requested challenge consists of adding TXT DNS records so, when the domain does not 
+point to ZEIT World DNS, we cannot create the records to solve the challenge.
+
+## How to Fix It
+
+To generate a certificate solving challenges manually, you must add the given `TXT` records with
+the appropriate name to your DNS. Then, after verifying that the CA can read the records, 
+you can rerun the issuance command.
+
+In case you want to start issuing a certificate to get the records you have to add or to 
+get those records again in the console, You can run the issuance command including the
+`--challenge-only` option. This way the CLI will output the challenges information and,
+after adding those records, you can rerun the command without `--challenge-only` to finish 
+issuance.

errors/unauthorized-domain.md

@@ -0,0 +1,9 @@
+# Not authorized to access domain
+
+#### Why This Error Occurred
+
+You tried to add or update a domain's configuration, but you don't have permission to modify the domain.
+
+#### Possible Ways to Fix It
+
+If you or your team owns the domain, then you are most likely in the wrong context. Use `now switch` to select the team or user that owns the domain.

errors/v2-no-min.md

@@ -0,0 +1,17 @@
+# No minimum scale settings on Cloud v2 deployments
+
+#### Why This Error Occurred
+
+An attempt was made at scaling a Cloud v2 deployment with a `min` scale
+setting. This isn't supported yet.
+
+#### Possible Ways to Fix It
+
+Ensure your scale settings (in `now.json`, the command you're running 
+or from a previous deployment who's alias you're trying to overwrite) has
+the `min` scale setting set to `0`. You can do this by running 
+
+```
+now scale <deployment> 0 10
+```
+

errors/verification-timeout.md

@@ -0,0 +1,29 @@
+# Verification Timeout
+
+#### Why This Error Occurred
+
+After the deployment build completed and the deployment state was set to `READY`,
+instances failed to initialize properly.
+
+The CLI attempted to verify that the scale settings of your instances matched,
+but it couldn't do so within the allotted time (defaults to 2 minutes).
+
+#### Possible Ways to Fix It
+
+Instance verification is the process of ensuring that after
+your deployment is ready, we can actually run (instantiate) your code.
+
+If you configured [regions or scale](https://zeit.co/docs/features/scaling),
+we ensure the minimums and maximums are met for the regions you enabled.
+
+If you think your code is taking too long to instantiate, this can be due
+to slow boot up times. You can supply `--no-verify` to skip verification
+if you are confident your code runs properly.
+
+If your application is not listening on a HTTP port, we might be failing to 
+instantiate your deployment as well. It might not be showing any errors,
+but the deployment instance is effectively not routable and cannot be
+verified.
+
+If your instances are crashing before an HTTP port is exposed, verification
+will fail as well. Double check your logs (e.g.: by running `now logs <url>`)

lerna.json

@@ -0,0 +1,14 @@
+{
+    "npmClient": "yarn",
+    "useWorkspaces": true,
+    "packages": ["packages/*"],
+    "command": {
+      "publish": {
+        "npmClient": "npm",
+        "allowBranch": ["master", "canary"],
+        "registry": "https://registry.npmjs.org/"
+      }
+    },
+    "version": "independent"
+  }
+  

lib/agent.js

@@ -1,83 +0,0 @@
-// Native
-const { parse } = require('url')
-const http = require('http')
-const https = require('https')
-
-// Packages
-const fetch = require('node-fetch')
-
-/**
- * Returns a `fetch` version with a similar
- * API to the browser's configured with a
- * HTTP2 agent.
- *
- * It encodes `body` automatically as JSON.
- *
- * @param {String} host
- * @return {Function} fetch
- */
-
-module.exports = class Agent {
-  constructor(url, { tls = true, debug } = {}) {
-    this._url = url
-    const parsed = parse(url)
-    this._protocol = parsed.protocol
-    this._debug = debug
-    if (tls) {
-      this._initAgent()
-    }
-  }
-
-  _initAgent() {
-    const module = this._protocol === 'https:' ? https : http
-    this._agent = new module.Agent({
-      keepAlive: true,
-      keepAliveMsecs: 10000,
-      maxSockets: 8
-    }).on('error', err => this._onError(err, this._agent))
-  }
-
-  _onError(err, agent) {
-    if (this._debug) {
-      console.log(`> [debug] agent connection error ${err}\n${err.stack}`)
-    }
-    if (this._agent === agent) {
-      this._agent = null
-    }
-  }
-
-  fetch(path, opts = {}) {
-    if (!this._agent) {
-      if (this._debug) {
-        console.log('> [debug] re-initializing agent')
-      }
-      this._initAgent()
-    }
-
-    const { body } = opts
-    if (this._agent) {
-      opts.agent = this._agent
-    }
-
-    if (body && typeof body === 'object' && typeof body.pipe !== 'function') {
-      opts.headers['Content-Type'] = 'application/json'
-      opts.body = JSON.stringify(body)
-    }
-
-    if (opts.body && typeof body.pipe !== 'function') {
-      opts.headers['Content-Length'] = Buffer.byteLength(opts.body)
-    }
-
-    return fetch(this._url + path, opts)
-  }
-
-  close() {
-    if (this._debug) {
-      console.log('> [debug] closing agent')
-    }
-
-    if (this._agent) {
-      this._agent.destroy()
-    }
-  }
-}

lib/alias.js

@@ -1,872 +0,0 @@
-// Packages
-const { readFileSync } = require('fs')
-const publicSuffixList = require('psl')
-const minimist = require('minimist')
-const ms = require('ms')
-const chalk = require('chalk')
-const { write: copy } = require('clipboardy')
-
-// Ours
-const promptBool = require('../lib/utils/input/prompt-bool')
-const info = require('../lib/utils/output/info')
-const param = require('../lib/utils/output/param')
-const wait = require('../lib/utils/output/wait')
-const success = require('../lib/utils/output/success')
-const uid = require('../lib/utils/output/uid')
-const eraseLines = require('../lib/utils/output/erase-lines')
-const stamp = require('../lib/utils/output/stamp')
-const error = require('../lib/utils/output/error')
-const treatBuyError = require('../lib/utils/domains/treat-buy-error')
-const scaleInfo = require('./scale-info')
-const { DOMAIN_VERIFICATION_ERROR } = require('./errors')
-const isZeitWorld = require('./is-zeit-world')
-const resolve4 = require('./dns')
-const toHost = require('./to-host')
-const exit = require('./utils/exit')
-const Now = require('./')
-
-const argv = minimist(process.argv.slice(2), {
-  boolean: ['no-clipboard'],
-  alias: { 'no-clipboard': 'C' }
-})
-
-const isTTY = process.stdout.isTTY
-const clipboard = !argv['no-clipboard']
-const domainRegex = /^((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}$/
-
-module.exports = class Alias extends Now {
-  async ls(deployment) {
-    if (deployment) {
-      const target = await this.findDeployment(deployment)
-
-      if (!target) {
-        const err = new Error(
-          `Aliases not found by "${deployment}". Run ${chalk.dim(
-            '`now alias ls`'
-          )} to see your aliases.`
-        )
-        err.userError = true
-        throw err
-      }
-
-      return this.listAliases(target.uid)
-    }
-
-    return this.listAliases()
-  }
-
-  async rm(_alias) {
-    return this.retry(async bail => {
-      const res = await this._fetch(`/now/aliases/${_alias.uid}`, {
-        method: 'DELETE'
-      })
-
-      if (res.status === 403) {
-        return bail(new Error('Unauthorized'))
-      }
-
-      if (res.status !== 200) {
-        const err = new Error('Deletion failed. Try again later.')
-        throw err
-      }
-    })
-  }
-
-  async findDeployment(deployment) {
-    const list = await this.list()
-
-    let key
-    let val
-
-    if (/\./.test(deployment)) {
-      val = toHost(deployment)
-      key = 'url'
-    } else {
-      val = deployment
-      key = 'uid'
-    }
-
-    const depl = list.find(d => {
-      if (d[key] === val) {
-        if (this._debug) {
-          console.log(`> [debug] matched deployment ${d.uid} by ${key} ${val}`)
-        }
-
-        return true
-      }
-
-      // Match prefix
-      if (`${val}.now.sh` === d.url) {
-        if (this._debug) {
-          console.log(`> [debug] matched deployment ${d.uid} by url ${d.url}`)
-        }
-
-        return true
-      }
-
-      return false
-    })
-
-    return depl
-  }
-
-  async updatePathBasedroutes(alias, rules, domains) {
-    alias = await this.maybeSetUpDomain(alias, domains)
-    return this.upsertPathAlias(alias, rules)
-  }
-
-  async upsertPathAlias(alias, rules) {
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] /now/aliases #${attempt}`)
-      }
-
-      const rulesData = this.readRulesFile(rules)
-      const ruleCount = rulesData.rules.length
-      const res = await this._fetch(`/now/aliases`, {
-        method: 'POST',
-        body: { alias, rules: rulesData.rules }
-      })
-
-      const body = await res.json()
-      body.ruleCount = ruleCount
-      if (this._debug) {
-        console.timeEnd(`> [debug] /now/aliases #${attempt}`)
-      }
-
-      // 409 conflict is returned if it already exists
-      if (res.status === 409) {
-        return { uid: body.error.uid }
-      }
-      if (res.status === 422) {
-        return body
-      }
-
-      // No retry on authorization problems
-      if (res.status === 403) {
-        const code = body.error.code
-
-        if (code === 'custom_domain_needs_upgrade') {
-          const err = new Error(
-            `Custom domains are only enabled for premium accounts. Please upgrade by running ${chalk.gray(
-              '`'
-            )}${chalk.cyan('now upgrade')}${chalk.gray('`')}.`
-          )
-          err.userError = true
-          return bail(err)
-        }
-
-        if (code === 'alias_in_use') {
-          const err = new Error(
-            `The alias you are trying to configure (${chalk.underline(
-              chalk.bold(alias)
-            )}) is already in use by a different account.`
-          )
-          err.userError = true
-          return bail(err)
-        }
-
-        if (code === 'forbidden') {
-          const err = new Error(
-            'The domain you are trying to use as an alias is already in use by a different account.'
-          )
-          err.userError = true
-          return bail(err)
-        }
-
-        return bail(new Error('Authorization error'))
-      }
-
-      // All other errors
-      if (body.error) {
-        const code = body.error.code
-
-        if (code === 'cert_missing') {
-          console.log(
-            `> Provisioning certificate for ${chalk.underline(
-              chalk.bold(alias)
-            )}`
-          )
-
-          try {
-            await this.createCert(alias)
-          } catch (err) {
-            // We bail to avoid retrying the whole process
-            // of aliasing which would involve too many
-            // retries on certificate provisioning
-            return bail(err)
-          }
-
-          // Try again, but now having provisioned the certificate
-          return this.upsertPathAlias(alias, rules)
-        }
-
-        if (code === 'cert_expired') {
-          console.log(
-            `> Renewing certificate for ${chalk.underline(chalk.bold(alias))}`
-          )
-
-          try {
-            await this.createCert(alias, { renew: true })
-          } catch (err) {
-            return bail(err)
-          }
-        }
-
-        return bail(new Error(body.error.message))
-      }
-
-      // The two expected succesful cods are 200 and 304
-      if (res.status !== 200 && res.status !== 304) {
-        throw new Error('Unhandled error')
-      }
-
-      return body
-    })
-  }
-
-  readRulesFile(rules) {
-    try {
-      const rulesJson = readFileSync(rules, 'utf8')
-      return JSON.parse(rulesJson)
-    } catch (err) {
-      console.error(`Reading rules file ${rules} failed: ${err}`)
-    }
-  }
-
-  async set(deployment, alias, domains, currentTeam, user) {
-    alias = alias.replace(/^https:\/\//i, '')
-
-    if (alias.indexOf('.') === -1) {
-      // `.now.sh` domain is implied if just the subdomain is given
-      alias += '.now.sh'
-    }
-    const depl = await this.findDeployment(deployment)
-    if (!depl) {
-      const err = new Error(
-        `Deployment not found by "${deployment}". Run ${chalk.dim(
-          '`now ls`'
-        )} to see your deployments.`
-      )
-      err.userError = true
-      throw err
-    }
-
-    const aliasDepl = (await this.listAliases()).find(e => e.alias === alias)
-    if (aliasDepl && aliasDepl.rules) {
-      if (isTTY) {
-        try {
-          const msg =
-            `> Path alias exists with ${aliasDepl.rules.length} rule${aliasDepl
-              .rules.length > 1
-              ? 's'
-              : ''}.\n` +
-            `> Are you sure you want to update ${alias} to be a normal alias?\n`
-
-          const confirmation = await promptBool(msg, {
-            trailing: '\n'
-          })
-
-          if (!confirmation) {
-            info('Aborted')
-            return exit(1)
-          }
-        } catch (err) {
-          console.log(err)
-        }
-      } else {
-        console.log(
-          `Overwriting path alias with ${aliasDepl.rules.length} rule${aliasDepl
-            .rules.length > 1
-            ? 's'
-            : ''} to be a normal alias.`
-        )
-      }
-    }
-
-    let aliasedDeployment = null
-    let shouldScaleDown = false
-
-    if (aliasDepl && depl.scale) {
-      aliasedDeployment = await this.findDeployment(aliasDepl.deploymentId)
-      if (
-        aliasedDeployment &&
-        aliasedDeployment.scale &&
-        aliasedDeployment.scale.current >= depl.scale.current &&
-        (aliasedDeployment.scale.min > depl.scale.min ||
-          aliasedDeployment.scale.max > depl.scale.max)
-      ) {
-        shouldScaleDown = true
-        console.log(
-          `> Alias ${alias} points to ${chalk.bold(
-            aliasedDeployment.url
-          )} (${chalk.bold(aliasedDeployment.scale.current + ' instances')})`
-        )
-        // Test if we need to change the scale or just update the rules
-        console.log(
-          `> Scaling ${depl.url} to ${chalk.bold(
-            aliasedDeployment.scale.current + ' instances'
-          )} atomically`
-        )
-        if (depl.scale.current !== aliasedDeployment.scale.current) {
-          if (depl.scale.max < 1) {
-            if (this._debug) {
-              console.log(
-                'Updating max scale to 1 so that deployment may be unfrozen.'
-              )
-            }
-            await this.setScale(depl.uid, {
-              min: depl.scale.min,
-              max: Math.max(aliasedDeployment.scale.max, 1)
-            })
-          }
-          if (depl.scale.current < 1) {
-            if (this._debug) {
-              console.log(`> Deployment ${depl.url} is frozen, unfreezing...`)
-            }
-            await this.unfreeze(depl)
-            if (this._debug) {
-              console.log(
-                `> Deployment is now unfrozen, scaling it to match current instance count`
-              )
-            }
-          }
-          // Scale it to current limit
-          if (depl.scale.current !== aliasedDeployment.scale.current) {
-            if (this._debug) {
-              console.log(`> Scaling deployment to match current scale.`)
-            }
-            await this.setScale(depl.uid, {
-              min: aliasedDeployment.scale.current,
-              max: aliasedDeployment.scale.current
-            })
-          }
-          await scaleInfo(this, depl.url)
-          if (this._debug) {
-            console.log(`> Updating scaling rules for deployment.`)
-          }
-        }
-
-        await this.setScale(depl.uid, {
-          min: Math.max(aliasedDeployment.scale.min, depl.scale.min),
-          max: Math.max(aliasedDeployment.scale.max, depl.scale.max)
-        })
-      }
-    }
-
-    alias = await this.maybeSetUpDomain(alias, domains, currentTeam, user)
-
-    const aliasTime = Date.now()
-    const newAlias = await this.createAlias(depl, alias)
-    if (!newAlias) {
-      throw new Error(
-        `Unexpected error occurred while setting up alias: ${JSON.stringify(
-          newAlias
-        )}`
-      )
-    }
-    const { created, uid } = newAlias
-    if (created) {
-      const output = `${chalk.cyan(
-        '> Success!'
-      )} ${alias} now points to ${chalk.bold(depl.url)}! ${chalk.grey(
-        '[' + ms(Date.now() - aliasTime) + ']'
-      )}`
-      if (isTTY && clipboard) {
-        try {
-          await copy(depl.url)
-        } catch (err) {
-        } finally {
-          console.log(output)
-        }
-      } else {
-        console.log(output)
-      }
-    } else {
-      console.log(
-        `${chalk.cyan('> Success!')} Alias already exists ${chalk.dim(
-          `(${uid})`
-        )}.`
-      )
-    }
-    if (aliasedDeployment && shouldScaleDown) {
-      const scaleDown = Date.now()
-      await this.setScale(aliasedDeployment.uid, { min: 0, max: 1 })
-      console.log(
-        `> Scaled ${chalk.gray(
-          aliasedDeployment.url
-        )} down to 1 instance ${chalk.gray(
-          '[' + ms(Date.now() - scaleDown) + ']'
-        )}`
-      )
-    }
-  }
-
-  createAlias(depl, alias) {
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(
-          `> [debug] /now/deployments/${depl.uid}/aliases #${attempt}`
-        )
-      }
-
-      const res = await this._fetch(`/now/deployments/${depl.uid}/aliases`, {
-        method: 'POST',
-        body: { alias }
-      })
-
-      const body = await res.json()
-      if (this._debug) {
-        console.timeEnd(
-          `> [debug] /now/deployments/${depl.uid}/aliases #${attempt}`
-        )
-      }
-
-      // 409 conflict is returned if it already exists
-      if (res.status === 409) {
-        return { uid: body.error.uid }
-      }
-
-      // No retry on authorization problems
-      if (res.status === 403) {
-        const code = body.error.code
-
-        if (code === 'custom_domain_needs_upgrade') {
-          const err = new Error(
-            `Custom domains are only enabled for premium accounts. Please upgrade by running ${chalk.gray(
-              '`'
-            )}${chalk.cyan('now upgrade')}${chalk.gray('`')}.`
-          )
-          err.userError = true
-          return bail(err)
-        }
-
-        if (code === 'alias_in_use') {
-          const err = new Error(
-            `The alias you are trying to configure (${chalk.underline(
-              chalk.bold(alias)
-            )}) is already in use by a different account.`
-          )
-          err.userError = true
-          return bail(err)
-        }
-
-        if (code === 'forbidden') {
-          const err = new Error(
-            'The domain you are trying to use as an alias is already in use by a different account.'
-          )
-          err.userError = true
-          return bail(err)
-        }
-
-        return bail(new Error('Authorization error'))
-      }
-
-      // All other errors
-      if (body.error) {
-        const code = body.error.code
-
-        if (code === 'deployment_not_found') {
-          return bail(new Error('Deployment not found'))
-        }
-
-        if (code === 'cert_missing') {
-          console.log(
-            `> Provisioning certificate for ${chalk.underline(
-              chalk.bold(alias)
-            )}`
-          )
-
-          try {
-            await this.createCert(alias)
-          } catch (err) {
-            // We bail to avoid retrying the whole process
-            // of aliasing which would involve too many
-            // retries on certificate provisioning
-            return bail(err)
-          }
-
-          // Try again, but now having provisioned the certificate
-          return this.createAlias(depl, alias)
-        }
-
-        if (code === 'cert_expired') {
-          console.log(
-            `> Renewing certificate for ${chalk.underline(chalk.bold(alias))}`
-          )
-
-          try {
-            await this.createCert(alias, { renew: true })
-          } catch (err) {
-            return bail(err)
-          }
-        }
-
-        return bail(new Error(body.error.message))
-      }
-
-      // The two expected succesful cods are 200 and 304
-      if (res.status !== 200 && res.status !== 304) {
-        throw new Error('Unhandled error')
-      }
-
-      return body
-    })
-  }
-
-  async setupRecord(domain, name) {
-    await this.setupDomain(domain)
-
-    if (this._debug) {
-      console.log(`> [debug] Setting up record "${name}" for "${domain}"`)
-    }
-
-    const type = name === '' ? 'ALIAS' : 'CNAME'
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] /domains/${domain}/records #${attempt}`)
-      }
-
-      const res = await this._fetch(`/domains/${domain}/records`, {
-        method: 'POST',
-        body: { type, name: name === '' ? name : '*', value: 'alias.zeit.co' }
-      })
-
-      if (this._debug) {
-        console.timeEnd(`> [debug] /domains/${domain}/records #${attempt}`)
-      }
-
-      if (res.status === 403) {
-        return bail(new Error('Unauthorized'))
-      }
-
-      const body = await res.json()
-
-      if (res.status !== 200) {
-        throw new Error(body.error.message)
-      }
-
-      return body
-    })
-  }
-
-  async maybeSetUpDomain(alias, domains, currentTeam, user) {
-    const gracefulExit = () => {
-      this.close()
-      domains.close()
-      // eslint-disable-next-line unicorn/no-process-exit
-      process.exit()
-    }
-    // Make alias lowercase
-    alias = alias.toLowerCase()
-
-    // Trim leading and trailing dots
-    // for example: `google.com.` => `google.com`
-    alias = alias.replace(/^\.+/, '').replace(/\.+$/, '')
-    // Evaluate the alias
-    if (/\./.test(alias)) {
-      alias = toHost(alias)
-    } else {
-      if (this._debug) {
-        console.log(`> [debug] suffixing \`.now.sh\` to alias ${alias}`)
-      }
-
-      alias = `${alias}.now.sh`
-    }
-
-    if (!domainRegex.test(alias)) {
-      const err = new Error(`Invalid alias "${alias}"`)
-      err.userError = true
-      throw err
-    }
-
-    if (!/\.now\.sh$/.test(alias)) {
-      console.log(`> ${chalk.bold(chalk.underline(alias))} is a custom domain.`)
-
-      let stopSpinner = wait('Fetching domain info')
-
-      let elapsed = stamp()
-      const parsed = publicSuffixList.parse(alias)
-      const pricePromise = domains.price(parsed.domain).catch(() => {
-        // Can be safely ignored
-      })
-      const canBePurchased = await domains.status(parsed.domain)
-      const aliasParam = param(parsed.domain)
-      let price
-      let period
-
-      stopSpinner()
-
-      if (canBePurchased) {
-        try {
-          const json = await pricePromise
-          price = json.price
-          period = json.period
-        } catch (err) {
-          // Can be safely ignored
-        }
-      }
-      if (canBePurchased && price && period) {
-        const periodMsg = `${period}yr${period > 1 ? 's' : ''}`
-        info(
-          `The domain ${aliasParam} is ${chalk.italic(
-            'available'
-          )} to buy under ${chalk.bold(
-            (currentTeam && currentTeam.slug) || user.username || user.email
-          )}! ${elapsed()}`
-        )
-        const confirmation = await promptBool(
-          `Buy now for ${chalk.bold(`$${price}`)} (${periodMsg})?`
-        )
-        eraseLines(1)
-        if (!confirmation) {
-          info('Aborted')
-          gracefulExit()
-        }
-        elapsed = stamp()
-        stopSpinner = wait('Purchasing')
-        let domain
-        try {
-          domain = await domains.buy(parsed.domain)
-        } catch (err) {
-          stopSpinner()
-          treatBuyError(err)
-          gracefulExit()
-        }
-
-        stopSpinner()
-        success(`Domain purchased and created ${uid(domain.uid)} ${elapsed()}`)
-
-        stopSpinner = wait('Verifying nameservers')
-
-        let domainInfo
-
-        try {
-          domainInfo = await this.setupDomain(parsed.domain)
-        } catch (err) {
-          if (this._debug) {
-            console.log('> [debug] Error while trying to setup the domain', err)
-          }
-        }
-
-        stopSpinner()
-
-        if (!domainInfo.verified) {
-          const tld = param(`.${parsed.tld}`)
-          error(
-            'The nameservers are pending propagation. Please try again shortly'
-          )
-          info(
-            `The ${tld} servers might take some extra time to reflect changes`
-          )
-          gracefulExit()
-        }
-      }
-
-      console.log(
-        `> Verifying the DNS settings for ${chalk.bold(
-          chalk.underline(alias)
-        )} (see ${chalk.underline('https://zeit.world')} for help)`
-      )
-
-      const _domain = publicSuffixList.parse(alias).domain
-      const _domainInfo = await this.getDomain(_domain)
-      const domainInfo = _domainInfo && !_domainInfo.error
-        ? _domainInfo
-        : undefined
-      const { domain, nameservers } = domainInfo
-        ? { domain: _domain }
-        : await this.getNameservers(alias)
-      const usingZeitWorld = domainInfo
-        ? !domainInfo.isExternal
-        : isZeitWorld(nameservers)
-      let skipDNSVerification = false
-
-      if (this._debug) {
-        if (domainInfo) {
-          console.log(
-            `> [debug] Found domain ${domain} with verified:${domainInfo.verified}`
-          )
-        } else {
-          console.log(
-            `> [debug] Found domain ${domain} and nameservers ${nameservers}`
-          )
-        }
-      }
-
-      if (!usingZeitWorld && domainInfo) {
-        if (domainInfo.verified) {
-          skipDNSVerification = true
-        } else if (domainInfo.uid) {
-          const { verified, created } = await this.setupDomain(domain, {
-            isExternal: true
-          })
-          if (!(created && verified)) {
-            const e = new Error(
-              `> Failed to verify the ownership of ${domain}, please refer to 'now domain --help'.`
-            )
-            e.userError = true
-            throw e
-          }
-          console.log(
-            `${chalk.cyan('> Success!')} Domain ${chalk.bold(
-              chalk.underline(domain)
-            )} verified`
-          )
-        }
-      }
-
-      try {
-        if (!skipDNSVerification) {
-          await this.verifyOwnership(alias)
-        }
-      } catch (err) {
-        if (err.userError) {
-          // A user error would imply that verification failed
-          // in which case we attempt to correct the dns
-          // configuration (if we can!)
-          try {
-            if (usingZeitWorld) {
-              console.log(
-                `> Detected ${chalk.bold(
-                  chalk.underline('zeit.world')
-                )} nameservers! Configuring records.`
-              )
-              const record = alias.substr(0, alias.length - domain.length)
-
-              // Lean up trailing and leading dots
-              const _record = record.replace(/^\./, '').replace(/\.$/, '')
-              const _domain = domain.replace(/^\./, '').replace(/\.$/, '')
-
-              if (_record === '') {
-                await this.setupRecord(_domain, '*')
-              }
-
-              await this.setupRecord(_domain, _record)
-
-              this.recordSetup = true
-              console.log('> DNS Configured! Verifying propagation…')
-
-              try {
-                await this.retry(() => this.verifyOwnership(alias), {
-                  retries: 10,
-                  maxTimeout: 8000
-                })
-              } catch (err2) {
-                const e = new Error(
-                  '> We configured the DNS settings for your alias, but we were unable to ' +
-                    "verify that they've propagated. Please try the alias again later."
-                )
-                e.userError = true
-                throw e
-              }
-            } else {
-              console.log(
-                `> Resolved IP: ${err.ip
-                  ? `${chalk.underline(err.ip)} (unknown)`
-                  : chalk.dim('none')}`
-              )
-              console.log(
-                `> Nameservers: ${nameservers && nameservers.length
-                  ? nameservers.map(ns => chalk.underline(ns)).join(', ')
-                  : chalk.dim('none')}`
-              )
-              throw err
-            }
-          } catch (e) {
-            if (e.userError) {
-              throw e
-            }
-
-            throw err
-          }
-        } else {
-          throw err
-        }
-      }
-
-      if (!usingZeitWorld && !skipDNSVerification) {
-        if (this._debug) {
-          console.log(
-            `> [debug] Trying to register a non-ZeitWorld domain ${domain} for the current user`
-          )
-        }
-
-        const { uid, verified, created } = await this.setupDomain(domain, {
-          isExternal: true
-        })
-        if (!(created && verified)) {
-          const e = new Error(
-            `> Failed to verify the ownership of ${domain}, please refer to 'now domain --help'.`
-          )
-          e.userError = true
-          throw e
-        }
-        console.log(
-          `${chalk.cyan('> Success!')} Domain ${chalk.bold(
-            chalk.underline(domain)
-          )} ${chalk.dim(`(${uid})`)} added`
-        )
-      }
-
-      console.log(`> Verification ${chalk.bold('OK')}!`)
-    }
-    return alias
-  }
-
-  verifyOwnership(domain) {
-    return this.retry(
-      async bail => {
-        const targets = await resolve4('alias.zeit.co')
-
-        if (targets.length <= 0) {
-          return bail(new Error('Unable to resolve alias.zeit.co'))
-        }
-
-        let ips = []
-
-        try {
-          ips = await resolve4(domain)
-        } catch (err) {
-          if (
-            err.code === 'ENODATA' ||
-            err.code === 'ESERVFAIL' ||
-            err.code === 'ENOTFOUND'
-          ) {
-            // Not errors per se, just absence of records
-            if (this._debug) {
-              console.log(`> [debug] No records found for "${domain}"`)
-            }
-
-            const err = new Error(DOMAIN_VERIFICATION_ERROR)
-            err.userError = true
-            return bail(err)
-          }
-          throw err
-        }
-
-        if (ips.length <= 0) {
-          const err = new Error(DOMAIN_VERIFICATION_ERROR)
-          err.userError = true
-          return bail(err)
-        }
-
-        for (const ip of ips) {
-          if (targets.indexOf(ip) === -1) {
-            const err = new Error(
-              `The domain ${domain} has an A record ${chalk.bold(
-                ip
-              )} that doesn't resolve to ${chalk.bold(
-                chalk.underline('alias.zeit.co')
-              )}.\n> ` + DOMAIN_VERIFICATION_ERROR
-            )
-            err.ip = ip
-            err.userError = true
-            return bail(err)
-          }
-        }
-      },
-      { retries: 5 }
-    )
-  }
-}

lib/build-logger.js

@@ -1,138 +0,0 @@
-// Native
-const EventEmitter = require('events')
-
-// Packages
-const io = require('socket.io-client')
-const chalk = require('chalk')
-
-const { compare, deserialize } = require('./logs')
-
-module.exports = class Logger extends EventEmitter {
-  constructor(host, token, { debug = false, quiet = false } = {}) {
-    super()
-    this.host = host
-    this.token = token
-    this.debug = debug
-    this.quiet = quiet
-
-    // ReadyState
-    this.building = false
-
-    this.socket = io(`https://io.now.sh/states?host=${host}&v=2`)
-    this.socket.once('error', this.onSocketError.bind(this))
-    this.socket.on('auth', this.onAuth.bind(this))
-    this.socket.on('state', this.onState.bind(this))
-    this.socket.on('logs', this.onLog.bind(this))
-    this.socket.on('backend', this.onComplete.bind(this))
-
-    // Log buffer
-    this.buf = []
-    this.printed = new Set()
-  }
-
-  onAuth(callback) {
-    if (this.debug) {
-      console.log('> [debug] authenticate')
-    }
-    callback(this.token)
-  }
-
-  onState(state) {
-    // Console.log(state)
-    if (!state.id) {
-      console.error('> Deployment not found')
-      this.emit('error')
-      return
-    }
-
-    if (state.error) {
-      this.emit('error', state)
-      return
-    }
-
-    if (state.backend) {
-      this.onComplete()
-      return
-    }
-
-    if (state.logs) {
-      state.logs.forEach(this.onLog, this)
-    }
-  }
-
-  onLog(log) {
-    if (!this.building) {
-      if (!this.quiet) {
-        console.log('> Building')
-      }
-      this.building = true
-    }
-
-    if (this.quiet) {
-      return
-    }
-
-    log = deserialize(log)
-
-    const timer = setTimeout(() => {
-      this.buf.sort((a, b) => compare(a.log, b.log))
-      const idx = this.buf.findIndex(b => b.log.id === log.id) + 1
-      for (const b of this.buf.slice(0, idx)) {
-        clearTimeout(b.timer)
-        this.printLog(b.log)
-      }
-      this.buf = this.buf.slice(idx)
-    }, 500)
-
-    this.buf.push({ log, timer })
-  }
-
-  onComplete() {
-    this.socket.disconnect()
-
-    if (this.building) {
-      this.building = false
-    }
-
-    this.buf.sort((a, b) => compare(a.log, b.log))
-
-    // Flush all buffer
-    for (const b of this.buf) {
-      clearTimeout(b.timer)
-      this.printLog(b.log)
-    }
-    this.buf = []
-
-    this.emit('close')
-  }
-
-  onSocketError(err) {
-    if (this.debug) {
-      console.log(`> [debug] Socket error ${err}\n${err.stack}`)
-    }
-  }
-
-  printLog(log) {
-    if (this.printed.has(log.id)) return
-
-    this.printed.add(log.id)
-
-    const data = log.object ? JSON.stringify(log.object) : log.text
-
-    if (log.type === 'command') {
-      console.log(`${chalk.gray('>')} ▲ ${data}`)
-    } else if (log.type === 'stderr') {
-      data.split('\n').forEach(v => {
-        if (v.length > 0) {
-          console.error(chalk.gray(`> ${v}`))
-        }
-      })
-    } else if (log.type === 'stdout') {
-      data.split('\n').forEach(v => {
-        if (v.length > 0) {
-          console.log(`${chalk.gray('>')} ${v}`)
-        }
-      })
-    }
-  }
-}

lib/certs.js

@@ -1,101 +0,0 @@
-// Ours
-const Now = require('../lib')
-
-module.exports = class Certs extends Now {
-  ls() {
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} GET now/certs`)
-      }
-
-      const res = await this._fetch('/now/certs')
-
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} GET now/certs`)
-      }
-
-      const body = await res.json()
-      return body.certs
-    })
-  }
-
-  create(cn) {
-    return this.createCert(cn)
-  }
-
-  renew(cn) {
-    return this.createCert(cn, { renew: true })
-  }
-
-  put(cn, crt, key, ca) {
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} PUT now/certs`)
-      }
-
-      const res = await this._fetch('/now/certs', {
-        method: 'PUT',
-        body: {
-          domains: [cn],
-          ca,
-          cert: crt,
-          key
-        }
-      })
-
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} PUT now/certs`)
-      }
-
-      if (res.status === 403) {
-        return bail(new Error('Unauthorized'))
-      }
-
-      const body = await res.json()
-
-      if (res.status !== 200) {
-        if (res.status === 404 || res.status === 400) {
-          const err = new Error(body.error.message)
-          err.userError = true
-          return bail(err)
-        }
-
-        throw new Error(body.error.message)
-      }
-
-      return body
-    })
-  }
-
-  delete(cn) {
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} DELETE now/certs/${cn}`)
-      }
-
-      const res = await this._fetch(`/now/certs/${cn}`, { method: 'DELETE' })
-
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} DELETE now/certs/${cn}`)
-      }
-
-      if (res.status === 403) {
-        return bail(new Error('Unauthorized'))
-      }
-
-      const body = await res.json()
-
-      if (res.status !== 200) {
-        if (res.status === 404 || res.status === 400) {
-          const err = new Error(body.error.message)
-          err.userError = true
-          return bail(err)
-        }
-
-        throw new Error(body.error.message)
-      }
-
-      return body
-    })
-  }
-}

lib/cfg.js

@@ -1,112 +0,0 @@
-// Native
-const { homedir } = require('os')
-const path = require('path')
-
-// Packages
-const fs = require('fs-extra')
-const ms = require('ms')
-
-// Ours
-const { get: getUser } = require('./user')
-
-// `8h` is arbitrarily used based on the average sleep time
-const TTL = ms('8h')
-
-let file = process.env.NOW_JSON
-  ? path.resolve(process.env.NOW_JSON)
-  : path.resolve(homedir(), '.now.json')
-
-function setConfigFile(nowjson) {
-  file = path.resolve(nowjson)
-}
-
-function save(data) {
-  fs.writeFileSync(file, JSON.stringify(data, null, 2))
-}
-
-/**
- * Reads the config file
- *
- * Optionally, always queries the API to get the user info even if the
- * config file is not present
- *
- * @param  {Boolean} force [false] Queries the API even if the config
- *                                 file is not present. If `true`, `token`
- *                                 *must* be specified
- * @param  {String}  token         Will be used to autenticate in the API
-                                   if needed
- * @param  {String}  apiUrl        URL of the API to be used
- * @return {Object}
- */
-async function read({ force = false, token, apiUrl } = {}) {
-  let existing = {}
-  try {
-    existing = fs.readFileSync(file, 'utf8')
-    existing = JSON.parse(existing)
-  } catch (err) {}
-
-  // Will happen if `force`d or if `--token` is used and it's different from
-  // The one that's stored (which can be `undefined`)
-  if ((force && token) || (token && token !== existing.token)) {
-    const user = await getUser({ token, apiUrl })
-    if (user) {
-      return {
-        token,
-        user: {
-          uid: user.uid,
-          username: user.username,
-          email: user.email
-        },
-        currentTeam: existing.currentTeam
-      }
-    }
-    return {}
-  }
-
-  if (!existing.token) {
-    return {}
-  }
-
-  if (!existing.lastUpdate || Date.now() - existing.lastUpdate > TTL) {
-    // TODO: update `teams` info
-    const token = existing.token
-    const user = await getUser({ token })
-
-    if (user) {
-      existing.user = user
-      existing.lastUpdate = Date.now()
-      save(existing)
-    }
-  }
-  return existing
-}
-
-/**
- * Merges the `data` object onto the
- * JSON config stored in `.now.json`.
- *
- * (atomic)
- * @param {Object} data
- */
-async function merge(data) {
-  const cfg = Object.assign({}, await read(), data)
-  save(cfg)
-}
-
-// Removes a key from the config and store the result
-async function remove(key) {
-  const cfg = await read()
-  delete cfg[key]
-  fs.writeFileSync(file, JSON.stringify(cfg, null, 2))
-}
-
-// We need to remove the config file when running `now logout`
-const removeFile = async () => fs.remove(file)
-
-module.exports = {
-  setConfigFile,
-  read,
-  merge,
-  remove,
-  removeFile
-}

lib/credit-cards.js

@@ -1,73 +0,0 @@
-const stripe = require('stripe')('pk_live_alyEi3lN0kSwbdevK0nrGwTw')
-
-const Now = require('../lib')
-
-module.exports = class CreditCards extends Now {
-  async ls() {
-    const res = await this._fetch('/cards')
-    const body = await res.json()
-    if (res.status !== 200) {
-      const e = new Error(body.error.message)
-      e.code = body.error.code
-      throw e
-    }
-    return body
-  }
-
-  async setDefault(cardId) {
-    await this._fetch('/cards/default', {
-      method: 'PUT',
-      body: { cardId }
-    })
-    return true
-  }
-
-  async rm(cardId) {
-    await this._fetch(`/cards/${encodeURIComponent(cardId)}`, {
-      method: 'DELETE'
-    })
-    return true
-  }
-
-  /* eslint-disable camelcase */
-  add(card) {
-    return new Promise(async (resolve, reject) => {
-      const expDateParts = card.expDate.split(' / ')
-      card = {
-        name: card.name,
-        number: card.cardNumber,
-        cvc: card.ccv,
-        address_country: card.country,
-        address_zip: card.zipCode,
-        address_state: card.state,
-        address_city: card.city,
-        address_line1: card.address1
-      }
-
-      card.exp_month = expDateParts[0]
-      card.exp_year = expDateParts[1]
-
-      try {
-        const stripeToken = (await stripe.tokens.create({ card })).id
-        const res = await this._fetch('/cards', {
-          method: 'POST',
-          body: { stripeToken }
-        })
-
-        const body = await res.json()
-
-        if (body && body.id) {
-          resolve({
-            last4: body.last4
-          })
-        } else if (body.error && body.error.message) {
-          reject(new Error(body.error.message))
-        } else {
-          reject(new Error('Unknown error'))
-        }
-      } catch (err) {
-        reject(new Error(err.message || 'Unknown error'))
-      }
-    })
-  }
-}

lib/dns.js

@@ -1,15 +0,0 @@
-// Packages
-const dns = require('dns')
-
-function resolve4(host) {
-  return new Promise((resolve, reject) => {
-    return dns.resolve4(host, (err, answer) => {
-      if (err) {
-        return reject(err)
-      }
-
-      resolve(answer)
-    })
-  })
-}
-module.exports = resolve4

lib/domain-records.js

@@ -1,148 +0,0 @@
-// Ours
-const Now = require('../lib')
-
-module.exports = class DomainRecords extends Now {
-  async getRecord(id) {
-    const all = (await this.ls()).entries()
-    for (const [domain, records] of all) {
-      for (const record of records) {
-        if (record.id === id) {
-          record.domain = domain
-          return record
-        }
-      }
-    }
-    return null
-  }
-
-  async ls(dom) {
-    let domains
-
-    if (dom) {
-      domains = [dom]
-    } else {
-      const ret = await this.listDomains()
-      domains = ret
-        .filter(x => !x.isExternal)
-        .map(x => x.name)
-        .sort((a, b) => a.localeCompare(b))
-    }
-
-    const records = new Map()
-    const bodies = []
-
-    for (const domain of domains) {
-      bodies.push(
-        this.retry(async (bail, attempt) => {
-          const url = `/domains/${domain}/records`
-          if (this._debug) {
-            console.time(`> [debug] #${attempt} GET ${url}`)
-          }
-          const res = await this._fetch(url)
-          if (this._debug) {
-            console.timeEnd(`> [debug] #${attempt} GET ${url}`)
-          }
-          const body = await res.json()
-
-          if (res.status === 404 && body.code === 'not_found') {
-            return bail(new Error(body.message))
-          } else if (res.status !== 200) {
-            throw new Error(`Failed to get DNS records for domain "${domain}"`)
-          }
-
-          return body
-        })
-      )
-    }
-
-    const domainList = await Promise.all(bodies)
-
-    for (const body of domainList) {
-      const index = domainList.indexOf(body)
-
-      records.set(
-        domains[index],
-        body.records.sort((a, b) => a.slug.localeCompare(b.slug))
-      )
-    }
-
-    return records
-  }
-
-  create(domain, data) {
-    const url = `/domains/${domain}/records`
-
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} POST ${url}`)
-      }
-      const res = await this._fetch(url, {
-        method: 'POST',
-        body: data
-      })
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} POST ${url}`)
-      }
-
-      const body = await res.json()
-      if (res.status === 400) {
-        return bail(
-          new Error(body.error ? body.error.message : 'Unknown error')
-        )
-      } else if (res.status === 403) {
-        const err = new Error(`Not authorized to access the domain "${domain}"`)
-        err.userError = true
-        return bail(err)
-      } else if (res.status === 404) {
-        let err
-
-        if (body.error.code === 'not_found') {
-          err = new Error(`The domain "${domain}" was not found`)
-          err.userError = true
-          return bail(err)
-        }
-      }
-
-      if (res.status !== 200) {
-        throw new Error(body.error ? body.error.message : 'Unknown error')
-      }
-
-      return body
-    })
-  }
-
-  delete(domain, recordId) {
-    const url = `/domains/${domain}/records/${recordId}`
-
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} DELETE ${url}`)
-      }
-      const res = await this._fetch(url, { method: 'DELETE' })
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} DELETE ${url}`)
-      }
-
-      const body = await res.json()
-      if (res.status === 403) {
-        const err = new Error(`Not authorized to access domain ${domain}`)
-        err.userError = true
-        return bail(err)
-      } else if (res.status === 404) {
-        let err
-
-        if (body.error.code === 'not_found') {
-          err = new Error(body.error.message)
-          err.userError = true
-          return bail(err)
-        }
-      }
-
-      if (res.status !== 200) {
-        throw new Error(body.error ? body.error.message : 'Unkown error')
-      }
-
-      return body
-    })
-  }
-}

lib/domains.js

@@ -1,181 +0,0 @@
-// Native
-const { encode: encodeQuery } = require('querystring')
-
-// Packages
-const chalk = require('chalk')
-
-// Ours
-const Now = require('../lib')
-const isZeitWorld = require('./is-zeit-world')
-const { DNS_VERIFICATION_ERROR } = require('./errors')
-const cmd = require('./utils/output/param')
-
-const domainRegex = /^((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}$/
-
-module.exports = class Domains extends Now {
-  async ls() {
-    return this.listDomains()
-  }
-
-  async rm(name) {
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} DELETE /domains/${name}`)
-      }
-
-      const res = await this._fetch(`/domains/${name}`, { method: 'DELETE' })
-
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} DELETE /domains/${name}`)
-      }
-
-      if (res.status === 403) {
-        return bail(new Error('Unauthorized'))
-      }
-
-      if (res.status !== 200) {
-        const body = await res.json()
-        throw new Error(body.error.message)
-      }
-    })
-  }
-
-  async add(domain, skipVerification, isExternal) {
-    if (!domainRegex.test(domain)) {
-      const err = new Error(
-        `The supplied value ${chalk.bold(`"${domain}"`)} is not a valid domain.`
-      )
-      err.userError = true
-      throw err
-    }
-
-    if (skipVerification || isExternal) {
-      return this.setupDomain(domain, { isExternal })
-    }
-
-    let ns
-
-    try {
-      console.log('> Verifying nameservers…')
-      const res = await this.getNameservers(domain)
-      ns = res.nameservers
-    } catch (err) {
-      const err2 = new Error(
-        `Unable to fetch nameservers for ${chalk.underline(
-          chalk.bold(domain)
-        )}.`
-      )
-      err2.userError = true
-      throw err2
-    }
-
-    if (isZeitWorld(ns)) {
-      console.log(`> Verification ${chalk.bold('OK')}!`)
-      return this.setupDomain(domain)
-    }
-
-    if (this._debug) {
-      console.log(
-        `> [debug] Supplied domain "${domain}" has non-zeit nameservers`
-      )
-    }
-
-    const err3 = new Error(DNS_VERIFICATION_ERROR)
-    err3.userError = true
-    throw err3
-  }
-
-  async status(name) {
-    if (!name) {
-      throw new Error('`domain` is not defined')
-    }
-
-    const query = encodeQuery({ name })
-
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} GET /domains/status?${query}`)
-      }
-
-      const res = await this._fetch(`/domains/status?${query}`)
-      const json = await res.json()
-
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} GET /domains/status?${query}`)
-      }
-
-      return json.available
-    })
-  }
-
-  async price(name) {
-    if (!name) {
-      throw new Error('`domain` is not defined')
-    }
-
-    const query = encodeQuery({ name })
-
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} GET /domains/price?${query}`)
-      }
-
-      const res = await this._fetch(`/domains/price?${query}`)
-      const json = await res.json()
-
-      if (res.status === 400) {
-        const e = new Error(json.error.message)
-        e.code = json.error.code
-        return bail(e)
-      }
-
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} GET /domains/price?${query}`)
-      }
-
-      return json
-    })
-  }
-
-  async buy(name) {
-    if (!name) {
-      throw new Error('`name` is not defined')
-    }
-
-    const rawBody = { name }
-
-    if (name.startsWith('test')) {
-      rawBody.dev = true
-    }
-
-    const body = JSON.stringify(rawBody)
-
-    return this.retry(async (bail, attempt) => {
-      if (this._debug) {
-        console.time(`> [debug] #${attempt} GET /domains/buy`)
-      }
-      const res = await this._fetch(`/domains/buy`, {
-        method: 'POST',
-        body
-      })
-      const json = await res.json()
-
-      if (this._debug) {
-        console.timeEnd(`> [debug] #${attempt} GET /domains/buy`)
-      }
-
-      if ([400, 403, 500, 503].includes(res.status)) {
-        const e = new Error()
-        e.code = json.error.code
-        if (json.error.code === 'source_not_found') {
-          e.message = `No credit cards found – please run ${cmd('now cc add')}`
-        } else {
-          e.message = json.error.message
-        }
-        return bail(e)
-      }
-
-      return json
-    })
-  }
-}

lib/error.js

@@ -1,45 +0,0 @@
-// Packages
-const ms = require('ms')
-const chalk = require('chalk')
-
-const error = require('./utils/output/error')
-const info = require('./utils/output/info')
-
-function handleError(err) {
-  // Coerce Strings to Error instances
-  if (typeof err === 'string') {
-    err = new Error(err)
-  }
-
-  if (err.status === 403) {
-    error(
-      'Authentication error. Run `now -L` or `now --login` to log-in again.'
-    )
-  } else if (err.status === 429) {
-    if (err.retryAfter === 'never') {
-      error(err.message)
-    } else if (err.retryAfter === null) {
-      error('Rate limit exceeded error. Please try later.')
-    } else {
-      error(
-        'Rate limit exceeded error. Try again in ' +
-          ms(err.retryAfter * 1000, { long: true }) +
-          ', or upgrade your account by runnung ' +
-          `${chalk.gray('`')}${chalk.cyan('now upgrade')}${chalk.gray('`')}`
-      )
-    }
-  } else if (err.userError) {
-    error(err.message)
-  } else if (err.status === 500) {
-    error('Unexpected server error. Please retry.')
-  } else if (err.code === 'USER_ABORT') {
-    info('Aborted')
-  } else {
-    error(`Unexpected error. Please try later. (${err.message})`)
-  }
-}
-
-module.exports = {
-  handleError,
-  error
-}

lib/errors.js

@@ -1,30 +0,0 @@
-// Packages
-const chalk = require('chalk')
-
-const DNS_VERIFICATION_ERROR = `Please make sure that your nameservers point to ${chalk.underline(
-  'zeit.world'
-)}.
-> Examples: (full list at ${chalk.underline('https://zeit.world')})
-> ${chalk.gray('-')} ${chalk.underline('california.zeit.world')}    ${chalk.dim(
-  '173.255.215.107'
-)}
-> ${chalk.gray('-')} ${chalk.underline('newark.zeit.world')}        ${chalk.dim(
-  '173.255.231.87'
-)}
-> ${chalk.gray('-')} ${chalk.underline('london.zeit.world')}        ${chalk.dim(
-  '178.62.47.76'
-)}
-> ${chalk.gray('-')} ${chalk.underline('singapore.zeit.world')}     ${chalk.dim(
-  '119.81.97.170'
-)}`
-
-const DOMAIN_VERIFICATION_ERROR =
-  DNS_VERIFICATION_ERROR +
-  `\n> Alternatively, ensure it resolves to ${chalk.underline(
-    'alias.zeit.co'
-  )} via ${chalk.dim('CNAME')} / ${chalk.dim('ALIAS')}.`
-
-module.exports = {
-  DNS_VERIFICATION_ERROR,
-  DOMAIN_VERIFICATION_ERROR
-}

lib/get-files.js

@@ -1,384 +0,0 @@
-// Native
-const { resolve } = require('path')
-
-// Packages
-const flatten = require('arr-flatten')
-const unique = require('array-unique')
-const ignore = require('ignore')
-const _glob = require('glob')
-const { stat, readdir, readFile } = require('fs-extra')
-
-// Ours
-const IGNORED = require('./ignored')
-
-const glob = async function(pattern, options) {
-  return new Promise((resolve, reject) => {
-    _glob(pattern, options, (error, files) => {
-      if (error) {
-        reject(error)
-      } else {
-        resolve(files)
-      }
-    })
-  })
-}
-
-/**
- * Remove leading `./` from the beginning of ignores
- * because our parser doesn't like them :|
- */
-
-const clearRelative = function(str) {
-  return str.replace(/(\n|^)\.\//g, '$1')
-}
-
-/**
- * Returns the contents of a file if it exists.
- *
- * @return {String} results or `''`
- */
-
-const maybeRead = async function(path, default_ = '') {
-  try {
-    return await readFile(path, 'utf8')
-  } catch (err) {
-    return default_
-  }
-}
-
-/**
- * Transform relative paths into absolutes,
- * and maintains absolutes as such.
- *
- * @param {String} maybe relative path
- * @param {String} parent full path
- */
-
-const asAbsolute = function(path, parent) {
-  if (path[0] === '/') {
-    return path
-  }
-
-  return resolve(parent, path)
-}
-
-/**
- * Returns a list of files in the given
- * directory that are subject to be
- * synchronized for static deployments.
- *
- * @param {String} full path to directory
- * @param {Object} options:
- *  - `limit` {Number|null} byte limit
- *  - `debug` {Boolean} warn upon ignore
- * @return {Array} comprehensive list of paths to sync
- */
-
-async function staticFiles(
-  path,
-  nowConfig = {},
-  { limit = null, hasNowJson = false, debug = false } = {}
-) {
-  const whitelist = nowConfig.files
-
-  // The package.json `files` whitelist still
-  // honors ignores: https://docs.npmjs.com/files/package.json#files
-  const search_ = whitelist || ['.']
-  // Convert all filenames into absolute paths
-  const search = Array.prototype.concat.apply(
-    [],
-    await Promise.all(
-      search_.map(file => glob(file, { cwd: path, absolute: true, dot: true }))
-    )
-  )
-
-  // Compile list of ignored patterns and files
-  const gitIgnore = await maybeRead(resolve(path, '.gitignore'))
-
-  const filter = ignore()
-    .add(IGNORED + '\n' + clearRelative(gitIgnore))
-    .createFilter()
-
-  const prefixLength = path.length + 1
-
-  // The package.json `files` whitelist still
-  // honors npmignores: https://docs.npmjs.com/files/package.json#files
-  // but we don't ignore if the user is explicitly listing files
-  // under the now namespace, or using files in combination with gitignore
-  const accepts = file => {
-    const relativePath = file.substr(prefixLength)
-
-    if (relativePath === '') {
-      return true
-    }
-
-    const accepted = filter(relativePath)
-    if (!accepted && debug) {
-      console.log('> [debug] ignoring "%s"', file)
-    }
-    return accepted
-  }
-
-  // Locate files
-  if (debug) {
-    console.time(`> [debug] locating files ${path}`)
-  }
-
-  const files = await explode(search, {
-    accepts,
-    limit,
-    debug
-  })
-
-  if (debug) {
-    console.timeEnd(`> [debug] locating files ${path}`)
-  }
-
-  if (hasNowJson) {
-    files.push(asAbsolute('now.json', path))
-  }
-
-  // Get files
-  return unique(files)
-}
-
-/**
- * Returns a list of files in the given
- * directory that are subject to be
- * synchronized for npm.
- *
- * @param {String} full path to directory
- * @param {String} contents of `package.json` to avoid lookup
- * @param {Object} options:
- *  - `limit` {Number|null} byte limit
- *  - `debug` {Boolean} warn upon ignore
- * @return {Array} comprehensive list of paths to sync
- */
-
-async function npm(
-  path,
-  pkg = {},
-  nowConfig = {},
-  { limit = null, hasNowJson = false, debug = false } = {}
-) {
-  const whitelist = nowConfig.files || pkg.files
-
-  // The package.json `files` whitelist still
-  // honors ignores: https://docs.npmjs.com/files/package.json#files
-  const search_ = whitelist || ['.']
-  // Convert all filenames into absolute paths
-  const search = Array.prototype.concat.apply(
-    [],
-    await Promise.all(
-      search_.map(file => glob(file, { cwd: path, absolute: true, dot: true }))
-    )
-  )
-
-  // Compile list of ignored patterns and files
-  const npmIgnore = await maybeRead(resolve(path, '.npmignore'), null)
-  const gitIgnore = npmIgnore === null
-    ? await maybeRead(resolve(path, '.gitignore'))
-    : null
-
-  const filter = ignore()
-    .add(
-      IGNORED + '\n' + clearRelative(npmIgnore === null ? gitIgnore : npmIgnore)
-    )
-    .createFilter()
-
-  const prefixLength = path.length + 1
-
-  // The package.json `files` whitelist still
-  // honors npmignores: https://docs.npmjs.com/files/package.json#files
-  // but we don't ignore if the user is explicitly listing files
-  // under the now namespace, or using files in combination with gitignore
-  const overrideIgnores =
-    (pkg.now && pkg.now.files) || (gitIgnore !== null && pkg.files)
-  const accepts = overrideIgnores
-    ? () => true
-    : file => {
-        const relativePath = file.substr(prefixLength)
-
-        if (relativePath === '') {
-          return true
-        }
-
-        const accepted = filter(relativePath)
-        if (!accepted && debug) {
-          console.log('> [debug] ignoring "%s"', file)
-        }
-        return accepted
-      }
-
-  // Locate files
-  if (debug) {
-    console.time(`> [debug] locating files ${path}`)
-  }
-
-  const files = await explode(search, {
-    accepts,
-    limit,
-    debug
-  })
-
-  if (debug) {
-    console.timeEnd(`> [debug] locating files ${path}`)
-  }
-
-  // Always include manifest as npm does not allow ignoring it
-  // source: https://docs.npmjs.com/files/package.json#files
-  files.push(asAbsolute('package.json', path))
-
-  if (hasNowJson) {
-    files.push(asAbsolute('now.json', path))
-  }
-
-  // Get files
-  return unique(files)
-}
-
-/**
- * Returns a list of files in the given
- * directory that are subject to be
- * sent to docker as build context.
- *
- * @param {String} full path to directory
- * @param {String} contents of `Dockerfile`
- * @param {Object} options:
- *  - `limit` {Number|null} byte limit
- *  - `debug` {Boolean} warn upon ignore
- * @return {Array} comprehensive list of paths to sync
- */
-
-async function docker(
-  path,
-  nowConfig = {},
-  { limit = null, hasNowJson = false, debug = false } = {}
-) {
-  const whitelist = nowConfig.files
-
-  // Base search path
-  // the now.json `files` whitelist still
-  // honors ignores: https://docs.npmjs.com/files/package.json#files
-  const search_ = whitelist || ['.']
-
-  // Convert all filenames into absolute paths
-  const search = search_.map(file => asAbsolute(file, path))
-
-  // Compile list of ignored patterns and files
-  const dockerIgnore = await maybeRead(resolve(path, '.dockerignore'), null)
-
-  const filter = ignore()
-    .add(
-      IGNORED +
-        '\n' +
-        clearRelative(
-          dockerIgnore === null
-            ? await maybeRead(resolve(path, '.gitignore'))
-            : dockerIgnore
-        )
-    )
-    .createFilter()
-
-  const prefixLength = path.length + 1
-  const accepts = function(file) {
-    const relativePath = file.substr(prefixLength)
-
-    if (relativePath === '') {
-      return true
-    }
-
-    const accepted = filter(relativePath)
-    if (!accepted && debug) {
-      console.log('> [debug] ignoring "%s"', file)
-    }
-    return accepted
-  }
-
-  // Locate files
-  if (debug) {
-    console.time(`> [debug] locating files ${path}`)
-  }
-
-  const files = await explode(search, { accepts, limit, debug })
-
-  if (debug) {
-    console.timeEnd(`> [debug] locating files ${path}`)
-  }
-
-  // Always include manifest as npm does not allow ignoring it
-  // source: https://docs.npmjs.com/files/package.json#files
-  files.push(asAbsolute('Dockerfile', path))
-
-  if (hasNowJson) {
-    files.push(asAbsolute('now.json', path))
-  }
-
-  // Get files
-  return unique(files)
-}
-
-/**
- * Explodes directories into a full list of files.
- * Eg:
- *   in:  ['/a.js', '/b']
- *   out: ['/a.js', '/b/c.js', '/b/d.js']
- *
- * @param {Array} of {String}s representing paths
- * @param {Array} of ignored {String}s.
- * @param {Object} options:
- *  - `limit` {Number|null} byte limit
- *  - `debug` {Boolean} warn upon ignore
- * @return {Array} of {String}s of full paths
- */
-
-async function explode(paths, { accepts, debug }) {
-  const list = async file => {
-    let path = file
-    let s
-
-    if (!accepts(file)) {
-      return null
-    }
-
-    try {
-      s = await stat(path)
-    } catch (e) {
-      // In case the file comes from `files`
-      // and it wasn't specified with `.js` by the user
-      path = file + '.js'
-
-      try {
-        s = await stat(path)
-      } catch (e2) {
-        if (debug) {
-          console.log('> [debug] ignoring invalid file "%s"', file)
-        }
-        return null
-      }
-    }
-
-    if (s.isDirectory()) {
-      const all = await readdir(file)
-      /* eslint-disable no-use-before-define */
-      return many(all.map(subdir => asAbsolute(subdir, file)))
-      /* eslint-enable no-use-before-define */
-    } else if (!s.isFile()) {
-      if (debug) {
-        console.log('> [debug] ignoring special file "%s"', file)
-      }
-      return null
-    }
-
-    return path
-  }
-
-  const many = all => Promise.all(all.map(file => list(file)))
-  return flatten(await many(paths)).filter(v => v !== null)
-}
-
-module.exports = {
-  npm,
-  docker,
-  staticFiles
-}

lib/git.js

@@ -1,214 +0,0 @@
-// Native
-const path = require('path')
-const url = require('url')
-const childProcess = require('child_process')
-
-// Packages
-const fs = require('fs-extra')
-const download = require('download')
-const tmp = require('tmp-promise')
-const isURL = require('is-url')
-
-const cloneRepo = (parts, tmpDir) =>
-  new Promise((resolve, reject) => {
-    let host
-
-    switch (parts.type) {
-      case 'GitLab':
-        host = `gitlab.com`
-        break
-      case 'Bitbucket':
-        host = `bitbucket.org`
-        break
-      default:
-        host = `github.com`
-    }
-
-    const url = `https://${host}/${parts.main}`
-    const ref = parts.ref || (parts.type === 'Bitbucket' ? 'default' : 'master')
-    const cmd = `git clone ${url} --single-branch ${ref}`
-
-    childProcess.exec(cmd, { cwd: tmpDir.path }, (err, stdout) => {
-      if (err) {
-        reject(err)
-      }
-
-      resolve(stdout)
-    })
-  })
-
-const renameRepoDir = async (pathParts, tmpDir) => {
-  const tmpContents = await fs.readdir(tmpDir.path)
-
-  const oldTemp = path.join(tmpDir.path, tmpContents[0])
-  const newTemp = path.join(tmpDir.path, pathParts.main.replace('/', '-'))
-
-  await fs.rename(oldTemp, newTemp)
-  tmpDir.path = newTemp
-
-  return tmpDir
-}
-
-const capitalizePlatform = name => {
-  const names = {
-    github: 'GitHub',
-    gitlab: 'GitLab',
-    bitbucket: 'Bitbucket'
-  }
-
-  return names[name]
-}
-
-const splittedURL = fullURL => {
-  const parsedURL = url.parse(fullURL)
-  const pathParts = parsedURL.path.split('/')
-
-  pathParts.shift()
-
-  // Set path to repo...
-  const main = pathParts[0] + '/' + pathParts[1]
-
-  // ...and then remove it from the parts
-  pathParts.splice(0, 2)
-
-  // Assign Git reference
-  let ref = pathParts.length >= 2 ? pathParts[1] : ''
-
-  // Firstly be sure that we haven know the ref type
-  if (pathParts[0]) {
-    // Then shorten the SHA of the commit
-    if (pathParts[0] === 'commit' || pathParts[0] === 'commits') {
-      ref = ref.substring(0, 7)
-    }
-  }
-
-  // We're deploying master by default,
-  // so there's no need to indicate it explicitly
-  if (ref === 'master') {
-    ref = ''
-  }
-
-  return {
-    main,
-    ref,
-    type: capitalizePlatform(parsedURL.host.split('.')[0])
-  }
-}
-
-const gitPathParts = main => {
-  let ref = ''
-
-  if (isURL(main)) {
-    return splittedURL(main)
-  }
-
-  if (main.split('/')[1].includes('#')) {
-    const parts = main.split('#')
-
-    ref = parts[1]
-    main = parts[0]
-  }
-
-  return {
-    main,
-    ref,
-    type: capitalizePlatform('github')
-  }
-}
-
-const downloadRepo = async repoPath => {
-  const pathParts = gitPathParts(repoPath)
-
-  const tmpDir = await tmp.dir({
-    // We'll remove it manually once deployment is done
-    keep: true,
-    // Recursively remove directory when calling respective method
-    unsafeCleanup: true
-  })
-
-  let gitInstalled = true
-
-  try {
-    await cloneRepo(pathParts, tmpDir)
-  } catch (err) {
-    gitInstalled = false
-  }
-
-  if (gitInstalled) {
-    const renaming = await renameRepoDir(pathParts, tmpDir)
-    return renaming
-  }
-
-  let url
-
-  switch (pathParts.type) {
-    case 'GitLab': {
-      const ref = pathParts.ref ? `?ref=${pathParts.ref}` : ''
-      url = `https://gitlab.com/${pathParts.main}/repository/archive.tar` + ref
-      break
-    }
-    case 'Bitbucket':
-      url = `https://bitbucket.org/${pathParts.main}/get/${pathParts.ref ||
-        'default'}.zip`
-      break
-    default:
-      url = `https://api.github.com/repos/${pathParts.main}/tarball/${pathParts.ref}`
-  }
-
-  try {
-    await download(url, tmpDir.path, {
-      extract: true
-    })
-  } catch (err) {
-    tmpDir.cleanup()
-    return false
-  }
-
-  const renaming = await renameRepoDir(pathParts, tmpDir)
-  return renaming
-}
-
-const isRepoPath = path => {
-  if (!path) {
-    return false
-  }
-
-  const allowedHosts = ['github.com', 'gitlab.com', 'bitbucket.org']
-
-  if (isURL(path)) {
-    const urlParts = url.parse(path)
-    const slashSplitted = urlParts.path.split('/').filter(n => n)
-    const notBare = slashSplitted.length >= 2
-
-    if (allowedHosts.includes(urlParts.host) && notBare) {
-      return true
-    }
-
-    const err = new Error(`Host "${urlParts.host}" is unsupported.`)
-    err.code = 'INVALID_URL'
-    err.userError = true
-    throw err
-  }
-
-  return /[^\s\\]\/[^\s\\]/g.test(path)
-}
-
-const fromGit = async (path, debug) => {
-  let tmpDir = false
-
-  try {
-    tmpDir = await downloadRepo(path)
-  } catch (err) {
-    if (debug) {
-      console.log(`Could not download "${path}" repo from GitHub`)
-    }
-  }
-
-  return tmpDir
-}
-
-module.exports = {
-  gitPathParts,
-  isRepoPath,
-  fromGit
-}

lib/indent.js

@@ -1,5 +0,0 @@
-function indent(text, n) {
-  return text.split('\n').map(l => ' '.repeat(n) + l).join('\n')
-}
-
-module.exports = indent

lib/is-zeit-world.js

@@ -1,32 +0,0 @@
-/**
- * List of `zeit.world` nameservers
- */
-
-const nameservers = new Set([
-  'california.zeit.world',
-  'london.zeit.world',
-  'newark.zeit.world',
-  'sydney.zeit.world',
-  'iowa.zeit.world',
-  'dallas.zeit.world',
-  'amsterdam.zeit.world',
-  'paris.zeit.world',
-  'frankfurt.zeit.world',
-  'singapore.zeit.world'
-])
-
-/**
- * Given an array of nameservers (ie: as returned
- * by `resolveNs` from Node, assert that they're
- * zeit.world's.
- */
-function isZeitWorld(ns) {
-  return (
-    ns.length > 1 &&
-    ns.every(host => {
-      return nameservers.has(host)
-    })
-  )
-}
-
-module.exports = isZeitWorld

lib/login.js

@@ -1,141 +0,0 @@
-// Native
-const os = require('os')
-
-// Packages
-const { stringify: stringifyQuery } = require('querystring')
-const chalk = require('chalk')
-const fetch = require('node-fetch')
-const { validate } = require('email-validator')
-const readEmail = require('email-prompt')
-const ora = require('ora')
-
-// Ours
-const pkg = require('./pkg')
-const ua = require('./ua')
-const cfg = require('./cfg')
-
-async function getVerificationData(url, email) {
-  const tokenName = `Now CLI ${os.platform()}-${os.arch()} ${pkg.version} (${os.hostname()})`
-  const data = JSON.stringify({ email, tokenName })
-  const res = await fetch(`${url}/now/registration`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(data),
-      'User-Agent': ua
-    },
-    body: data
-  })
-
-  const body = await res.json()
-  if (res.status !== 200) {
-    throw new Error(
-      `Verification error: ${res.status} – ${JSON.stringify(body)}`
-    )
-  }
-  return body
-}
-
-async function verify(url, email, verificationToken) {
-  const query = {
-    email,
-    token: verificationToken
-  }
-
-  const res = await fetch(
-    `${url}/now/registration/verify?${stringifyQuery(query)}`,
-    {
-      headers: { 'User-Agent': ua }
-    }
-  )
-  const body = await res.json()
-  return body.token
-}
-
-function sleep(ms) {
-  return new Promise(resolve => {
-    setTimeout(resolve, ms)
-  })
-}
-
-async function register(url, { retryEmail = false } = {}) {
-  let email
-  try {
-    email = await readEmail({ invalid: retryEmail })
-  } catch (err) {
-    process.stdout.write('\n')
-    throw err
-  }
-
-  process.stdout.write('\n')
-
-  if (!validate(email)) {
-    return register(url, { retryEmail: true })
-  }
-
-  const { token, securityCode } = await getVerificationData(url, email)
-  console.log(
-    `> Please follow the link sent to ${chalk.bold(email)} to log in.`
-  )
-
-  if (securityCode) {
-    console.log(
-      `> Verify that the provided security code in the email matches ${chalk.cyan(
-        chalk.bold(securityCode)
-      )}.`
-    )
-  }
-
-  process.stdout.write('\n')
-
-  const spinner = ora({
-    text: 'Waiting for confirmation...'
-  }).start()
-
-  let final
-
-  /* eslint-disable no-await-in-loop */
-  do {
-    await sleep(2500)
-
-    try {
-      final = await verify(url, email, token)
-    } catch (err) {}
-  } while (!final)
-  /* eslint-enable no-await-in-loop */
-
-  let user
-  try {
-    user = (await (await fetch(`${url}/www/user`, {
-      headers: {
-        Authorization: `Bearer ${final}`
-      }
-    })).json()).user
-  } catch (err) {
-    spinner.stop()
-    throw new Error(`Couldn't retrieve user details ${err.message}`)
-  }
-
-  spinner.text = 'Confirmed email address!'
-  spinner.stopAndPersist('✔')
-
-  process.stdout.write('\n')
-
-  return {
-    token: final,
-    user: {
-      uid: user.uid,
-      username: user.username,
-      email: user.email
-    },
-    lastUpdate: Date.now()
-  }
-}
-
-module.exports = async function(url) {
-  const loginData = await register(url)
-  await cfg.merge(loginData)
-  await cfg.remove('currentTeam') // Make sure to logout the team too
-  await cfg.remove('email') // Remove old schema from previus versions
-  return loginData.token
-}

lib/logs.js

@@ -1,14 +0,0 @@
-exports.compare = function(a, b) {
-  return (
-    a.serial.localeCompare(b.serial) ||
-    // For the case serials are a same value on old logs
-    a.created.getTime() - b.created.getTime()
-  )
-}
-
-exports.deserialize = function(log) {
-  return Object.assign({}, log, {
-    date: new Date(log.date),
-    created: new Date(log.created)
-  })
-}

lib/pkg.js

@@ -1,13 +0,0 @@
-/* eslint-disable import/no-unresolved */
-
-const path = require('path')
-const pkg = require('../package.json')
-
-try {
-  const distDir = path.dirname(process.execPath)
-  pkg._npmPkg = require(path.join(distDir, '../../package.json'))
-} catch (err) {
-  pkg._npmPkg = null
-}
-
-module.exports = pkg

lib/plans.js

@@ -1,57 +0,0 @@
-const ms = require('ms')
-
-const Now = require('../lib')
-
-async function parsePlan(json) {
-  const { subscription } = json
-  let id
-  let until
-  let name
-
-  if (subscription) {
-    const planItems = subscription.items.data
-    const mainPlan = planItems.find(d => d.plan.metadata.is_main_plan === '1')
-
-    if (mainPlan) {
-      id = mainPlan.plan.id
-      name = mainPlan.plan.name
-      if (subscription.cancel_at_period_end) {
-        until = ms(
-          new Date(subscription.current_period_end * 1000) - new Date(),
-          { long: true }
-        )
-      }
-    } else {
-      id = 'oss'
-    }
-  } else {
-    id = 'oss'
-  }
-
-  return { id, name, until }
-}
-
-module.exports = class Plans extends Now {
-  async getCurrent() {
-    const res = await this._fetch('/plan')
-    const json = await res.json()
-    return parsePlan(json)
-  }
-
-  async set(plan) {
-    const res = await this._fetch('/plan', {
-      method: 'PUT',
-      body: { plan }
-    })
-
-    const json = await res.json()
-
-    if (res.ok) {
-      return parsePlan(json)
-    }
-
-    const err = new Error(json.error.message)
-    err.code = json.error.code
-    throw err
-  }
-}

lib/re-alias.js

@@ -1,134 +0,0 @@
-// Native
-const { join } = require('path')
-
-// Packages
-const fs = require('fs-extra')
-const chalk = require('chalk')
-
-// Ours
-const { error } = require('./error')
-const readMetaData = require('./read-metadata')
-const NowAlias = require('./alias')
-const NowDomains = require('./domains')
-
-exports.assignAlias = async (
-  autoAlias,
-  token,
-  deployment,
-  apiUrl,
-  debug,
-  currentTeam,
-  user
-) => {
-  const aliases = new NowAlias({ apiUrl, token, debug, currentTeam })
-  const domains = new NowDomains({ apiUrl, token, debug, currentTeam })
-  console.log(
-    `> Assigning alias ${chalk.bold.underline(autoAlias)} to deployment...`
-  )
-
-  // Assign alias
-  await aliases.set(
-    String(deployment),
-    String(autoAlias),
-    domains,
-    currentTeam,
-    user
-  )
-}
-
-exports.reAlias = async (
-  token,
-  host,
-  pointer,
-  help,
-  exit,
-  apiUrl,
-  debug,
-  alias,
-  currentTeam,
-  user
-) => {
-  const path = process.cwd()
-
-  const configFiles = {
-    pkg: join(path, 'package.json'),
-    nowJSON: join(path, 'now.json')
-  }
-
-  if (!fs.existsSync(configFiles.pkg) && !fs.existsSync(configFiles.nowJSON)) {
-    error(
-      `Couldn't find a now.json or package.json file with an alias list in it`
-    )
-    return
-  }
-
-  const { nowConfig, name } = await readMetaData(path, {
-    deploymentType: 'npm', // Hard coding settings…
-    quiet: true // `quiet`
-  })
-
-  if (!host) {
-    const lastAlias = await alias.last(name)
-    host = lastAlias.url
-  }
-
-  if (!nowConfig) {
-    help()
-    return exit(0)
-  }
-
-  let pointers = []
-
-  if (pointer) {
-    pointers.push(pointer)
-  } else {
-    if (nowConfig.alias) {
-      const value = nowConfig.alias
-
-      if (typeof value === 'string') {
-        pointers.push(value)
-      } else if (Array.isArray(value)) {
-        pointers = pointers.concat(nowConfig.alias)
-      } else {
-        error(
-          `Property ${chalk.grey('aliases')} is not a valid array or string`
-        )
-        return exit(1)
-      }
-    }
-
-    if (nowConfig.aliases && Array.isArray(nowConfig.aliases)) {
-      console.log(
-        `${chalk.red('Deprecated!')} The property ${chalk.grey(
-          'aliases'
-        )} will be removed from the config file soon.`
-      )
-      console.log('Read more about the new way here: http://bit.ly/2l2v5Fg\n')
-
-      pointers = pointers.concat(nowConfig.aliases)
-    }
-  }
-
-  if (pointers.length === 0) {
-    help()
-    return exit(0)
-  }
-
-  const assignments = []
-
-  for (const pointer of pointers) {
-    assignments.push(
-      exports.assignAlias(
-        pointer,
-        token,
-        host,
-        apiUrl,
-        debug,
-        currentTeam,
-        user
-      )
-    )
-  }
-
-  await Promise.all(assignments)
-}

lib/read-metadata.js

@@ -1,195 +0,0 @@
-// Native
-const { basename, resolve: resolvePath } = require('path')
-
-// Packages
-const chalk = require('chalk')
-const { readFile } = require('fs-extra')
-const { parse: parseDockerfile } = require('docker-file-parser')
-const determineType = require('deployment-type')
-
-module.exports = readMetaData
-
-async function readMetaData(
-  path,
-  {
-    deploymentType,
-    deploymentName,
-    sessionAffinity,
-    quiet = false,
-    strict = true
-  }
-) {
-  let description
-  let type = deploymentType
-  let name = deploymentName
-  let affinity = sessionAffinity
-
-  const pkg = await readJSON(path, 'package.json')
-  let nowConfig = await readJSON(path, 'now.json')
-  const dockerfile = await readDockerfile(path)
-
-  const hasNowJson = Boolean(nowConfig)
-
-  if (pkg && pkg.now) {
-    // If the project has both a `now.json` and `now` Object in the `package.json`
-    // file, then fail hard and let the user know that they need to pick one or the
-    // other
-    if (nowConfig) {
-      const err = new Error(
-        'You have a `now` configuration field inside `package.json` ' +
-          'but configuration is also present in `now.json`! ' +
-          "Please ensure there's a single source of configuration by removing one."
-      )
-      err.userError = true
-      throw err
-    } else {
-      nowConfig = pkg.now
-    }
-  }
-
-  // We can remove this once the prompt for choosing `--npm` or `--docker` is gone
-  if (pkg && pkg.now && pkg.now.type) {
-    type = nowConfig.type
-  }
-
-  // The same goes for this
-  if (nowConfig && nowConfig.type) {
-    type = nowConfig.type
-  }
-
-  if (!type) {
-    type = await determineType(path)
-
-    // Both `package.json` and `Dockerfile` exist! Prompt the user to pick one.
-    // We can remove this soon (details are internal) - also read the comment paragraph above
-    if (type === 'docker' && (pkg && dockerfile)) {
-      const err = new Error(
-        'Ambiguous deployment (`package.json` and `Dockerfile` found). ' +
-          'Please supply `--npm` or `--docker` to disambiguate.'
-      )
-
-      err.userError = true
-      err.code = 'MULTIPLE_MANIFESTS'
-
-      throw err
-    }
-  }
-
-  if (!name && nowConfig) {
-    name = nowConfig.name
-  }
-
-  if (!affinity && nowConfig) {
-    affinity = nowConfig.sessionAffinity
-  }
-
-  if (type === 'npm') {
-    if (pkg) {
-      if (!name && pkg.now && pkg.now.name) {
-        name = String(pkg.now.name)
-      }
-
-      if (!name && pkg.name) {
-        name = String(pkg.name)
-      }
-
-      description = pkg.description
-    }
-  } else if (type === 'docker') {
-    if (strict && dockerfile.length <= 0) {
-      const err = new Error('No commands found in `Dockerfile`')
-      err.userError = true
-
-      throw err
-    }
-
-    const labels = {}
-
-    dockerfile.filter(cmd => cmd.name === 'LABEL').forEach(({ args }) => {
-      for (const key in args) {
-        if (!{}.hasOwnProperty.call(args, key)) {
-          continue
-        }
-
-        // Unescape and convert into string
-        try {
-          labels[key] = args[key]
-        } catch (err) {
-          const e = new Error(
-            `Error parsing value for LABEL ${key} in \`Dockerfile\``
-          )
-
-          e.userError = true
-          throw e
-        }
-      }
-    })
-
-    if (!name) {
-      name = labels.name
-    }
-
-    description = labels.description
-  } else if (type === 'static') {
-    // Do nothing
-  } else {
-    throw new TypeError(`Unsupported "deploymentType": ${type}`)
-  }
-
-  // No name in `package.json` / `now.json`, or "name" label in Dockerfile.
-  // Default to the basename of the root dir
-  if (!name) {
-    name = basename(path)
-
-    if (!quiet && type !== 'static') {
-      if (type === 'docker') {
-        console.log(
-          `> No \`name\` LABEL in \`Dockerfile\`, using ${chalk.bold(name)}`
-        )
-      } else {
-        console.log(
-          `> No \`name\` in \`package.json\`, using ${chalk.bold(name)}`
-        )
-      }
-    }
-  }
-
-  return {
-    name,
-    description,
-    type,
-    pkg,
-    nowConfig,
-    hasNowJson,
-
-    // XXX: legacy
-    deploymentType: type,
-    sessionAffinity: affinity
-  }
-}
-
-async function readJSON(path, name) {
-  try {
-    const contents = await readFile(resolvePath(path, name), 'utf8')
-    return JSON.parse(contents)
-  } catch (err) {
-    // If the file doesn't exist then that's fine; any other error bubbles up
-    if (err.code !== 'ENOENT') {
-      err.userError = true
-      throw err
-    }
-  }
-}
-
-async function readDockerfile(path, name = 'Dockerfile') {
-  try {
-    const contents = await readFile(resolvePath(path, name), 'utf8')
-    return parseDockerfile(contents, { includeComments: true })
-  } catch (err) {
-    // If the file doesn't exist then that's fine; any other error bubbles up
-    if (err.code !== 'ENOENT') {
-      err.userError = true
-      throw err
-    }
-  }
-}