@vercel/client 17.2.41 → 17.2.42

package/dist/continue.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { Agent } from 'http';
+import type { DeploymentEventType } from './types';
+/**
+ * Continues a manual deployment by uploading build outputs and calling the
+ * continue endpoint. Waits for READY state unless the caller stops consuming
+ * events early.
+ */
+export declare function continueDeployment(options: {
+    agent?: Agent;
+    apiUrl?: string;
+    debug?: boolean;
+    deploymentId: string;
+    path: string;
+    teamId?: string;
+    token: string;
+    userAgent?: string;
+    vercelOutputDir?: string;
+}): AsyncIterableIterator<{
+    type: DeploymentEventType;
+    payload: any;
+}>;

package/dist/continue.js

@@ -0,0 +1,210 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var continue_exports = {};
+__export(continue_exports, {
+  continueDeployment: () => continueDeployment
+});
+module.exports = __toCommonJS(continue_exports);
+var import_path = require("path");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_check_deployment_status = require("./check-deployment-status");
+var import_utils = require("./utils");
+var import_hashes = require("./utils/hashes");
+var import_ready_state = require("./utils/ready-state");
+var import_upload = require("./upload");
+var import_errors = require("./errors");
+async function* continueDeployment(options) {
+  const debug = (0, import_utils.createDebug)(options.debug);
+  debug(`Continuing deployment: ${options.deploymentId}`);
+  const outputDir = options.vercelOutputDir || (0, import_path.join)(options.path, ".vercel", "output");
+  if (!await import_fs_extra.default.pathExists(outputDir)) {
+    return yield {
+      type: "error",
+      payload: new import_errors.DeploymentError({
+        code: "output_dir_not_found",
+        message: `Output directory not found at ${outputDir}. Run 'vercel build' first.`
+      })
+    };
+  }
+  const { fileList } = await (0, import_utils.buildFileTree)(
+    options.path,
+    { isDirectory: true, prebuilt: true, vercelOutputDir: outputDir },
+    debug
+  );
+  const files = await (0, import_hashes.hashes)(fileList);
+  debug(`Calculated ${files.size} unique hashes`);
+  yield { type: "hashes-calculated", payload: (0, import_hashes.mapToObject)(files) };
+  let deployment;
+  let result = await postContinue({
+    deploymentId: options.deploymentId,
+    files,
+    outputDir,
+    path: options.path,
+    token: options.token,
+    teamId: options.teamId,
+    apiUrl: options.apiUrl,
+    userAgent: options.userAgent,
+    agent: options.agent,
+    debug: options.debug
+  });
+  if (result.type === "missing_files") {
+    debug(`Uploading ${result.missing.length} missing files...`);
+    const uploads = result.missing.map(
+      (sha) => new import_upload.UploadProgress(sha, files.get(sha))
+    );
+    yield {
+      type: "file-count",
+      payload: { total: files, missing: result.missing, uploads }
+    };
+    for await (const event of (0, import_upload.uploadFiles)({
+      agent: options.agent,
+      apiUrl: options.apiUrl,
+      debug: options.debug,
+      teamId: options.teamId,
+      token: options.token,
+      userAgent: options.userAgent,
+      shas: result.missing,
+      files,
+      uploads
+    })) {
+      if (event.type === "error") {
+        return yield event;
+      }
+      yield event;
+    }
+    yield { type: "all-files-uploaded", payload: files };
+    result = await postContinue({
+      deploymentId: options.deploymentId,
+      files,
+      outputDir,
+      path: options.path,
+      token: options.token,
+      teamId: options.teamId,
+      apiUrl: options.apiUrl,
+      userAgent: options.userAgent,
+      agent: options.agent,
+      debug: options.debug
+    });
+    if (result.type === "missing_files") {
+      return yield {
+        type: "error",
+        payload: {
+          code: "missing_files",
+          message: "Missing files",
+          missing: result.missing
+        }
+      };
+    }
+  }
+  if (result.type === "error") {
+    return yield { type: "error", payload: result.error };
+  }
+  if (result.type === "success") {
+    deployment = result.deployment;
+    yield { type: "created", payload: deployment };
+  }
+  if (!deployment) {
+    return yield {
+      type: "error",
+      payload: new import_errors.DeploymentError({
+        code: "continue_failed",
+        message: "Failed to continue deployment after uploading files"
+      })
+    };
+  }
+  if ((0, import_ready_state.isReady)(deployment) && (0, import_ready_state.isAliasAssigned)(deployment)) {
+    yield { type: "ready", payload: deployment };
+    return yield { type: "alias-assigned", payload: deployment };
+  }
+  yield* (0, import_check_deployment_status.checkDeploymentStatus)(deployment, {
+    agent: options.agent,
+    apiUrl: options.apiUrl,
+    debug: options.debug,
+    path: options.path,
+    teamId: options.teamId,
+    token: options.token,
+    userAgent: options.userAgent
+  });
+}
+async function postContinue(options) {
+  const debug = (0, import_utils.createDebug)(options.debug);
+  debug(`Calling continue deployment endpoint for ${options.deploymentId}`);
+  const response = await (0, import_utils.fetch)(
+    `/deployments/${options.deploymentId}/continue${options.teamId ? `?teamId=${options.teamId}` : ""}`,
+    options.token,
+    {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        files: (0, import_utils.prepareFiles)(options.files, {
+          isDirectory: true,
+          path: options.path,
+          token: options.token
+        })
+      }),
+      apiUrl: options.apiUrl,
+      userAgent: options.userAgent,
+      agent: options.agent
+    }
+  );
+  let result;
+  try {
+    result = await response.json();
+  } catch {
+    return {
+      type: "error",
+      error: new Error("Invalid JSON response from continue endpoint")
+    };
+  }
+  if (!response.ok || result.error) {
+    if (result.error?.code === "missing_files" || result.code === "missing_files") {
+      debug(
+        `Continue deployment returned missing_files: ${(result.error?.missing || result.missing || []).length} files`
+      );
+      return {
+        type: "missing_files",
+        missing: result.error?.missing || result.missing || []
+      };
+    }
+    debug("Continue deployment request failed");
+    return {
+      type: "error",
+      error: result.error ? { ...result.error, status: response.status } : { ...result, status: response.status }
+    };
+  }
+  debug("Continue deployment succeeded");
+  return { type: "success", deployment: result };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  continueDeployment
+});

package/dist/create-deployment.js

@@ -34,6 +34,7 @@ module.exports = __toCommonJS(create_deployment_exports);
 var import_fs_extra = require("fs-extra");
 var import_path = require("path");
 var import_hashes = require("./utils/hashes");
+var import_deploy = require("./deploy");
 var import_upload = require("./upload");
 var import_utils = require("./utils");
 var import_errors = require("./errors");
@@ -64,6 +65,22 @@ function buildCreateDeployment() {
         message: "Options object must include a `token`"
       });
     }
+    if (clientOptions.manual) {
+      debug("Manual provisioning mode enabled");
+      if (!clientOptions.prebuilt) {
+        throw new import_errors.DeploymentError({
+          code: "invalid_options",
+          message: "The `manual` option requires `prebuilt` to be true"
+        });
+      }
+      deploymentOptions.build = deploymentOptions.build || {};
+      deploymentOptions.build.env = deploymentOptions.build.env || {};
+      deploymentOptions.build.env.VERCEL_MANUAL_PROVISIONING = "1";
+      deploymentOptions.version = 2;
+      debug("Creating deployment with manual provisioning...");
+      yield* (0, import_deploy.deploy)(/* @__PURE__ */ new Map(), clientOptions, deploymentOptions);
+      return;
+    }
     clientOptions.isDirectory = !Array.isArray(path) && (0, import_fs_extra.lstatSync)(path).isDirectory();
     if (Array.isArray(path)) {
       for (const filePath of path) {

package/dist/deploy.d.ts

@@ -1,6 +1,6 @@
 import { FilesMap } from './utils/hashes';
-import { DeploymentOptions, VercelClientOptions } from './types';
+import { DeploymentOptions, VercelClientOptions, DeploymentEventType } from './types';
 export declare function deploy(files: FilesMap, clientOptions: VercelClientOptions, deploymentOptions: DeploymentOptions): AsyncIterableIterator<{
-    type: string;
+    type: DeploymentEventType;
     payload: any;
 }>;

package/dist/deploy.js

@@ -110,14 +110,14 @@ function getDefaultName(files, clientOptions) {
 }
 async function* deploy(files, clientOptions, deploymentOptions) {
   const debug = (0, import_utils.createDebug)(clientOptions.debug);
-  if (!deploymentOptions.name) {
+  if (!deploymentOptions.name && files.size > 0) {
     deploymentOptions.version = 2;
     deploymentOptions.name = files.size === 1 ? "file" : getDefaultName(files, clientOptions);
     if (deploymentOptions.name === "file") {
       debug('Setting deployment name to "file" for single-file deployment');
     }
   }
-  if (!deploymentOptions.name) {
+  if (!deploymentOptions.name && files.size > 0) {
     deploymentOptions.name = clientOptions.defaultName || getDefaultName(files, clientOptions);
     debug("No name provided. Defaulting to", deploymentOptions.name);
   }
@@ -144,6 +144,10 @@ async function* deploy(files, clientOptions, deploymentOptions) {
     debug("An unexpected error occurred when creating the deployment");
     return yield { type: "error", payload: e };
   }
+  if (clientOptions.manual) {
+    debug("Manual mode - skipping ready state check");
+    return;
+  }
   if (deployment) {
     if ((0, import_ready_state.isReady)(deployment) && (0, import_ready_state.isAliasAssigned)(deployment)) {
       debug("Deployment state changed to READY 3");

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { continueDeployment } from './continue';
 export { checkDeploymentStatus } from './check-deployment-status';
 export { getVercelIgnore, buildFileTree } from './utils/index';
 export declare const createDeployment: (clientOptions: import("./types").VercelClientOptions, deploymentOptions?: import("./types").DeploymentOptions) => AsyncIterableIterator<{

package/dist/index.js

@@ -31,11 +31,13 @@ var src_exports = {};
 __export(src_exports, {
   buildFileTree: () => import_utils.buildFileTree,
   checkDeploymentStatus: () => import_check_deployment_status.checkDeploymentStatus,
+  continueDeployment: () => import_continue.continueDeployment,
   createDeployment: () => createDeployment,
   getVercelIgnore: () => import_utils.getVercelIgnore
 });
 module.exports = __toCommonJS(src_exports);
 var import_create_deployment = __toESM(require("./create-deployment"));
+var import_continue = require("./continue");
 var import_check_deployment_status = require("./check-deployment-status");
 var import_utils = require("./utils/index");
 __reExport(src_exports, require("./errors"), module.exports);
@@ -45,6 +47,7 @@ const createDeployment = (0, import_create_deployment.default)();
 0 && (module.exports = {
   buildFileTree,
   checkDeploymentStatus,
+  continueDeployment,
   createDeployment,
   getVercelIgnore,
   ...require("./errors"),

package/dist/types.d.ts

@@ -31,6 +31,11 @@ export interface VercelClientOptions {
      * This file will be included in prebuilt deployments.
      */
     bulkRedirectsPath?: string | null;
+    /**
+     * When true, creates an experimental manual deployment. This mode requires
+     * that the user later continues the deployment with an API call.
+     */
+    manual?: boolean;
 }
 /** @deprecated Use VercelClientOptions instead. */
 export type NowClientOptions = VercelClientOptions;

package/dist/upload.d.ts

@@ -1,3 +1,30 @@
-import { FilesMap } from './utils/hashes';
-import { VercelClientOptions, DeploymentOptions } from './types';
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+import { DeploymentFile, FilesMap } from './utils/hashes';
+import type { Agent } from 'http';
+import type { VercelClientOptions, DeploymentOptions, DeploymentEventType } from './types';
 export declare function upload(files: FilesMap, clientOptions: VercelClientOptions, deploymentOptions: DeploymentOptions): AsyncIterableIterator<any>;
+/**
+ * Uploads files to the /v2/files endpoint with retry and fault tolerance.
+ */
+export declare function uploadFiles(options: {
+    agent?: Agent;
+    apiUrl?: string;
+    debug?: boolean;
+    files: FilesMap;
+    shas: string[];
+    teamId?: string;
+    token: string;
+    uploads: UploadProgress[];
+    userAgent?: string;
+}): AsyncIterableIterator<{
+    type: DeploymentEventType;
+    payload: any;
+}>;
+export declare class UploadProgress extends EventEmitter {
+    sha: string;
+    file: DeploymentFile;
+    bytesUploaded: number;
+    constructor(sha: string, file: DeploymentFile);
+}

package/dist/upload.js

@@ -28,7 +28,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var upload_exports = {};
 __export(upload_exports, {
-  upload: () => upload
+  UploadProgress: () => UploadProgress,
+  upload: () => upload,
+  uploadFiles: () => uploadFiles
 });
 module.exports = __toCommonJS(upload_exports);
 var import_http = __toESM(require("http"));
@@ -47,9 +49,8 @@ const isClientNetworkError = (err) => {
   return false;
 };
 async function* upload(files, clientOptions, deploymentOptions) {
-  const { token, teamId, apiUrl, userAgent } = clientOptions;
   const debug = (0, import_utils.createDebug)(clientOptions.debug);
-  if (!files && !token && !teamId) {
+  if (!files && !clientOptions.token && !clientOptions.teamId) {
     debug(`Neither 'files', 'token' nor 'teamId are present. Exiting`);
     return;
   }
@@ -78,23 +79,60 @@ async function* upload(files, clientOptions, deploymentOptions) {
     type: "file-count",
     payload: { total: files, missing: shas, uploads }
   };
+  const uploadGenerator = uploadFiles({
+    agent: clientOptions.agent,
+    apiUrl: clientOptions.apiUrl,
+    debug: clientOptions.debug,
+    teamId: clientOptions.teamId,
+    token: clientOptions.token,
+    userAgent: clientOptions.userAgent,
+    files,
+    shas,
+    uploads
+  });
+  for await (const event of uploadGenerator) {
+    if (event.type === "error") {
+      return yield event;
+    } else {
+      yield event;
+    }
+  }
+  debug("All files uploaded");
+  yield { type: "all-files-uploaded", payload: files };
+  try {
+    debug("Starting deployment creation");
+    for await (const event of (0, import_deploy.deploy)(files, clientOptions, deploymentOptions)) {
+      if (event.type === "alias-assigned") {
+        debug("Deployment is ready");
+        return yield event;
+      }
+      yield event;
+    }
+  } catch (e) {
+    debug("An unexpected error occurred when starting deployment creation");
+    yield { type: "error", payload: e };
+  }
+}
+async function* uploadFiles(options) {
+  const debug = (0, import_utils.createDebug)(options.debug);
   const uploadList = {};
   debug("Building an upload list...");
   const semaphore = new import_async_sema.Sema(50, { capacity: 50 });
-  const defaultAgent = apiUrl?.startsWith("https://") ? new import_https.default.Agent({ keepAlive: true }) : new import_http.default.Agent({ keepAlive: true });
+  const defaultAgent = options.apiUrl?.startsWith("https://") ? new import_https.default.Agent({ keepAlive: true }) : new import_http.default.Agent({ keepAlive: true });
   const abortControllers = /* @__PURE__ */ new Set();
   let aborted = false;
-  shas.forEach((sha, index) => {
-    const uploadProgress = uploads[index];
+  options.shas.forEach((sha, index) => {
+    const uploadProgress = options.uploads[index];
     uploadList[sha] = (0, import_async_retry.default)(
       async (bail) => {
-        const file = files.get(sha);
+        const file = options.files.get(sha);
         if (!file) {
           debug(`File ${sha} is undefined. Bailing`);
           return bail(new Error(`File ${sha} is undefined`));
         }
         await semaphore.acquire();
         if (aborted) {
+          semaphore.release();
           return bail(new Error("Upload aborted"));
         }
         const { data } = file;
@@ -125,9 +163,9 @@ async function* upload(files, clientOptions, deploymentOptions) {
         try {
           const res = await (0, import_utils.fetch)(
             import_utils.API_FILES,
-            token,
+            options.token,
             {
-              agent: clientOptions.agent || defaultAgent,
+              agent: options.agent || defaultAgent,
               method: "POST",
               headers: {
                 "Content-Type": "application/octet-stream",
@@ -136,13 +174,13 @@ async function* upload(files, clientOptions, deploymentOptions) {
                 "x-now-size": data.length
               },
               body,
-              teamId,
-              apiUrl,
-              userAgent,
+              teamId: options.teamId,
+              apiUrl: options.apiUrl,
+              userAgent: options.userAgent,
               // @ts-expect-error: typescript is getting confused with the signal types from node (web & server) and node-fetch (server only)
               signal: abortController.signal
             },
-            clientOptions.debug
+            options.debug
           );
           if (res.status === 200) {
             debug(
@@ -202,21 +240,6 @@ ${e}`);
       return yield { type: "error", payload: e };
     }
   }
-  debug("All files uploaded");
-  yield { type: "all-files-uploaded", payload: files };
-  try {
-    debug("Starting deployment creation");
-    for await (const event of (0, import_deploy.deploy)(files, clientOptions, deploymentOptions)) {
-      if (event.type === "alias-assigned") {
-        debug("Deployment is ready");
-        return yield event;
-      }
-      yield event;
-    }
-  } catch (e) {
-    debug("An unexpected error occurred when starting deployment creation");
-    yield { type: "error", payload: e };
-  }
 }
 class UploadProgress extends import_node_events.EventEmitter {
   constructor(sha, file) {
@@ -228,5 +251,7 @@ class UploadProgress extends import_node_events.EventEmitter {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  upload
+  UploadProgress,
+  upload,
+  uploadFiles
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/client",
-  "version": "17.2.41",
+  "version": "17.2.42",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "homepage": "https://vercel.com",
@@ -42,9 +42,9 @@
     "querystring": "^0.2.0",
     "sleep-promise": "8.0.1",
     "tar-fs": "1.16.3",
-    "@vercel/routing-utils": "5.3.3",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/build-utils": "13.4.0"
+    "@vercel/build-utils": "13.4.0",
+    "@vercel/routing-utils": "5.3.3"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",