vercel 59.11.2 → 59.12.0

package/dist/chunks/chunk-HRXRELD3.js

@@ -0,0 +1,338 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  __commonJS,
+  __require
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js
+var require_is_docker = __commonJS({
+  "../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var isDocker;
+    function hasDockerEnv() {
+      try {
+        fs.statSync("/.dockerenv");
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }
+    function hasDockerCGroup() {
+      try {
+        return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+      } catch (_) {
+        return false;
+      }
+    }
+    module.exports = () => {
+      if (isDocker === void 0) {
+        isDocker = hasDockerEnv() || hasDockerCGroup();
+      }
+      return isDocker;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js
+var require_is_wsl = __commonJS({
+  "../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js"(exports, module) {
+    "use strict";
+    var os = __require("os");
+    var fs = __require("fs");
+    var isDocker = require_is_docker();
+    var isWsl = () => {
+      if (process.platform !== "linux") {
+        return false;
+      }
+      if (os.release().toLowerCase().includes("microsoft")) {
+        if (isDocker()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isDocker() : false;
+      } catch (_) {
+        return false;
+      }
+    };
+    if (process.env.__IS_WSL_TEST__) {
+      module.exports = isWsl;
+    } else {
+      module.exports = isWsl();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/define-lazy-prop@2.0.0/node_modules/define-lazy-prop/index.js
+var require_define_lazy_prop = __commonJS({
+  "../../node_modules/.pnpm/define-lazy-prop@2.0.0/node_modules/define-lazy-prop/index.js"(exports, module) {
+    "use strict";
+    module.exports = (object, propertyName, fn) => {
+      const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+      Object.defineProperty(object, propertyName, {
+        configurable: true,
+        enumerable: true,
+        get() {
+          const result = fn();
+          define(result);
+          return result;
+        },
+        set(value) {
+          define(value);
+        }
+      });
+      return object;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/open@8.4.0/node_modules/open/index.js
+var require_open = __commonJS({
+  "../../node_modules/.pnpm/open@8.4.0/node_modules/open/index.js"(exports, module) {
+    var path = __require("path");
+    var childProcess = __require("child_process");
+    var { promises: fs, constants: fsConstants } = __require("fs");
+    var isWsl = require_is_wsl();
+    var isDocker = require_is_docker();
+    var defineLazyProperty = require_define_lazy_prop();
+    var localXdgOpenPath = path.join(__dirname, "xdg-open");
+    var { platform, arch } = process;
+    var getWslDrivesMountPoint = (() => {
+      const defaultMountPoint = "/mnt/";
+      let mountPoint;
+      return async function() {
+        if (mountPoint) {
+          return mountPoint;
+        }
+        const configFilePath = "/etc/wsl.conf";
+        let isConfigFileExists = false;
+        try {
+          await fs.access(configFilePath, fsConstants.F_OK);
+          isConfigFileExists = true;
+        } catch {
+        }
+        if (!isConfigFileExists) {
+          return defaultMountPoint;
+        }
+        const configContent = await fs.readFile(configFilePath, { encoding: "utf8" });
+        const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+        if (!configMountPoint) {
+          return defaultMountPoint;
+        }
+        mountPoint = configMountPoint.groups.mountPoint.trim();
+        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+        return mountPoint;
+      };
+    })();
+    var pTryEach = async (array, mapper) => {
+      let latestError;
+      for (const item of array) {
+        try {
+          return await mapper(item);
+        } catch (error) {
+          latestError = error;
+        }
+      }
+      throw latestError;
+    };
+    var baseOpen = async (options) => {
+      options = {
+        wait: false,
+        background: false,
+        newInstance: false,
+        allowNonzeroExitCode: false,
+        ...options
+      };
+      if (Array.isArray(options.app)) {
+        return pTryEach(options.app, (singleApp) => baseOpen({
+          ...options,
+          app: singleApp
+        }));
+      }
+      let { name: app, arguments: appArguments = [] } = options.app || {};
+      appArguments = [...appArguments];
+      if (Array.isArray(app)) {
+        return pTryEach(app, (appName) => baseOpen({
+          ...options,
+          app: {
+            name: appName,
+            arguments: appArguments
+          }
+        }));
+      }
+      let command;
+      const cliArguments = [];
+      const childProcessOptions = {};
+      if (platform === "darwin") {
+        command = "open";
+        if (options.wait) {
+          cliArguments.push("--wait-apps");
+        }
+        if (options.background) {
+          cliArguments.push("--background");
+        }
+        if (options.newInstance) {
+          cliArguments.push("--new");
+        }
+        if (app) {
+          cliArguments.push("-a", app);
+        }
+      } else if (platform === "win32" || isWsl && !isDocker()) {
+        const mountPoint = await getWslDrivesMountPoint();
+        command = isWsl ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process.env.SYSTEMROOT}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+        cliArguments.push(
+          "-NoProfile",
+          "-NonInteractive",
+          "\u2013ExecutionPolicy",
+          "Bypass",
+          "-EncodedCommand"
+        );
+        if (!isWsl) {
+          childProcessOptions.windowsVerbatimArguments = true;
+        }
+        const encodedArguments = ["Start"];
+        if (options.wait) {
+          encodedArguments.push("-Wait");
+        }
+        if (app) {
+          encodedArguments.push(`"\`"${app}\`""`, "-ArgumentList");
+          if (options.target) {
+            appArguments.unshift(options.target);
+          }
+        } else if (options.target) {
+          encodedArguments.push(`"${options.target}"`);
+        }
+        if (appArguments.length > 0) {
+          appArguments = appArguments.map((arg) => `"\`"${arg}\`""`);
+          encodedArguments.push(appArguments.join(","));
+        }
+        options.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+      } else {
+        if (app) {
+          command = app;
+        } else {
+          const isBundled = !__dirname || __dirname === "/";
+          let exeLocalXdgOpen = false;
+          try {
+            await fs.access(localXdgOpenPath, fsConstants.X_OK);
+            exeLocalXdgOpen = true;
+          } catch {
+          }
+          const useSystemXdgOpen = process.versions.electron || platform === "android" || isBundled || !exeLocalXdgOpen;
+          command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+        }
+        if (appArguments.length > 0) {
+          cliArguments.push(...appArguments);
+        }
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+          childProcessOptions.detached = true;
+        }
+      }
+      if (options.target) {
+        cliArguments.push(options.target);
+      }
+      if (platform === "darwin" && appArguments.length > 0) {
+        cliArguments.push("--args", ...appArguments);
+      }
+      const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+      if (options.wait) {
+        return new Promise((resolve, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("close", (exitCode) => {
+            if (options.allowNonzeroExitCode && exitCode > 0) {
+              reject(new Error(`Exited with code ${exitCode}`));
+              return;
+            }
+            resolve(subprocess);
+          });
+        });
+      }
+      subprocess.unref();
+      return subprocess;
+    };
+    var open = (target, options) => {
+      if (typeof target !== "string") {
+        throw new TypeError("Expected a `target`");
+      }
+      return baseOpen({
+        ...options,
+        target
+      });
+    };
+    var openApp = (name, options) => {
+      if (typeof name !== "string") {
+        throw new TypeError("Expected a `name`");
+      }
+      const { arguments: appArguments = [] } = options || {};
+      if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
+        throw new TypeError("Expected `appArguments` as Array type");
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name,
+          arguments: appArguments
+        }
+      });
+    };
+    function detectArchBinary(binary) {
+      if (typeof binary === "string" || Array.isArray(binary)) {
+        return binary;
+      }
+      const { [arch]: archBinary } = binary;
+      if (!archBinary) {
+        throw new Error(`${arch} is not supported`);
+      }
+      return archBinary;
+    }
+    function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+      if (wsl && isWsl) {
+        return detectArchBinary(wsl);
+      }
+      if (!platformBinary) {
+        throw new Error(`${platform} is not supported`);
+      }
+      return detectArchBinary(platformBinary);
+    }
+    var apps = {};
+    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+      darwin: "google chrome",
+      win32: "chrome",
+      linux: ["google-chrome", "google-chrome-stable", "chromium"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+        x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+      darwin: "firefox",
+      win32: "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
+      linux: "firefox"
+    }, {
+      wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+    }));
+    defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+      darwin: "microsoft edge",
+      win32: "msedge",
+      linux: ["microsoft-edge", "microsoft-edge-dev"]
+    }, {
+      wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+    }));
+    open.apps = apps;
+    open.openApp = openApp;
+    module.exports = open;
+  }
+});
+
+export {
+  require_open
+};

package/dist/chunks/{chunk-IJ4X426J.js → chunk-IIMSID24.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-2473DUBR.js";
 import {
   outputError
-} from "./chunk-3T7WSWZH.js";
+} from "./chunk-KFWQ3EFH.js";
 
 // src/commands/comments/content.ts
 import { readFileSync } from "fs";

package/dist/chunks/{chunk-B4TXCKXE.js → chunk-JOXNBQ7W.js}

@@ -6,20 +6,22 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   resolveProjectContext
-} from "./chunk-WYU64FLP.js";
+} from "./chunk-X6TGUHFD.js";
 import {
   AGENT_REASON,
-  AGENT_STATUS,
-  buildCommandWithYes,
-  outputAgentError,
-  withGlobalFlags
-} from "./chunk-NGGLYKNU.js";
+  AGENT_STATUS
+} from "./chunk-VUS2JQB2.js";
 import {
   printError
-} from "./chunk-AYLY3ZVL.js";
+} from "./chunk-3VM7HWF6.js";
 import {
   parseArguments
 } from "./chunk-57RHXXXG.js";
+import {
+  buildCommandWithYes,
+  outputAgentError,
+  withGlobalFlags
+} from "./chunk-26CU4Q3C.js";
 import {
   getCommandName,
   getCommandNamePlain,
@@ -28,7 +30,7 @@ import {
 } from "./chunk-Q2DGFCO7.js";
 import {
   output_manager_default
-} from "./chunk-QFAS4OVW.js";
+} from "./chunk-2JIX6UMI.js";
 import {
   require_source
 } from "./chunk-S7KYDPEM.js";

package/dist/chunks/{chunk-O75LSD3C.js → chunk-JSD4EZL3.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-Q2DGFCO7.js";
 import {
   output_manager_default
-} from "./chunk-QFAS4OVW.js";
+} from "./chunk-2JIX6UMI.js";
 import {
   require_source
 } from "./chunk-S7KYDPEM.js";

package/dist/chunks/{chunk-7AEEQOD4.js → chunk-K3RED3VO.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   output_manager_default
-} from "./chunk-QFAS4OVW.js";
+} from "./chunk-2JIX6UMI.js";
 
 // src/util/agent/auto-install-agentic.ts
 import { readFile, writeFile } from "fs/promises";

package/dist/chunks/chunk-KAF4WFF3.js

@@ -0,0 +1,257 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  require_open
+} from "./chunk-HRXRELD3.js";
+import {
+  deviceAccessTokenRequest,
+  deviceAuthorizationRequest,
+  isOAuthError,
+  processDeviceAuthorizationResponse,
+  processTokenResponse
+} from "./chunk-ABSZNJQO.js";
+import {
+  printError
+} from "./chunk-3VM7HWF6.js";
+import {
+  getTeams,
+  getUser,
+  humanizePath
+} from "./chunk-MADFAH3O.js";
+import {
+  getCommandName
+} from "./chunk-Q2DGFCO7.js";
+import {
+  emoji,
+  output_manager_default,
+  require_ansi_escapes
+} from "./chunk-2JIX6UMI.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/login/future.ts
+var import_chalk = __toESM(require_source(), 1);
+var open = __toESM(require_open(), 1);
+var import_ansi_escapes = __toESM(require_ansi_escapes(), 1);
+import readline from "readline";
+import { KNOWN_AGENTS } from "@vercel/detect-agent";
+
+// src/util/login/update-current-team-after-login.ts
+async function updateCurrentTeamAfterLogin(client, ssoTeamId) {
+  if (ssoTeamId) {
+    client.config.currentTeam = ssoTeamId;
+  } else {
+    let user = null;
+    try {
+      user = await getUser(client);
+    } catch (_err) {
+      output_manager_default.error("Failed to fetch the logged in user. Please try again.");
+      return 1;
+    }
+    if (user.version === "northstar" && user.defaultTeamId) {
+      client.config.currentTeam = user.defaultTeamId;
+    } else {
+      delete client.config.currentTeam;
+    }
+  }
+}
+
+// src/commands/login/future.ts
+async function performDeviceCodeFlow(client, options) {
+  const deviceAuthorizationResponse = await deviceAuthorizationRequest({
+    refresh_token: options?.refreshToken,
+    acr_values: options?.acrValues
+  });
+  output_manager_default.debug(
+    `'Device Authorization response:', ${await deviceAuthorizationResponse.clone().text()}`
+  );
+  const [deviceAuthorizationError, deviceAuthorization] = await processDeviceAuthorizationResponse(deviceAuthorizationResponse);
+  if (deviceAuthorizationError) {
+    if (options?.fallbackToLoginOnStepUpFailure && options.refreshToken && isOAuthError(deviceAuthorizationError) && (deviceAuthorizationError.code === "invalid_grant" || deviceAuthorizationError.code === "invalid_scope")) {
+      output_manager_default.debug(
+        `Step-up device authorization failed: ${deviceAuthorizationError.cause.message}`
+      );
+      output_manager_default.log("Couldn't refresh the saved login. Starting a new login.");
+      return performDeviceCodeFlow(
+        client,
+        options.teamId ? { teamId: options.teamId } : void 0
+      );
+    }
+    printError(
+      isOAuthError(deviceAuthorizationError) ? deviceAuthorizationError.cause : deviceAuthorizationError
+    );
+    return null;
+  }
+  const { device_code, user_code, verification_uri, expiresAt, interval } = deviceAuthorization;
+  let { verification_uri_complete } = deviceAuthorization;
+  if (options?.teamId) {
+    const url = new URL(verification_uri_complete);
+    url.searchParams.set("team_id", options.teamId);
+    verification_uri_complete = url.toString();
+  }
+  const isCursorAgent = client.agentName === KNOWN_AGENTS.CURSOR || client.agentName === KNOWN_AGENTS.CURSOR_CLI;
+  const shouldSkipBrowser = process.env.CI && !isCursorAgent;
+  output_manager_default.log(
+    `
+  Visit ${import_chalk.default.bold(
+      output_manager_default.link(
+        verification_uri.replace("https://", ""),
+        verification_uri_complete,
+        { color: false, fallback: () => verification_uri_complete }
+      )
+    )}${output_manager_default.supportsHyperlink ? ` and enter ${import_chalk.default.bold(user_code)}` : ""}
+`
+  );
+  if (!shouldSkipBrowser) {
+    try {
+      const browserProcess = await open.default(verification_uri_complete);
+      browserProcess.on("error", (error) => {
+        output_manager_default.debug(`Failed to open browser: ${error}`);
+      });
+    } catch (error) {
+      output_manager_default.debug(`Failed to open browser: ${error}`);
+      if (client.isAgent && client.nonInteractive) {
+        output_manager_default.log(
+          `
+${import_chalk.default.yellow("\u26A0")} ${import_chalk.default.bold("Browser could not be opened automatically.")}
+`
+        );
+        output_manager_default.log(
+          `Please ask the user to manually visit the URL above and complete the authentication process.
+`
+        );
+      }
+    }
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  }).on("SIGINT", () => {
+    process.exit(0);
+  });
+  output_manager_default.spinner("Waiting for authentication...");
+  let intervalMs = interval * 1e3;
+  let result = null;
+  let flowError = new Error(
+    "Timed out waiting for authentication. Please try again."
+  );
+  async function pollForToken() {
+    while (Date.now() < expiresAt) {
+      const [tokenResponseError, tokenResponse] = await deviceAccessTokenRequest({ device_code });
+      if (tokenResponseError) {
+        if (tokenResponseError.message.includes("timeout")) {
+          intervalMs *= 2;
+          output_manager_default.debug(
+            `Connection timeout. Slowing down, polling every ${intervalMs / 1e3}s...`
+          );
+          await wait(intervalMs);
+          continue;
+        }
+        return tokenResponseError;
+      }
+      output_manager_default.debug(
+        `'Device Access Token response:', ${await tokenResponse.clone().text()}`
+      );
+      const [tokensError, tokens] = await processTokenResponse(tokenResponse);
+      if (isOAuthError(tokensError)) {
+        const { code } = tokensError;
+        switch (code) {
+          case "authorization_pending":
+            await wait(intervalMs);
+            continue;
+          case "slow_down":
+            intervalMs += 5 * 1e3;
+            output_manager_default.debug(
+              `Authorization server requests to slow down. Polling every ${intervalMs / 1e3}s...`
+            );
+            await wait(intervalMs);
+            continue;
+          default:
+            return tokensError.cause;
+        }
+      }
+      if (tokensError)
+        return tokensError;
+      output_manager_default.print((0, import_ansi_escapes.eraseLines)(2));
+      result = {
+        access_token: tokens.access_token,
+        expires_in: tokens.expires_in,
+        refresh_token: tokens.refresh_token
+      };
+      return;
+    }
+  }
+  flowError = await pollForToken();
+  output_manager_default.stopSpinner();
+  rl.close();
+  if (flowError) {
+    printError(flowError);
+    return null;
+  }
+  return result;
+}
+async function login(client, telemetry, standalone = true) {
+  const tokens = await performDeviceCodeFlow(client);
+  if (!tokens) {
+    telemetry.trackState("error");
+    return 1;
+  }
+  const previousTeamId = client.config.currentTeam;
+  client.updateAuthConfig({
+    token: tokens.access_token,
+    userId: void 0,
+    expiresAt: Math.floor(Date.now() / 1e3) + tokens.expires_in,
+    refreshToken: tokens.refresh_token
+  });
+  if (previousTeamId) {
+    let isMember = true;
+    try {
+      const teams = await getTeams(client);
+      isMember = teams.some((team) => team.id === previousTeamId);
+    } catch {
+    }
+    if (!isMember) {
+      output_manager_default.warn(
+        "Your previously selected team is no longer accessible; switching to your default scope."
+      );
+      client.updateConfig({ currentTeam: void 0 });
+      await updateCurrentTeamAfterLogin(client);
+    }
+  } else {
+    client.updateConfig({ currentTeam: void 0 });
+    await updateCurrentTeamAfterLogin(client);
+  }
+  client.persistAuthConfig();
+  client.writeToConfigFile();
+  output_manager_default.debug(`Saved credentials in "${humanizePath(client.getGlobalPathConfig())}"`);
+  if (standalone) {
+    output_manager_default.print(`
+  ${import_chalk.default.cyan("Congratulations!")} You are now signed in.
+
+  To deploy something, run ${getCommandName()}.
+
+  ${emoji("tip")} To deploy every commit automatically,
+  connect a Git Repository (${import_chalk.default.bold(output_manager_default.link("vercel.link/git", "https://vercel.link/git", { color: false }))}).
+`);
+  } else {
+    output_manager_default.success("Logged in.");
+  }
+  telemetry.trackState("success");
+  return 0;
+}
+async function wait(intervalMs) {
+  await new Promise((resolve) => setTimeout(resolve, intervalMs));
+}
+
+export {
+  performDeviceCodeFlow,
+  login
+};

package/dist/chunks/{chunk-3T7WSWZH.js → chunk-KFWQ3EFH.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-GGP5R3FU.js";
 import {
   output_manager_default
-} from "./chunk-QFAS4OVW.js";
+} from "./chunk-2JIX6UMI.js";
 import {
   __toESM
 } from "./chunk-TZ2YI2VH.js";

package/dist/chunks/{chunk-6CZZ3SH3.js → chunk-KNO327AW.js}

@@ -8,10 +8,10 @@ import {
   formatCondition,
   formatTransform,
   isTargetTransform
-} from "./chunk-B4TXCKXE.js";
+} from "./chunk-JOXNBQ7W.js";
 import {
   output_manager_default
-} from "./chunk-QFAS4OVW.js";
+} from "./chunk-2JIX6UMI.js";
 import {
   require_source
 } from "./chunk-S7KYDPEM.js";

package/dist/chunks/{chunk-L3UXB2CW.js → chunk-KW7BS25T.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   TelemetryClient
-} from "./chunk-XNFHNTS2.js";
+} from "./chunk-HB4UKFDO.js";
 
 // src/util/telemetry/commands/routes/index.ts
 var RoutesTelemetryClient = class extends TelemetryClient {