Publish

- gatsby-plugin-now@1.2.2
 - @now/build-utils@0.10.1
 - now@16.3.0
 - now-client@5.1.4
 - @now/go@0.6.0
 - @now/next@1.0.2
 - @now/node@1.0.1
 - @now/python@0.3.0
 - @now/ruby@0.1.7
 - @now/static-build@0.10.0

.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

@@ -1,12 +1,64 @@
 {
-  "extends": "standard",
-  "parser": "babel-eslint",
+  "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": {
-    "yoda": 0,
-    "arrow-parens": 0,
-    "semi": [2, "always"],
-    "no-extra-semi": 2,
-    "semi-spacing": [2, { "before": false, "after": true }],
-    "no-shadow": [2, {"builtinGlobals": true, "hoist": "functions"}]
-  }
+    "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,3 +1,20 @@
 node_modules
-build
+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,17 @@
+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"
+body = "pull_request_body"
+include_pr_number = true
+body_type = "markdown"

.prettierrc

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

.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$/, '')
+```

History.md

@@ -1,58 +0,0 @@
-
-0.9.8 / 2016-03-12
-==================
-
-  * cap maximum concurrent uploads due to HTTP/2 streams limit [@rauchg]
-  * make login resolve token [@rase-]
-
-0.9.7 / 2016-03-10
-==================
-
-  * Add `-F, --forceSync` flag [@rauchg]
-
-0.9.6 / 2016-03-04
-==================
-
-  * send files as buffers [@rase-]
-  * simplify cfg reading / merging [@rauchg]
-  * ignored: ignore `.dockerignore` [@rauchg]
-  * add auto updater with support for timeout, exit handler [@rauchg]
-  * package: bump `gulp-eslint` to work with latest eslint [@rauchg]
-  * fix eslint [@rauchg]
-
-0.9.5 / 2016-03-04
-==================
-
-  * login: fix usage of `Object.assign` [@rauchg]
-  * post-install: improve error handling [@rauchg]
-  * post-install: make runnable as script [@rauchg]
-  * package: use `build/scripts` for postinstall [@rauchg]
-  * index: fallback to directory name [@rauchg]
-  * index: send `package.json` metadata like `name` [@rauchg]
-
-0.9.4 / 2016-03-03
-==================
-
-  * login: extend configuration instead of overwriting it [@rauchg]
-
-0.9.3 / 2016-03-03
-==================
-
-  * more debug information [@rauchg]
-
-0.9.2 / 2016-03-03
-==================
-
-  * update ignores list [@rauchg]
-
-0.9.1 / 2016-03-03
-==================
-
-  * index: throw error if `start` is not defined. [@rauchg]
-  * now: revert usage of `now` [@rauchg]
-  * package: simplify `files` [@rauchg]
-
-0.9.0 / 2016-03-03
-==================
-
-  * initial release

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.

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://badgen.net/circleci/github/zeit/now/master)](https://circleci.com/gh/zeit/workflows/now/tree/master)
+[![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).

Readme.md

@@ -1,45 +0,0 @@
-# now
-
-The fastest way to deploy a Node.JS service.
-
-## How it works
-
-In any directory with a `package.json`, run:
-
-```bash
-$ now
-> https://some-code-nd23n2.now.sh
-```
-
-every time you run it, you get a new URL (unless nothing's changed).
-
-### Conventions
-
-1. `package.json` must contain a `start` task inside `scripts`.
-   If a `now` script is defined, that's used instead.
-2. Only files that would be included in `npm publish` are synchronized.
-   `package.json` `files` field, `.npmignore` and `.gitignore` are supported.
-3. If a build step is needed, specify a `build` task in `scripts`.
-   If `now-build` is defined, that's used instead.
-
-## Installing
-
-```bash
-$ npm install -g now
-> Enter your email: rauchg@gmail.com.
-> We sent an email. Click to log in.
-```
-
-## Features
-
-- **Slim**. No reliance on Git.
-- **Fast**. Blazing fast sync with deduping.
-- **Standard**. Respects npm and Node.JS conventions.
-- **Easy**. No need to specify ports, `Dockerfile` or config.
-
-## Options
-
-```
--d  Debug mode. Lists all files to be uploaded.
--f  Force. Creates a new URL even if nothing has changed.
-```

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/now

@@ -1,151 +0,0 @@
-#!/usr/bin/env node
-import program from 'commander';
-import Progress from 'progress';
-import copy from '../lib/copy';
-import * as cfg from '../lib/cfg';
-import { resolve } from 'path';
-import login from '../lib/login';
-import checkUpdate from '../lib/check-update';
-import bytes from 'bytes';
-import chalk from 'chalk';
-import Now from '../lib';
-import ms from 'ms';
-
-program
-.usage('[options]')
-.option('-d, --debug', 'Debug mode [off]', false)
-.option('-f, --force', 'Force a new deployment even if nothing has changed', false)
-.option('-F, --forceSync', 'Force a new deployment even if nothing has changed and force syncing of all files', false)
-.option('-L, --login', 'Configure login')
-.option('-C, --no-clipboard', 'Do not attempt to copy URL to clipboard')
-.parse(process.argv);
-
-let path = program.args[program.args.length - 1];
-
-if (path) {
-  if ('/' !== path[0]) {
-    path = resolve(process.cwd(), path);
-  }
-} else {
-  path = process.cwd();
-}
-
-const debug = !!program.debug;
-const clipboard = !program.noClipboard;
-const config = cfg.read();
-const update = checkUpdate({ debug });
-const exit = (code) => {
-  update.then(() => process.exit(code));
-  // don't wait for updates more than a second
-  // when the process really wants to exit
-  setTimeout(() => process.exit(code), 1000);
-};
-
-if (!config.token || program.login) {
-  login()
-  .then((token) => {
-    if (program.login) {
-      console.log('> Logged in successfully. Token saved in ~/.now.json');
-      exit(0);
-    } else {
-      sync(token).catch((err) => {
-        error(`Unknown error: ${err.stack}`);
-        exit(1);
-      });
-    }
-  })
-  .catch((e) => {
-    error(`Authentication error – ${e.message}`);
-    exit(1);
-  });
-} else {
-  sync(config.token).catch((err) => {
-    error(`Unknown error: ${err.stack}`);
-    exit(1);
-  });
-}
-
-async function sync (token) {
-  const start = Date.now();
-
-  console.log(`> Deploying "${path}"`);
-
-  const now = new Now(token, { debug });
-
-  try {
-    await now.create(path, { forceNew: program.force, forceSync: program.forceSync });
-  } catch (err) {
-    handleError(err);
-    return;
-  }
-
-  const { url } = now;
-  const elapsed = ms(new Date() - start);
-
-  if (clipboard) {
-    try {
-      await copy(url);
-      console.log(`> ${chalk.cyan('Ready!')} ${chalk.bold(`https://${url}`)} (copied to clipboard) [${elapsed}]`);
-    } catch (err) {
-      console.log(`> ${chalk.cyan('Ready!')} ${chalk.bold(`https://${url}`)} [${elapsed}]`);
-    }
-  } else {
-    console.log(`> ${url} [${elapsed}]`);
-  }
-
-  const start_u = new Date();
-  const complete = () => {
-    const elapsed_u = ms(new Date() - start_u);
-    console.log(`> Sync complete (${bytes(now.syncAmount)}) [${elapsed_u}] `);
-    now.close();
-    exit(0);
-  };
-
-  if (now.syncAmount) {
-    const bar = new Progress('> Upload [:bar] :percent :etas', {
-      width: 20,
-      complete: '=',
-      incomplete: '',
-      total: now.syncAmount
-    });
-
-    now.upload();
-
-    now.on('upload', ({ name, data }) => {
-      const amount = data.length;
-      if (debug) {
-        console.log(`> [debug] Uploaded: ${name} (${bytes(data.length)})`);
-      }
-      bar.tick(amount);
-    });
-
-    now.on('complete', complete);
-
-    now.on('error', (err) => {
-      error('Upload failed');
-      handleError(err);
-      exit(1);
-    });
-  } else {
-    console.log('> Sync complete (cached)');
-    now.close();
-    exit(0);
-  }
-}
-
-function handleError (err) {
-  if (403 === err.status) {
-    error('Authentication error. Run `now -L` or `now --login` to log-in again.');
-  } else if (err.userError) {
-    error(err.message);
-  } else if (500 === err.status) {
-    error('Unexpected server error. Please retry.');
-  } else {
-    error(`Unexpected error. Please try later. (${err.message})`);
-  }
-  exit(1);
-}
-
-function error (err) {
-  console.error(`> \u001b[31mError!\u001b[39m ${err}`);
-}

changelog.js

@@ -0,0 +1,18 @@
+const { execSync } = require('child_process');
+
+const commit = execSync('git log --pretty=format:"%s %H"')
+  .toString()
+  .trim()
+  .split('\n')
+  .find(line => line.startsWith('Publish '))
+  .split(' ')
+  .pop();
+
+if (!commit) {
+  throw new Error('Unable to find last publish commit');
+}
+
+const log = execSync(`git log --pretty=format:"- %s [%an]" ${commit}...HEAD`).toString().trim();
+
+console.log(`Changes since the last publish commit ${commit}:`);
+console.log(`\n${log}\n`);

diff.js

@@ -0,0 +1,36 @@
+const { execSync } = require('child_process');
+const { join } = require('path');
+const { tmpdir } = require('os');
+const { mkdirSync, writeFileSync } = require('fs');
+
+function getCommits(count) {
+  return execSync('git log --pretty=format:"%s [%an]"')
+    .toString()
+    .trim()
+    .split('\n')
+    .slice(0, count)
+    .filter(line => !line.startsWith('Publish '))
+    .join('\n');
+}
+
+function main(count = '100') {
+  console.log(`Generating diff using last ${count} commits...`);
+  const randomTmpId = Math.random().toString().slice(2);
+  const dir = join(tmpdir(), 'now-diff' + randomTmpId);
+  mkdirSync(dir);
+
+  execSync('git checkout canary && git pull');
+  const canary = getCommits(count);
+  execSync('git checkout master && git pull');
+  const master = getCommits(count);
+
+  writeFileSync(join(dir, 'log.txt'), '# canary\n' + canary);
+  execSync('git init && git add -A && git commit -m "init"', { cwd: dir });
+  writeFileSync(join(dir, 'log.txt'), '# master\n' + master);
+
+  console.log(`Done generating diff. Run the following:`);
+  console.log(`cd ${dir}`);
+  console.log('Then use `git diff` or `git difftool` to view the differences.');
+}
+
+main(process.argv[2]);

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>`)

gulpfile.js

@@ -1,75 +0,0 @@
-const gulp = require('gulp');
-const del = require('del');
-const ext = require('gulp-ext');
-const babel = require('gulp-babel');
-const eslint = require('gulp-eslint');
-const uglify = require('gulp-uglify');
-const help = require('gulp-task-listing');
-
-gulp.task('help', help);
-
-gulp.task('compile', [
-  'compile-lib',
-  'compile-bin',
-  'compile-scripts'
-]);
-
-gulp.task('compile-lib', function () {
-  return gulp.src('lib/**/*.js')
-  .pipe(babel({
-    presets: ['es2015'],
-    plugins: [
-      'syntax-async-functions',
-      'transform-async-to-generator',
-      'transform-runtime'
-    ]
-  }))
-  .pipe(uglify())
-  .pipe(gulp.dest('build/lib'));
-});
-
-gulp.task('compile-bin', function () {
-  return gulp.src('bin/*')
-  .pipe(babel({
-    presets: ['es2015'],
-    plugins: [
-      'syntax-async-functions',
-      'transform-async-to-generator',
-      'transform-runtime'
-    ]
-  }))
-  .pipe(uglify())
-  .pipe(ext.crop())
-  .pipe(gulp.dest('build/bin'));
-});
-
-gulp.task('compile-scripts', function () {
-  return gulp.src('scripts/*')
-  .pipe(babel({
-    presets: ['es2015'],
-    plugins: [
-      'syntax-async-functions',
-      'transform-async-to-generator',
-      'transform-runtime'
-    ]
-  }))
-  .pipe(ext.crop())
-  .pipe(gulp.dest('build/scripts'));
-});
-
-gulp.task('lint', function () {
-  return gulp.src([
-    'gulpfile.js',
-    'lib/**/*.js',
-    'bin/*'
-  ])
-  .pipe(eslint())
-  .pipe(eslint.format())
-  .pipe(eslint.failAfterError());
-});
-
-gulp.task('clean', function () {
-  return del(['build']);
-});
-
-gulp.task('default', ['lint', 'compile']);

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,63 +0,0 @@
-import http2 from 'spdy';
-import fetch from '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
- */
-
-export default class Agent {
-  constructor (host, { debug } = {}) {
-    this._host = host;
-    this._debug = debug;
-    this._initAgent();
-  }
-
-  _initAgent () {
-    this._agent = http2.createAgent({
-      host: this._host,
-      port: 443
-    }).once('error', (err) => this._onError(err));
-  }
-
-  _onError (err) {
-    // XXX: should we `this.emit()`?
-    if (this._debug) {
-      console.log('> [debug] agent connection error', err.stack);
-    }
-    this._error = err;
-  }
-
-  fetch (path, opts = {}) {
-    if (this._error) {
-      if (this._debug) console.log('> [debug] re-initializing agent after error');
-      this._error = null;
-      this._initAgent();
-    }
-
-    const { body } = opts;
-    opts.agent = this._agent;
-
-    if (body && 'object' === typeof body && 'function' !== typeof body.pipe) {
-      opts.headers['Content-Type'] = 'application/json';
-      opts.body = JSON.stringify(body);
-    }
-
-    if (null != opts.body && 'function' !== typeof body.pipe) {
-      opts.headers['Content-Length'] = Buffer.byteLength(opts.body);
-    }
-
-    return fetch(`https://${this._host}${path}`, opts);
-  }
-
-  close () {
-    if (this._debug) console.log('> [debug] closing agent');
-    return this._agent.close();
-  }
-}

lib/cfg.js

@@ -1,27 +0,0 @@
-import path from 'path';
-import fs from 'fs-promise';
-import { homedir } from 'os';
-
-const file = path.resolve(homedir(), '.now.json');
-
-export function read () {
-  let existing = null;
-  try {
-    existing = fs.readFileSync(file, 'utf8');
-    existing = JSON.parse(existing);
-  } catch (err) {}
-  return existing || {};
-}
-
-/**
- * Merges the `data` object onto the
- * JSON config stored in `.now.json`.
- *
- * (atomic)
- * @param {Object} data
- */
-
-export function merge (data) {
-  const cfg = Object.assign({}, read(), data);
-  fs.writeFileSync(file, JSON.stringify(cfg, null, 2));
-}

lib/check-update.js

@@ -1,68 +0,0 @@
-import ms from 'ms';
-import pkg from '../../package'; // relative to `build/` :\
-import fetch from 'node-fetch';
-import chalk from 'chalk';
-
-/**
- * Configures auto updates.
- * Sets up a `exit` listener to report them.
- */
-
-export default function checkUpdate (opts = {}) {
-  let updateData;
-
-  const update = check(opts).then((data) => {
-    updateData = data;
-
-    // forces the `exit` event upon Ctrl + C
-    process.on('SIGINT', () => {
-      // clean up output after ^C
-      process.stdout.write('\n');
-      process.exit(1);
-    });
-  }, (err) => console.error(err.stack));
-
-  process.on('exit', (code) => {
-    if (updateData) {
-      const { current, latest, at } = updateData;
-      const ago = ms(Date.now() - at);
-      console.log(`> ${chalk.white.bgRed('UPDATE NEEDED')} ` +
-        `Current: ${current} – ` +
-        `Latest ${chalk.bold(latest)} (released ${ago} ago)`);
-      console.log('> Run `npm install -g now` to update');
-    }
-  });
-
-  return update;
-}
-
-function check ({ debug = false }) {
-  return new Promise((resolve, reject) => {
-    if (debug) console.log('> [debug] Checking for updates.');
-
-    fetch('https://registry.npmjs.org/now').then((res) => {
-      if (200 !== res.status) {
-        if (debug) console.log(`> [debug] Update check error. NPM ${res.status}.`);
-        resolve(false);
-        return;
-      }
-
-      res.json().then((data) => {
-        const { latest } = data['dist-tags'];
-        const current = pkg.version;
-
-        if (latest !== pkg.version) {
-          if (debug) console.log(`> [debug] Needs update. Current ${current}, latest ${latest}`);
-          resolve({
-            latest,
-            current,
-            at: new Date(data.time[latest])
-          });
-        } else {
-          if (debug) console.log(`> [debug] Up to date (${pkg.version}).`);
-          resolve(false);
-        }
-      }, () => resolve(false));
-    }, () => resolve(false));
-  });
-}

lib/copy.js

@@ -1,10 +0,0 @@
-import { copy as _copy } from 'copy-paste';
-
-export default function copy (text) {
-  return new Promise((resolve, reject) => {
-    _copy(text, (err) => {
-      if (err) return reject(err);
-      resolve();
-    });
-  });
-}

lib/get-files.js

@@ -1,166 +0,0 @@
-import bytes from 'bytes';
-import flatten from 'arr-flatten';
-import unique from 'array-unique';
-import minimatch from 'minimatch';
-import IGNORED from './ignored';
-import { resolve } from 'path';
-import { stat, readdir, readFile } from 'fs-promise';
-
-/**
- * Returns a list of files in the given
- * directory that are subject to be
- * synchronized.
- *
- * @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
- */
-
-export default async function getFiles (path, pkg, { limit = null, debug = false }) {
-  if (!pkg) {
-    const pkgPath = resolve(path, 'package.json');
-    const pkgData = await readFile(pkgPath, 'utf8');
-    pkg = JSON.parse(pkgData);
-  }
-
-  let search = (pkg.files || ['.']).concat('package.json');
-  if (pkg.main) search = search.concat(pkg.main);
-  search = search.map((file) => asAbsolute(file, path));
-
-  // compile list of ignored patterns and files
-  const npmIgnore = await maybeRead(resolve(path, '.npmignore'));
-  const gitIgnore = npmIgnore
-    ? ''
-    : (await maybeRead(resolve(path, '.gitignore')));
-  const ignored = unique(IGNORED
-  .concat(gitIgnore.split('\n').filter(invalidFilter))
-  .concat(npmIgnore.split('\n').filter(invalidFilter)))
-  .map((file) => resolve(path, file));
-
-  // get files
-  return unique((await explode(search, ignored, { limit, debug })));
-}
-
-/**
- * Returns a filter function that
- * excludes ignored files in the path.
- *
- * @param {String} path
- * @return {Function} filter fn
- */
-
-const isIgnored = (file, ignored) => {
-  return ignored.some((test) => {
-    // test that the target file is not under
-    // an ignored directory
-    const dir = test + '/';
-    if (file.substr(0, dir.length) === dir) return true;
-
-    // if not match wildcards
-    return minimatch(file, test);
-  });
-};
-
-/**
- * Returns a filter function that
- * excludes invalid rules for .*ignore files
- *
- * @param {String} path
- * @return {Function} filter fn
- */
-
-const invalidFilter = (path) => {
-  return !(
-    /* commments */
-    '#' === path[0] ||
-
-    /* empty lines or newlines */
-    !path.trim().length
-  );
-};
-
-/**
- * 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);
-};
-
-/**
- * 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
- */
-
-const explode = async function (paths, ignored, { limit, debug }) {
-  const many = async (all) => {
-    return await Promise.all(all.map(async (file) => {
-      return await list(file);
-    }));
-  };
-
-  const list = async (file) => {
-    let path = file;
-    let s;
-
-    try {
-      s = await stat(path);
-    } catch (e) {
-      // in case the file comes from `files` or `main`
-      // and it wasn't specified with `.js` by the user
-      path = file + '.js';
-      s = await stat(path);
-    }
-
-    if (isIgnored(file, ignored)) {
-      if (debug) console.log(`> [debug] Ignoring "${file}"`);
-      return null;
-    }
-
-    if (s.isDirectory()) {
-      const all = await readdir(file);
-      return many(all.map(subdir => asAbsolute(subdir, file)));
-    } else {
-      if (null != limit && s.size > limit) {
-        console.error('> \u001b[31mWarning!\u001b[39m Skipping file ' +
-          `over ${bytes(limit)}: ${path}`);
-        return null;
-      }
-
-      return path;
-    }
-  };
-
-  return flatten((await many(paths))).filter((v) => null != v);
-};
-
-/**
- * Returns the contents of a file if it exists.
- *
- * @return {String} results or `''`
- */
-
-const maybeRead = async function (path) {
-  try {
-    return (await readFile(path, 'utf8'));
-  } catch (e) {
-    return '';
-  }
-};

lib/hash.js

@@ -1,30 +0,0 @@
-import { createHash } from 'crypto';
-import { readFile } from 'fs-promise';
-
-/**
- * Computes hashes for the contents of each file given.
- *
- * @param {Array} of {String} full paths
- * @return {Map}
- */
-
-export default async function hashes (files) {
-  const entries = await Promise.all(files.map(async (name) => {
-    const data = await readFile(name);
-    return [hash(data), { name, data }];
-  }));
-  return new Map(entries);
-}
-
-/**
- * Computes a hash for the given buf.
- *
- * @param {Buffer} file data
- * @return {String} hex digest
- */
-
-function hash (buf) {
-  return createHash('sha1')
-    .update(buf)
-    .digest('hex');
-}

lib/ignored.js

@@ -1,27 +0,0 @@
-export default [
-  '._*',
-  '.hg',
-  '.git',
-  '.svn',
-  '.next',
-  '.dockerignore',
-  '.gitignore',
-  '.npmrc',
-  '.*.swp',
-  '.DS_Store',
-  '.wafpickle-*',
-  '.lock-wscript',
-  'npm-debug.log',
-  'config.gypi',
-  'node_modules',
-  'CVS',
-  'README',
-  'README.*',
-  'CHANGELOG',
-  'History.md',
-  'LICENSE',
-  'Readme',
-  'Readme.*',
-  'test',
-  'tests'
-];

lib/index.js

@@ -1,193 +0,0 @@
-import getFiles from './get-files';
-import hash from './hash';
-import retry from './retry';
-import bytes from 'bytes';
-import Agent from './agent';
-import EventEmitter from 'events';
-import { basename, resolve } from 'path';
-import { stat, readFile } from 'fs-promise';
-import resumer from 'resumer';
-import splitArray from 'split-array';
-
-// limit of size of files to find
-const ONEMB = bytes('1mb');
-
-// how many concurrent HTTP/2 stream uploads
-const MAX_CONCURRENT = 10;
-
-export default class Now extends EventEmitter {
-  constructor (token, { forceNew = false, debug = false }) {
-    super();
-    this._token = token;
-    this._debug = debug;
-    this._forceNew = forceNew;
-    this._agent = new Agent('api.now.sh', { debug });
-    this._onRetry = this._onRetry.bind(this);
-  }
-
-  async create (path, { forceNew, forceSync }) {
-    this._path = path;
-
-    try {
-      await stat(path);
-    } catch (err) {
-      throw new Error(`Could not read directory ${path}.`);
-    }
-
-    let pkg;
-    try {
-      pkg = await readFile(resolve(path, 'package.json'));
-      pkg = JSON.parse(pkg);
-    } catch (err) {
-      const e = Error(`Failed to read JSON in "${path}/package.json"`);
-      e.userError = true;
-      throw e;
-    }
-
-    if (!pkg.scripts || !pkg.scripts.start) {
-      const e = Error('Missing `start` script in `package.json`. ' +
-        'See: https://docs.npmjs.com/cli/start.');
-      e.userError = true;
-      throw e;
-    }
-
-    if (this._debug) console.time('> [debug] Getting files');
-    const files = await getFiles(path, pkg, { limit: ONEMB, debug: this._debug });
-    if (this._debug) console.timeEnd('> [debug] Getting files');
-
-    if (this._debug) console.time('> [debug] Computing hashes');
-    const hashes = await hash(files);
-    if (this._debug) console.timeEnd('> [debug] Computing hashes');
-
-    this._files = hashes;
-
-    const deployment = await retry(async (bail) => {
-      if (this._debug) console.time('> [debug] /create');
-      const res = await this._fetch('/create', {
-        method: 'POST',
-        body: {
-          forceNew,
-          forceSync,
-          name: pkg.name || basename(path),
-          description: pkg.description,
-          files: Array.from(this._files).map(([sha, { data, name }]) => {
-            return {
-              sha,
-              size: data.length,
-              file: toRelative(name, this._path)
-            };
-          })
-        }
-      });
-      if (this._debug) console.timeEnd('> [debug] /create');
-
-      // no retry on 403
-      if (403 === res.status) {
-        if (this._debug) {
-          console.log('> [debug] bailing on creating due to 403');
-        }
-        return bail(responseError(res));
-      }
-
-      if (200 !== res.status) {
-        throw new Error('Deployment initialization failed');
-      }
-
-      return res.json();
-    }, { retries: 3, minTimeout: 2500, onRetry: this._onRetry });
-
-    this._id = deployment.deploymentId;
-    this._url = deployment.url;
-    this._missing = deployment.missing || [];
-
-    return this._url;
-  }
-
-  upload () {
-    const parts = splitArray(this._missing, MAX_CONCURRENT);
-
-    if (this._debug) {
-      console.log('> [debug] Will upload ' +
-        `${this._missing.length} files in ${parts.length} ` +
-        `steps of ${MAX_CONCURRENT} uploads.`);
-    }
-
-    const uploadChunk = () => {
-      Promise.all(parts.shift().map((sha) => retry(async (bail) => {
-        const file = this._files.get(sha);
-        const { data, name } = file;
-
-        if (this._debug) console.time(`> [debug] /sync ${name}`);
-
-        const stream = resumer().queue(data).end();
-        const res = await this._fetch('/sync', {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/octet-stream',
-            'Content-Length': data.length,
-            'x-now-deployment-id': this._id,
-            'x-now-sha': sha,
-            'x-now-file': toRelative(name, this._path),
-            'x-now-size': data.length
-          },
-          body: stream
-        });
-        if (this._debug) console.timeEnd(`> [debug] /sync ${name}`);
-
-        // no retry on 403
-        if (403 === res.status) {
-          if (this._debug) console.log('> [debug] bailing on creating due to 403');
-          return bail(responseError(res));
-        }
-
-        this.emit('upload', file);
-      }, { retries: 5, randomize: true, onRetry: this._onRetry })))
-      .then(() => parts.length ? uploadChunk() : this.emit('complete'))
-      .catch((err) => this.emit('error', err));
-    };
-
-    uploadChunk();
-  }
-
-  _onRetry (err) {
-    if (this._debug) {
-      console.log(`> [debug] Retrying: ${err.stack}`);
-    }
-  }
-
-  close () {
-    this._agent.close();
-  }
-
-  get url () {
-    return this._url;
-  }
-
-  get syncAmount () {
-    if (!this._syncAmount) {
-      this._syncAmount = this._missing
-      .map((sha) => this._files.get(sha).data.length)
-      .reduce((a, b) => a + b, 0);
-    }
-    return this._syncAmount;
-  }
-
-  async _fetch (url, opts) {
-    opts.headers = opts.headers || {};
-    opts.headers.authorization = `Bearer ${this._token}`;
-    return await this._agent.fetch(url, opts);
-  }
-}
-
-function toRelative (path, base) {
-  const fullBase = /\/$/.test(base) ? base + '/' : base;
-  const relative = path.substr(fullBase.length);
-  if (relative.startsWith('/')) return relative.substr(1);
-  return relative;
-}
-
-function responseError (res) {
-  const err = new Error('Response error');
-  err.status = res.status;
-  return err;
-}

lib/login.js

@@ -1,81 +0,0 @@
-import chalk from 'chalk';
-import fetch from 'node-fetch';
-import * as cfg from './cfg';
-import { stringify as stringifyQuery } from 'querystring';
-
-const URL = 'http://api-registration.now.sh';
-
-const stdin = process.openStdin();
-
-function readEmail () {
-  return new Promise((resolve, reject) => {
-    process.stdout.write('> Enter your email address: ');
-    stdin.on('data', (d) => {
-      stdin.destroy();
-      resolve(d.toString().trim());
-    });
-  });
-}
-
-async function getVerificationToken (email) {
-  const data = JSON.stringify({ email });
-  const res = await fetch(URL, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(data)
-    },
-    body: data
-  });
-
-  if (200 !== res.status) {
-    throw new Error('Verification error');
-  }
-
-  const body = await res.json();
-  return body.token;
-}
-
-async function verify (email, verificationToken) {
-  const query = {
-    email,
-    token: verificationToken
-  };
-
-  const res = await fetch(`${URL}/verify?${stringifyQuery(query)}`);
-  const body = await res.json();
-  return body.token;
-}
-
-function sleep (ms) {
-  return new Promise((resolve, reject) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-async function register () {
-  const email = await readEmail();
-  const verificationToken = await getVerificationToken(email);
-
-  console.log(`> Please follow the link sent to ${chalk.bold(email)} to log in.`);
-  process.stdout.write('> Waiting for confirmation..');
-
-  let final;
-  do {
-    await sleep(2500);
-    try {
-      final = await verify(email, verificationToken);
-    } catch (e) {}
-    process.stdout.write('.');
-  } while (!final);
-
-  process.stdout.write('\n');
-
-  return { email, token: final };
-}
-
-export default async function () {
-  const loginData = await register();
-  cfg.merge(loginData);
-  return loginData.token;
-}

lib/retry.js

@@ -1,29 +0,0 @@
-import retrier from 'retry';
-
-export default function retry (fn, opts) {
-  return new Promise((resolve, reject) => {
-    const op = retrier.operation(opts);
-    const { onRetry } = opts;
-
-    // we allow the user to abort retrying
-    // this makes sense in the cases where
-    // knowledge is obtained that retrying
-    // would be futile (e.g.: auth errors)
-    const bail = (err) => reject(err);
-
-    op.attempt((num) => {
-      if (num > 1 && onRetry) {
-        const errs = op.errors();
-        onRetry(errs[errs.length - 1]);
-      }
-
-      fn(bail)
-      .then((val) => resolve(val))
-      .catch(err => {
-        if (!op.retry(err)) {
-          reject(op.mainError());
-        }
-      });
-    });
-  });
-}

lib/test.js

@@ -1,20 +0,0 @@
-import getFiles from './get-files';
-import { resolve } from 'path';
-
-getFiles(resolve('../mng-test/files-in-package'))
-.then(files => {
-  console.log(files);
-
-  getFiles(resolve('../mng-test/files-in-package-ignore'))
-  .then(files2 => {
-    console.log('ignored: ');
-    console.log(files2);
-  })
-  .catch(err => {
-    console.log(err.stack);
-  });
-})
-.catch(err => {
-  console.log(err.stack);
-});
-

package.json

@@ -1,77 +1,62 @@
 {
-  "name": "now",
-  "version": "0.9.8",
-  "description": "Realtime Deployments for Node.JS apps.",
-  "main": "./build/lib/index",
-  "files": [
-    "build"
-  ],
-  "bin": {
-    "now": "./build/bin/now"
+  "name": "now-builders",
+  "version": "0.0.0",
+  "private": true,
+  "license": "MIT",
+  "workspaces": {
+    "packages": [
+      "packages/*"
+    ],
+    "nohoist": [
+      "**/@types/**"
+    ]
   },
   "dependencies": {
-    "arr-flatten": "1.0.1",
-    "array-unique": "0.2.1",
-    "babel-runtime": "6.6.1",
-    "bytes": "2.3.0",
-    "chalk": "1.1.1",
-    "commander": "2.9.0",
-    "copy-paste": "1.1.4",
-    "fs-promise": "0.4.1",
-    "graceful-fs": "4.1.3",
-    "minimatch": "3.0.0",
-    "ms": "0.7.1",
-    "node-fetch": "1.3.3",
-    "progress": "1.1.8",
-    "resumer": "0.0.0",
-    "retry": "0.9.0",
-    "spdy": "3.2.3",
-    "split-array": "1.0.1"
+    "lerna": "3.16.4"
   },
   "devDependencies": {
-    "alpha-sort": "1.0.2",
-    "ava": "0.12.0",
-    "babel-eslint": "5.0.0",
-    "babel-plugin-transform-runtime": "6.6.0",
-    "babel-plugin-syntax-async-functions": "6.5.0",
-    "babel-plugin-transform-async-to-generator": "6.7.0",
-    "babel-preset-es2015": "6.3.13",
-    "babel-register": "6.6.5",
-    "del": "2.2.0",
-    "eslint-config-standard": "5.1.0",
-    "eslint-plugin-standard": "1.3.2",
-    "gulp": "3.9.0",
-    "gulp-babel": "6.1.2",
-    "gulp-eslint": "2.0.0",
-    "gulp-ext": "1.0.0",
-    "gulp-task-listing": "1.0.1",
-    "gulp-uglify": "1.5.3",
-    "eslint": "2.3.0",
-    "eslint-plugin-promise": "1.1.0",
-    "estraverse-fb": "1.3.1"
+    "@typescript-eslint/eslint-plugin": "2.0.0",
+    "@typescript-eslint/parser": "2.0.0",
+    "@zeit/ncc": "0.20.4",
+    "async-retry": "1.2.3",
+    "buffer-replace": "1.0.0",
+    "eslint": "6.2.2",
+    "eslint-config-prettier": "6.1.0",
+    "husky": "3.0.4",
+    "lint-staged": "9.2.5",
+    "node-fetch": "2.6.0",
+    "prettier": "1.18.2"
   },
   "scripts": {
-    "gulp": "gulp",
-    "test": "ava",
-    "postinstall": "build/scripts/post-install"
+    "lerna": "lerna",
+    "bootstrap": "lerna bootstrap",
+    "publish-stable": "git checkout master && git pull && lerna version --exact",
+    "publish-canary": "git checkout canary && git pull && lerna version prerelease --preid canary --exact",
+    "publish-from-github": "./.circleci/publish.sh",
+    "diff": "node diff.js",
+    "changelog": "node changelog.js",
+    "build": "node run.js build all",
+    "test-lint": "node run.js test-lint",
+    "test-unit": "node run.js test-unit",
+    "test-integration": "node run.js test-integration",
+    "test-integration-once": "node run.js test-integration-once",
+    "test-integration-now-dev": "node run.js test-integration-now-dev",
+    "lint": "eslint . --ext .ts,.js"
   },
-  "babel": {
-    "presets": [
-      "es2015"
+  "lint-staged": {
+    "*.{js,ts}": [
+      "prettier --write",
+      "eslint",
+      "git add"
     ],
-    "plugins": [
-      "transform-runtime",
-      "syntax-async-functions",
-      "transform-async-to-generator"
+    "*.{json,md}": [
+      "prettier --write",
+      "git add"
     ]
   },
-  "ava": {
-    "failFast": true,
-    "files": [
-      "test/*.js"
-    ],
-    "require": [
-      "babel-register"
-    ]
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
   }
 }

packages/gatsby-plugin-now/build.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euo pipefail
+
+# build fixtures for tests
+yarn --cwd test/fixtures install
+yarn --cwd test/fixtures run build

packages/gatsby-plugin-now/gatsby-node.js

@@ -0,0 +1,33 @@
+const path = require('path');
+const writeFile = require('util').promisify(require('fs').writeFile);
+
+const REDIRECT_FILE_NAME = '__now_routes_g4t5bY.json';
+
+exports.onPostBuild = async ({ store }) => {
+  const { redirects, program } = store.getState();
+
+  if (!redirects.length === 0) {
+    return;
+  }
+
+  const routes = [{ handle: 'filesystem' }];
+
+  for (const redirect of redirects) {
+    const route = {
+      src: redirect.fromPath,
+      status: redirect.statusCode || (redirect.isPermanent ? 301 : 302),
+      headers: { Location: redirect.toPath }
+    };
+
+    if (redirect.force) {
+      routes.unshift(route);
+    } else {
+      routes.push(route);
+    }
+  }
+
+  await writeFile(
+    path.join(program.directory, 'public', REDIRECT_FILE_NAME),
+    JSON.stringify(routes)
+  );
+};

packages/gatsby-plugin-now/index.js

@@ -0,0 +1 @@
+// noop

packages/gatsby-plugin-now/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "gatsby-plugin-now",
+  "version": "1.2.2",
+  "main": "index.js",
+  "license": "MIT",
+  "homepage": "https://github.com/zeit/now/tree/canary/packages/gatsby-plugin-now#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now.git",
+    "directory": "packages/gatsby-plugin-now"
+  },
+  "keywords": [
+    "gatsby",
+    "gatsby-plugin"
+  ],
+  "scripts": {
+    "build": "./build.sh",
+    "test-integration-once": "jest --verbose"
+  },
+  "files": [
+    "index.js",
+    "gatsby-node.js"
+  ],
+  "peerDependencies": {
+    "gatsby": ">=2.0.0"
+  },
+  "devDependencies": {
+    "jest": "24.9.0"
+  },
+  "jest": {
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "<rootDir>/test/fixtures/"
+    ]
+  }
+}

packages/gatsby-plugin-now/readme.md

@@ -0,0 +1,24 @@
+# gatsby-plugin-now
+
+This plugin generates [Now Routes](https://zeit.co/docs/v2/advanced/routes) for [redirects](https://www.gatsbyjs.org/docs/actions/#createRedirect) you configured for to your Gatsby project.
+
+### Usage
+
+1. Install the plugin:
+
+```
+npm install gatsby-plugin-now --save-dev
+```
+
+2. Add it to the configuration file:
+
+```
+// gatsby-config.js
+module.exports = {
+  plugins: [
+    'gatsby-plugin-now'
+  ]
+}
+```
+
+3. [Deploy your project to ZEIT Now](https://www.gatsbyjs.org/docs/deploying-to-zeit-now/)

packages/gatsby-plugin-now/test/__snapshots__/index.test.js.snap

@@ -0,0 +1,86 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`test generated now routes 1`] = `
+Array [
+  Object {
+    "headers": Object {
+      "Location": "/",
+    },
+    "src": "/my-special-redirect",
+    "status": 302,
+  },
+  Object {
+    "handle": "filesystem",
+  },
+  Object {
+    "headers": Object {
+      "Location": "/page-2",
+    },
+    "src": "/page2",
+    "status": 301,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/page-2/",
+    },
+    "src": "/page2/",
+    "status": 301,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/",
+    },
+    "src": "/orange",
+    "status": 302,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/",
+    },
+    "src": "/grape",
+    "status": 302,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/page-2/",
+    },
+    "src": "/blue",
+    "status": 302,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/page-2/",
+    },
+    "src": "/randirect",
+    "status": 302,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/",
+    },
+    "src": "/juice",
+    "status": 302,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/",
+    },
+    "src": "/soda",
+    "status": 302,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/page-2/",
+    },
+    "src": "/donut",
+    "status": 302,
+  },
+  Object {
+    "headers": Object {
+      "Location": "/page-2/",
+    },
+    "src": "/randorect",
+    "status": 302,
+  },
+]
+`;

packages/gatsby-plugin-now/test/fixtures/.gitignore

@@ -0,0 +1,4 @@
+public
+node_modules
+.cache
+yarn.lock

packages/gatsby-plugin-now/test/fixtures/gatsby-config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  plugins: [{ resolve: require.resolve('../../') }]
+};

packages/gatsby-plugin-now/test/fixtures/gatsby-node.js

@@ -0,0 +1,105 @@
+'use strict';
+
+// Implement the Gatsby API “createPages”. This is called once the
+// data layer is bootstrapped to let plugins create pages from data.
+exports.createPages = ({ actions }) => {
+  // need createRedirect action in actions collection
+  // to make the redirection magic happen.
+  // https://www.gatsbyjs.org/docs/bound-action-creators/
+  const { createRedirect } = actions;
+
+  // Let’s set up some string consts to use thoroughout the following.
+  // MDN > JavaScript reference > Statements and declarations
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const
+  // Maybe we usually redirect to page 2, with trailing slash.
+  const page2Path = `/page-2/`;
+  // But sometimes to homepage.
+  const homePath = `/`;
+
+  // One-off redirect, note trailing slash missing on fromPath and
+  // toPath here.
+  createRedirect({
+    fromPath: `/page2`,
+    isPermanent: true,
+    redirectInBrowser: true,
+    toPath: `/page-2`
+  });
+
+  // Another one-off redirect, note trailing slash on toPath here.
+  // This time we want trailing slash on toPath so we use
+  // page2Path. Need to handle trailing-slashed and non-trailing-
+  // slashed fromPaths separately, Gatsby serves page components
+  // at either version by default, but we need to explicitly redirect
+  // both versions independently, more on page components:
+  // Docs > Building with Components
+  // https://www.gatsbyjs.org/docs/building-with-components/
+  // and handling trailing slashes:
+  // Docs > Creating and modifying pages > Removing trailing slashes
+  // https://www.gatsbyjs.org/docs/creating-and-modifying-pages/#removing-trailing-slashes
+  createRedirect({
+    fromPath: `/page2/`,
+    isPermanent: true,
+    redirectInBrowser: true,
+    toPath: page2Path
+  });
+
+  // One approach to handle several redirects at once is to create an
+  // array of from/to path pairs.
+  let redirectBatch1 = [
+    { f: `/orange`, t: `/` },
+    // We could use homePath and page2Path directly here.
+    { f: `/grape`, t: homePath },
+    { f: `/blue`, t: page2Path },
+    // or leave to empty and swap for page2Path later on.
+    { f: `/randirect`, t: `` }
+  ];
+
+  // Then we can loop through the array of object literals to create
+  // each redirect. A for loop would do the trick
+  for (var { f: f, t: t } of redirectBatch1) {
+    // Here we swap any empty toPath values for trusty page 2 via
+    // page2Path.
+    if (t === ``) {
+      t = page2Path;
+    }
+    createRedirect({
+      fromPath: f,
+      redirectInBrowser: true,
+      toPath: t
+    });
+    // Uncomment next line to see loop in action during build
+    // console.log('\nRedirecting:\n' + f + '\nTo:\n' + t + '\n');
+    // or check .cache/redirects.json post-compile.
+  }
+
+  // A more modern approach might use forEach rather than for...of
+  // Compare
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration#for...of_statement
+  // and
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
+  let redirectBatch2 = [
+    { f: `/juice`, t: `/` },
+    { f: `/soda`, t: `/` },
+    { f: `/donut`, t: page2Path },
+    { f: `/randorect`, t: `` }
+  ];
+
+  redirectBatch2.forEach(({ f, t }) => {
+    if (t === ``) {
+      t = page2Path;
+    }
+    createRedirect({
+      fromPath: f,
+      redirectInBrowser: true,
+      toPath: t
+    });
+    // Uncomment next line to see forEach in action during build
+    // console.log('\nRedirecting:\n' + f + '\nTo:\n' + t + '\n');
+  });
+
+  createRedirect({
+    fromPath: '/my-special-redirect',
+    toPath: homePath,
+    force: true
+  });
+};

packages/gatsby-plugin-now/test/fixtures/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "fixtures",
+  "dependencies": {
+    "gatsby": "2.14.0",
+    "react": "16.9.0",
+    "react-dom": "16.9.0"
+  },
+  "scripts": {
+    "build": "gatsby build"
+  }
+}

packages/gatsby-plugin-now/test/fixtures/src/pages/index.js

@@ -0,0 +1,9 @@
+import React from 'react';
+
+const IndexPage = () => (
+  <div>
+    <h1>Hi people</h1>
+  </div>
+);
+
+export default IndexPage;

packages/gatsby-plugin-now/test/index.test.js

@@ -0,0 +1,5 @@
+test('test generated now routes', async () => {
+  const nowRoutes = require('./fixtures/public/__now_routes_g4t5bY.json');
+
+  expect(nowRoutes).toMatchSnapshot();
+});

packages/now-build-utils/.gitignore

@@ -0,0 +1,3 @@
+dist
+test/symlinks-out
+test/symlinks.zip

packages/now-build-utils/.npmignore

@@ -0,0 +1,3 @@
+/src
+/test
+tmp

packages/now-build-utils/build.sh

@@ -0,0 +1,6 @@
+tsc
+
+rm dist/index.js
+ncc build src/index.ts -o dist/main
+mv dist/main/index.js dist/index.js
+rm -rf dist/main

packages/now-build-utils/file-blob.js

@@ -0,0 +1 @@
+module.exports = require('./dist/index').FileBlob;

packages/now-build-utils/file-fs-ref.js

@@ -0,0 +1 @@
+module.exports = require('./dist/index').FileFsRef;

packages/now-build-utils/file-ref.js

@@ -0,0 +1 @@
+module.exports = require('./dist/index').FileRef;

packages/now-build-utils/fs/download.js

@@ -0,0 +1 @@
+module.exports = require('../dist/index').download;

packages/now-build-utils/fs/get-writable-directory.js

@@ -0,0 +1 @@
+module.exports = require('../dist/index').getWriteableDirectory;

packages/now-build-utils/fs/glob.js

@@ -0,0 +1 @@
+module.exports = require('../dist/index').glob;

packages/now-build-utils/fs/rename.js

@@ -0,0 +1 @@
+module.exports = require('../dist/index').rename;

packages/now-build-utils/fs/run-user-scripts.js

@@ -0,0 +1 @@
+module.exports = require('../dist/index');

packages/now-build-utils/fs/stream-to-buffer.js

@@ -0,0 +1 @@
+module.exports = require('../dist/index').streamToBuffer;

packages/now-build-utils/lambda.js

@@ -0,0 +1 @@
+module.exports = require('./dist/index');

packages/now-build-utils/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@now/build-utils",
+  "version": "0.10.1",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.js",
+  "homepage": "https://zeit.co/docs/v2/deployments/builders/developer-guide",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now.git",
+    "directory": "packages/now-build-utils"
+  },
+  "scripts": {
+    "build": "./build.sh",
+    "test-integration-once": "jest --env node --verbose --runInBand",
+    "prepublishOnly": "./build.sh"
+  },
+  "devDependencies": {
+    "@types/async-retry": "^1.2.1",
+    "@types/cross-spawn": "6.0.0",
+    "@types/end-of-stream": "^1.4.0",
+    "@types/fs-extra": "^5.0.5",
+    "@types/glob": "^7.1.1",
+    "@types/multistream": "2.1.1",
+    "@types/node-fetch": "^2.1.6",
+    "@types/semver": "6.0.0",
+    "@types/yazl": "^2.4.1",
+    "async-retry": "1.2.3",
+    "async-sema": "2.1.4",
+    "cross-spawn": "6.0.5",
+    "end-of-stream": "1.4.1",
+    "execa": "^1.0.0",
+    "fs-extra": "7.0.0",
+    "glob": "7.1.3",
+    "into-stream": "5.0.0",
+    "minimatch": "3.0.4",
+    "multistream": "2.1.1",
+    "node-fetch": "2.2.0",
+    "semver": "6.1.1",
+    "typescript": "3.5.2",
+    "yazl": "2.4.3"
+  }
+}

packages/now-build-utils/src/debug.ts

@@ -0,0 +1,5 @@
+export default function debug(message: string, ...additional: any[]) {
+  if (process.env.NOW_BUILDER_DEBUG) {
+    console.log(message, ...additional);
+  }
+}

packages/now-build-utils/src/detect-builders.ts

@@ -0,0 +1,216 @@
+import { PackageJson, Builder, Config } from './types';
+import minimatch from 'minimatch';
+
+interface ErrorResponse {
+  code: string;
+  message: string;
+}
+
+interface Options {
+  tag?: 'canary' | 'latest' | string;
+}
+
+const src = 'package.json';
+const config: Config = { zeroConfig: true };
+
+const MISSING_BUILD_SCRIPT_ERROR: ErrorResponse = {
+  code: 'missing_build_script',
+  message:
+    'Your `package.json` file is missing a `build` property inside the `script` property.' +
+    '\nMore details: https://zeit.co/docs/v2/advanced/platform/frequently-asked-questions#missing-build-script',
+};
+
+// Static builders are special cased in `@now/static-build`
+function getBuilders(): Map<string, Builder> {
+  return new Map<string, Builder>([
+    ['next', { src, use: '@now/next', config }],
+  ]);
+}
+
+// Must be a function to ensure that the returned
+// object won't be a reference
+function getApiBuilders(): Builder[] {
+  return [
+    { src: 'api/**/*.js', use: '@now/node', config },
+    { src: 'api/**/*.ts', use: '@now/node', config },
+    { src: 'api/**/*.go', use: '@now/go', config },
+    { src: 'api/**/*.py', use: '@now/python', config },
+    { src: 'api/**/*.rb', use: '@now/ruby', config },
+  ];
+}
+
+function hasPublicDirectory(files: string[]) {
+  return files.some(name => name.startsWith('public/'));
+}
+
+function hasBuildScript(pkg: PackageJson | undefined) {
+  const { scripts = {} } = pkg || {};
+  return Boolean(scripts && scripts['build']);
+}
+
+async function detectBuilder(pkg: PackageJson): Promise<Builder> {
+  for (const [dependency, builder] of getBuilders()) {
+    const deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
+
+    // Return the builder when a dependency matches
+    if (deps[dependency]) {
+      return builder;
+    }
+  }
+
+  // By default we'll choose the `static-build` builder
+  return { src, use: '@now/static-build', config };
+}
+
+// Files that match a specific pattern will get ignored
+export function ignoreApiFilter(file: string) {
+  if (file.includes('/.')) {
+    return false;
+  }
+
+  if (file.includes('/_')) {
+    return false;
+  }
+
+  if (file.endsWith('.d.ts')) {
+    return false;
+  }
+
+  // If the file does not match any builder we also
+  // don't want to create a route e.g. `package.json`
+  if (getApiBuilders().every(({ src }) => !minimatch(file, src))) {
+    return false;
+  }
+
+  return true;
+}
+
+// We need to sort the file paths by alphabet to make
+// sure the routes stay in the same order e.g. for deduping
+export function sortFiles(fileA: string, fileB: string) {
+  return fileA.localeCompare(fileB);
+}
+
+async function detectApiBuilders(files: string[]): Promise<Builder[]> {
+  const builds = files
+    .sort(sortFiles)
+    .filter(ignoreApiFilter)
+    .map(file => {
+      const result = getApiBuilders().find(({ src }): boolean =>
+        minimatch(file, src)
+      );
+
+      return result ? { ...result, src: file } : null;
+    });
+
+  const finishedBuilds = builds.filter(Boolean);
+  return finishedBuilds as Builder[];
+}
+
+// When a package has files that conflict with `/api` routes
+// e.g. Next.js pages/api we'll check it here and return an error.
+async function checkConflictingFiles(
+  files: string[],
+  builders: Builder[]
+): Promise<ErrorResponse | null> {
+  // For Next.js
+  if (builders.some(builder => builder.use.startsWith('@now/next'))) {
+    const hasApiPages = files.some(file => file.startsWith('pages/api/'));
+    const hasApiBuilders = builders.some(builder =>
+      builder.src.startsWith('api/')
+    );
+
+    if (hasApiPages && hasApiBuilders) {
+      return {
+        code: 'conflicting_files',
+        message:
+          'It is not possible to use `api` and `pages/api` at the same time, please only use one option',
+      };
+    }
+  }
+
+  return null;
+}
+
+// When zero config is used we can call this function
+// to determine what builders to use
+export async function detectBuilders(
+  files: string[],
+  pkg?: PackageJson | undefined | null,
+  options?: Options
+): Promise<{
+  builders: Builder[] | null;
+  errors: ErrorResponse[] | null;
+  warnings: ErrorResponse[];
+}> {
+  const errors: ErrorResponse[] = [];
+  const warnings: ErrorResponse[] = [];
+
+  // Detect all builders for the `api` directory before anything else
+  let builders = await detectApiBuilders(files);
+
+  if (pkg && hasBuildScript(pkg)) {
+    builders.push(await detectBuilder(pkg));
+
+    const conflictError = await checkConflictingFiles(files, builders);
+
+    if (conflictError) {
+      warnings.push(conflictError);
+    }
+  } else {
+    if (pkg && builders.length === 0) {
+      // We only show this error when there are no api builders
+      // since the dependencies of the pkg could be used for those
+      errors.push(MISSING_BUILD_SCRIPT_ERROR);
+      return { errors, warnings, builders: null };
+    }
+
+    // We allow a `public` directory
+    // when there are no build steps
+    if (hasPublicDirectory(files)) {
+      builders.push({
+        use: '@now/static',
+        src: 'public/**/*',
+        config,
+      });
+    } else if (builders.length > 0) {
+      // We can't use pattern matching, since `!(api)` and `!(api)/**/*`
+      // won't give the correct results
+      builders.push(
+        ...files
+          .filter(name => !name.startsWith('api/'))
+          .filter(name => !(name === 'package.json'))
+          .map(name => ({
+            use: '@now/static',
+            src: name,
+            config,
+          }))
+      );
+    }
+  }
+
+  // Change the tag for the builders
+  if (builders && builders.length) {
+    const tag = options && options.tag;
+
+    if (tag) {
+      builders = builders.map((originBuilder: Builder) => {
+        // Copy builder to make sure it is not a reference
+        const builder = { ...originBuilder };
+
+        // @now/static has no canary builder
+        if (builder.use !== '@now/static') {
+          builder.use = `${builder.use}@${tag}`;
+        }
+
+        return builder;
+      });
+    }
+  }
+
+  return {
+    builders: builders.length ? builders : null,
+    errors: errors.length ? errors : null,
+    warnings,
+  };
+}

packages/now-build-utils/src/detect-routes.ts

@@ -0,0 +1,295 @@
+import { Route, Builder } from './types';
+import { parse as parsePath } from 'path';
+import { ignoreApiFilter, sortFiles } from './detect-builders';
+
+function escapeName(name: string) {
+  const special = '[]^$.|?*+()'.split('');
+
+  for (const char of special) {
+    name = name.replace(new RegExp(`\\${char}`, 'g'), `\\${char}`);
+  }
+
+  return name;
+}
+
+function joinPath(...segments: string[]) {
+  const joinedPath = segments.join('/');
+  return joinedPath.replace(/\/{2,}/g, '/');
+}
+
+function concatArrayOfText(texts: string[]): string {
+  if (texts.length <= 2) {
+    return texts.join(' and ');
+  }
+
+  const last = texts.pop();
+  return `${texts.join(', ')}, and ${last}`;
+}
+
+// Takes a filename or foldername, strips the extension
+// gets the part between the "[]" brackets.
+// It will return `null` if there are no brackets
+// and therefore no segment.
+function getSegmentName(segment: string): string | null {
+  const { name } = parsePath(segment);
+
+  if (name.startsWith('[') && name.endsWith(']')) {
+    return name.slice(1, -1);
+  }
+
+  return null;
+}
+
+function createRouteFromPath(filePath: string): Route {
+  const parts = filePath.split('/');
+
+  let counter = 1;
+  const query: string[] = [];
+
+  const srcParts = parts.map((segment, index): string => {
+    const name = getSegmentName(segment);
+    const isLast = index === parts.length - 1;
+
+    if (name !== null) {
+      // We can't use `URLSearchParams` because `$` would get escaped
+      query.push(`${name}=$${counter++}`);
+      return `([^\\/]+)`;
+    } else if (isLast) {
+      const { name: fileName, ext } = parsePath(segment);
+      const isIndex = fileName === 'index';
+      const prefix = isIndex ? '\\/' : '';
+
+      const names = [
+        prefix,
+        prefix + escapeName(fileName),
+        prefix + escapeName(fileName) + escapeName(ext)
+      ].filter(Boolean);
+
+      // Either filename with extension, filename without extension
+      // or nothing when the filename is `index`
+      return `(${names.join('|')})${isIndex ? '?' : ''}`;
+    }
+
+    return segment;
+  });
+
+  const { name: fileName } = parsePath(filePath);
+  const isIndex = fileName === 'index';
+
+  const src = isIndex
+    ? `^/${srcParts.slice(0, -1).join('/')}${srcParts.slice(-1)[0]}$`
+    : `^/${srcParts.join('/')}$`;
+
+  const dest = `/${filePath}${query.length ? '?' : ''}${query.join('&')}`;
+
+  return { src, dest };
+}
+
+// Check if the path partially matches and has the same
+// name for the path segment at the same position
+function partiallyMatches(pathA: string, pathB: string): boolean {
+  const partsA = pathA.split('/');
+  const partsB = pathB.split('/');
+
+  const long = partsA.length > partsB.length ? partsA : partsB;
+  const short = long === partsA ? partsB : partsA;
+
+  let index = 0;
+
+  for (const segmentShort of short) {
+    const segmentLong = long[index];
+
+    const nameLong = getSegmentName(segmentLong);
+    const nameShort = getSegmentName(segmentShort);
+
+    // If there are no segments or the paths differ we
+    // return as they are not matching
+    if (segmentShort !== segmentLong && (!nameLong || !nameShort)) {
+      return false;
+    }
+
+    if (nameLong !== nameShort) {
+      return true;
+    }
+
+    index += 1;
+  }
+
+  return false;
+}
+
+// Counts how often a path occurres when all placeholders
+// got resolved, so we can check if they have conflicts
+function pathOccurrences(filePath: string, files: string[]): string[] {
+  const getAbsolutePath = (unresolvedPath: string): string => {
+    const { dir, name } = parsePath(unresolvedPath);
+    const parts = joinPath(dir, name).split('/');
+    return parts.map(part => part.replace(/\[.*\]/, '1')).join('/');
+  };
+
+  const currentAbsolutePath = getAbsolutePath(filePath);
+
+  return files.reduce((prev: string[], file: string): string[] => {
+    const absolutePath = getAbsolutePath(file);
+
+    if (absolutePath === currentAbsolutePath) {
+      prev.push(file);
+    } else if (partiallyMatches(filePath, file)) {
+      prev.push(file);
+    }
+
+    return prev;
+  }, []);
+}
+
+// Checks if a placeholder with the same name is used
+// multiple times inside the same path
+function getConflictingSegment(filePath: string): string | null {
+  const segments = new Set<string>();
+
+  for (const segment of filePath.split('/')) {
+    const name = getSegmentName(segment);
+
+    if (name !== null && segments.has(name)) {
+      return name;
+    }
+
+    if (name) {
+      segments.add(name);
+    }
+  }
+
+  return null;
+}
+
+function sortFilesBySegmentCount(fileA: string, fileB: string): number {
+  const lengthA = fileA.split('/').length;
+  const lengthB = fileB.split('/').length;
+
+  if (lengthA > lengthB) {
+    return -1;
+  }
+
+  if (lengthA < lengthB) {
+    return 1;
+  }
+
+  // Paths that have the same segment length but
+  // less placeholders are preferred
+  const countSegments = (prev: number, segment: string) =>
+    getSegmentName(segment) ? prev + 1 : 0;
+  const segmentLengthA = fileA.split('/').reduce(countSegments, 0);
+  const segmentLengthB = fileB.split('/').reduce(countSegments, 0);
+
+  if (segmentLengthA > segmentLengthB) {
+    return 1;
+  }
+
+  if (segmentLengthA < segmentLengthB) {
+    return -1;
+  }
+
+  return 0;
+}
+
+interface RoutesResult {
+  defaultRoutes: Route[] | null;
+  error: { [key: string]: string } | null;
+}
+
+async function detectApiRoutes(files: string[]): Promise<RoutesResult> {
+  if (!files || files.length === 0) {
+    return { defaultRoutes: null, error: null };
+  }
+
+  // The deepest routes need to be
+  // the first ones to get handled
+  const sortedFiles = files
+    .filter(ignoreApiFilter)
+    .sort(sortFiles)
+    .sort(sortFilesBySegmentCount);
+
+  const defaultRoutes: Route[] = [];
+
+  for (const file of sortedFiles) {
+    // We only consider every file in the api directory
+    // as we will strip extensions as well as resolving "[segments]"
+    if (!file.startsWith('api/')) {
+      continue;
+    }
+
+    const conflictingSegment = getConflictingSegment(file);
+
+    if (conflictingSegment) {
+      return {
+        defaultRoutes: null,
+        error: {
+          code: 'conflicting_path_segment',
+          message:
+            `The segment "${conflictingSegment}" occurres more than ` +
+            `one time in your path "${file}". Please make sure that ` +
+            `every segment in a path is unique`
+        }
+      };
+    }
+
+    const occurrences = pathOccurrences(file, sortedFiles).filter(
+      name => name !== file
+    );
+
+    if (occurrences.length > 0) {
+      const messagePaths = concatArrayOfText(
+        occurrences.map(name => `"${name}"`)
+      );
+
+      return {
+        defaultRoutes: null,
+        error: {
+          code: 'conflicting_file_path',
+          message:
+            `Two or more files have conflicting paths or names. ` +
+            `Please make sure path segments and filenames, without their extension, are unique. ` +
+            `The path "${file}" has conflicts with ${messagePaths}`
+        }
+      };
+    }
+
+    defaultRoutes.push(createRouteFromPath(file));
+  }
+
+  // 404 Route to disable directory listing
+  if (defaultRoutes.length) {
+    defaultRoutes.push({
+      status: 404,
+      src: '/api(\\/.*)?$'
+    });
+  }
+
+  return { defaultRoutes, error: null };
+}
+
+function hasPublicBuilder(builders: Builder[]): boolean {
+  return builders.some(
+    builder =>
+      builder.use === '@now/static' &&
+      builder.src === 'public/**/*' &&
+      builder.config &&
+      builder.config.zeroConfig === true
+  );
+}
+
+export async function detectRoutes(
+  files: string[],
+  builders: Builder[]
+): Promise<RoutesResult> {
+  const routesResult = await detectApiRoutes(files);
+
+  if (routesResult.defaultRoutes && hasPublicBuilder(builders)) {
+    routesResult.defaultRoutes.push({
+      src: '/(.*)',
+      dest: '/public/$1'
+    });
+  }
+
+  return routesResult;
+}

packages/now-build-utils/src/file-blob.ts

@@ -0,0 +1,46 @@
+import assert from 'assert';
+import intoStream from 'into-stream';
+import { File } from './types';
+
+interface FileBlobOptions {
+  mode?: number;
+  data: string | Buffer;
+}
+
+interface FromStreamOptions {
+  mode?: number;
+  stream: NodeJS.ReadableStream;
+}
+
+export default class FileBlob implements File {
+  public type: 'FileBlob';
+  public mode: number;
+  public data: string | Buffer;
+
+  constructor({ mode = 0o100644, data }: FileBlobOptions) {
+    assert(typeof mode === 'number');
+    assert(typeof data === 'string' || Buffer.isBuffer(data));
+    this.type = 'FileBlob';
+    this.mode = mode;
+    this.data = data;
+  }
+
+  static async fromStream({ mode = 0o100644, stream }: FromStreamOptions) {
+    assert(typeof mode === 'number');
+    assert(typeof stream.pipe === 'function'); // is-stream
+    const chunks: Buffer[] = [];
+
+    await new Promise<void>((resolve, reject) => {
+      stream.on('data', chunk => chunks.push(Buffer.from(chunk)));
+      stream.on('error', error => reject(error));
+      stream.on('end', () => resolve());
+    });
+
+    const data = Buffer.concat(chunks);
+    return new FileBlob({ mode, data });
+  }
+
+  toStream(): NodeJS.ReadableStream {
+    return intoStream(this.data);
+  }
+}

packages/now-build-utils/src/file-fs-ref.ts

@@ -0,0 +1,97 @@
+import assert from 'assert';
+import fs from 'fs-extra';
+import multiStream from 'multistream';
+import path from 'path';
+import Sema from 'async-sema';
+import { File } from './types';
+
+const semaToPreventEMFILE = new Sema(20);
+
+interface FileFsRefOptions {
+  mode?: number;
+  fsPath: string;
+}
+
+interface FromStreamOptions {
+  mode: number;
+  stream: NodeJS.ReadableStream;
+  fsPath: string;
+}
+
+class FileFsRef implements File {
+  public type: 'FileFsRef';
+  public mode: number;
+  public fsPath: string;
+
+  constructor({ mode = 0o100644, fsPath }: FileFsRefOptions) {
+    assert(typeof mode === 'number');
+    assert(typeof fsPath === 'string');
+    this.type = 'FileFsRef';
+    this.mode = mode;
+    this.fsPath = fsPath;
+  }
+
+  static async fromFsPath({
+    mode,
+    fsPath,
+  }: FileFsRefOptions): Promise<FileFsRef> {
+    let m = mode;
+    if (!m) {
+      const stat = await fs.lstat(fsPath);
+      m = stat.mode;
+    }
+    return new FileFsRef({ mode: m, fsPath });
+  }
+
+  static async fromStream({
+    mode = 0o100644,
+    stream,
+    fsPath,
+  }: FromStreamOptions): Promise<FileFsRef> {
+    assert(typeof mode === 'number');
+    assert(typeof stream.pipe === 'function'); // is-stream
+    assert(typeof fsPath === 'string');
+    await fs.mkdirp(path.dirname(fsPath));
+
+    await new Promise<void>((resolve, reject) => {
+      const dest = fs.createWriteStream(fsPath, {
+        mode: mode & 0o777,
+      });
+      stream.pipe(dest);
+      stream.on('error', reject);
+      dest.on('finish', resolve);
+      dest.on('error', reject);
+    });
+
+    return new FileFsRef({ mode, fsPath });
+  }
+
+  async toStreamAsync(): Promise<NodeJS.ReadableStream> {
+    await semaToPreventEMFILE.acquire();
+    const release = () => semaToPreventEMFILE.release();
+    const stream = fs.createReadStream(this.fsPath);
+    stream.on('close', release);
+    stream.on('error', release);
+    return stream;
+  }
+
+  toStream(): NodeJS.ReadableStream {
+    let flag = false;
+
+    // eslint-disable-next-line consistent-return
+    return multiStream(cb => {
+      if (flag) return cb(null, null);
+      flag = true;
+
+      this.toStreamAsync()
+        .then(stream => {
+          cb(null, stream);
+        })
+        .catch(error => {
+          cb(error, null);
+        });
+    });
+  }
+}
+
+export = FileFsRef;

packages/now-build-utils/src/file-ref.ts

@@ -0,0 +1,100 @@
+import assert from 'assert';
+import fetch from 'node-fetch';
+import multiStream from 'multistream';
+import retry from 'async-retry';
+import Sema from 'async-sema';
+import { File } from './types';
+
+interface FileRefOptions {
+  mode?: number;
+  digest: string;
+  mutable?: boolean;
+}
+
+const semaToDownloadFromS3 = new Sema(5);
+
+class BailableError extends Error {
+  public bail: boolean;
+
+  constructor(...args: string[]) {
+    super(...args);
+    this.bail = false;
+  }
+}
+
+export default class FileRef implements File {
+  public type: 'FileRef';
+  public mode: number;
+  public digest: string;
+  private mutable: boolean;
+
+  constructor({ mode = 0o100644, digest, mutable = false }: FileRefOptions) {
+    assert(typeof mode === 'number');
+    assert(typeof digest === 'string');
+    this.type = 'FileRef';
+    this.mode = mode;
+    this.digest = digest;
+    this.mutable = mutable;
+  }
+
+  async toStreamAsync(): Promise<NodeJS.ReadableStream> {
+    let url = '';
+    // sha:24be087eef9fac01d61b30a725c1a10d7b45a256
+    const [digestType, digestHash] = this.digest.split(':');
+    if (digestType === 'sha') {
+      // This CloudFront URL edge caches the `now-files` S3 bucket to prevent
+      // overloading it. Mutable files cannot be cached.
+      // `https://now-files.s3.amazonaws.com/${digestHash}`
+      url = this.mutable
+        ? `https://now-files.s3.amazonaws.com/${digestHash}`
+        : `https://dmmcy0pwk6bqi.cloudfront.net/${digestHash}`;
+    } else if (digestType === 'sha+ephemeral') {
+      // This URL is currently only used for cache files that constantly
+      // change. We shouldn't cache it on CloudFront because it'd always be a
+      // MISS.
+      url = `https://now-ephemeral-files.s3.amazonaws.com/${digestHash}`;
+    } else {
+      throw new Error('Expected digest to be sha');
+    }
+
+    await semaToDownloadFromS3.acquire();
+    // console.time(`downloading ${url}`);
+    try {
+      return await retry(
+        async () => {
+          const resp = await fetch(url);
+          if (!resp.ok) {
+            const error = new BailableError(
+              `download: ${resp.status} ${resp.statusText} for ${url}`
+            );
+            if (resp.status === 403) error.bail = true;
+            throw error;
+          }
+          return resp.body;
+        },
+        { factor: 1, retries: 3 }
+      );
+    } finally {
+      // console.timeEnd(`downloading ${url}`);
+      semaToDownloadFromS3.release();
+    }
+  }
+
+  toStream(): NodeJS.ReadableStream {
+    let flag = false;
+
+    // eslint-disable-next-line consistent-return
+    return multiStream(cb => {
+      if (flag) return cb(null, null);
+      flag = true;
+
+      this.toStreamAsync()
+        .then(stream => {
+          cb(null, stream);
+        })
+        .catch(error => {
+          cb(error, null);
+        });
+    });
+  }
+}

packages/now-build-utils/src/fs/download.ts

@@ -0,0 +1,75 @@
+import path from 'path';
+import FileFsRef from '../file-fs-ref';
+import { File, Files, Meta } from '../types';
+import { remove, mkdirp, readlink, symlink } from 'fs-extra';
+
+export interface DownloadedFiles {
+  [filePath: string]: FileFsRef;
+}
+
+const S_IFMT = 61440; /* 0170000 type of file */
+const S_IFLNK = 40960; /* 0120000 symbolic link */
+
+export function isSymbolicLink(mode: number): boolean {
+  return (mode & S_IFMT) === S_IFLNK;
+}
+
+async function downloadFile(file: File, fsPath: string): Promise<FileFsRef> {
+  const { mode } = file;
+  if (mode && isSymbolicLink(mode) && file.type === 'FileFsRef') {
+    const [target] = await Promise.all([
+      readlink((file as FileFsRef).fsPath),
+      mkdirp(path.dirname(fsPath)),
+    ]);
+    await symlink(target, fsPath);
+    return FileFsRef.fromFsPath({ mode, fsPath });
+  } else {
+    const stream = file.toStream();
+    return FileFsRef.fromStream({ mode, stream, fsPath });
+  }
+}
+
+async function removeFile(basePath: string, fileMatched: string) {
+  const file = path.join(basePath, fileMatched);
+  await remove(file);
+}
+
+export default async function download(
+  files: Files,
+  basePath: string,
+  meta?: Meta
+): Promise<DownloadedFiles> {
+  const { isDev = false, skipDownload = false, filesChanged = null, filesRemoved = null } =
+    meta || {};
+
+  if (isDev || skipDownload) {
+    // In `now dev`, the `download()` function is a no-op because
+    // the `basePath` matches the `cwd` of the dev server, so the
+    // source files are already available.
+    return files as DownloadedFiles;
+  }
+
+  const files2: DownloadedFiles = {};
+
+  await Promise.all(
+    Object.keys(files).map(async name => {
+      // If the file does not exist anymore, remove it.
+      if (Array.isArray(filesRemoved) && filesRemoved.includes(name)) {
+        await removeFile(basePath, name);
+        return;
+      }
+
+      // If a file didn't change, do not re-download it.
+      if (Array.isArray(filesChanged) && !filesChanged.includes(name)) {
+        return;
+      }
+
+      const file = files[name];
+      const fsPath = path.join(basePath, name);
+
+      files2[name] = await downloadFile(file, fsPath);
+    })
+  );
+
+  return files2;
+}

packages/now-build-utils/src/fs/get-writable-directory.ts

@@ -0,0 +1,10 @@
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { mkdirp } from 'fs-extra';
+
+export default async function getWritableDirectory() {
+  const name = Math.floor(Math.random() * 0x7fffffff).toString(16);
+  const directory = join(tmpdir(), name);
+  await mkdirp(directory);
+  return directory;
+}