vercel 59.11.2 → 59.12.0

package/dist/chunks/chunk-RVBZ64EQ.js

@@ -0,0 +1,52 @@
+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_dist2 as require_dist
+} from "./chunk-332LMJLZ.js";
+import {
+  require_frameworks
+} from "./chunk-FRVG4OW3.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/projects/detect-projects.ts
+var import_frameworks = __toESM(require_frameworks(), 1);
+var import_fs_detectors = __toESM(require_dist(), 1);
+import { join } from "path";
+async function detectProjects(cwd) {
+  const fs = new import_fs_detectors.LocalFileSystemDetector(cwd);
+  const workspaces = await (0, import_fs_detectors.getWorkspaces)({ fs });
+  const detectedProjects = /* @__PURE__ */ new Map();
+  const packagePaths = (await Promise.all(
+    workspaces.map(
+      (workspace) => (0, import_fs_detectors.getWorkspacePackagePaths)({
+        fs,
+        workspace
+      })
+    )
+  )).flat();
+  if (packagePaths.length === 0) {
+    packagePaths.push("/");
+  }
+  await Promise.all(
+    packagePaths.map(async (p) => {
+      const frameworks = await (0, import_fs_detectors.detectFrameworks)({
+        fs: fs.chdir(join(".", p)),
+        frameworkList: import_frameworks.frameworkList
+      });
+      if (frameworks.length === 0)
+        return;
+      detectedProjects.set(p.slice(1), frameworks);
+    })
+  );
+  return detectedProjects;
+}
+
+export {
+  detectProjects
+};

package/dist/chunks/{chunk-WA2SJE5S.js → chunk-SWO66HE2.js}

@@ -4,12 +4,12 @@ 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_lib
-} from "./chunk-WYU64FLP.js";
 import {
   isNativeBinaryInstall
-} from "./chunk-XNFHNTS2.js";
+} from "./chunk-4IALDGB7.js";
+import {
+  require_lib
+} from "./chunk-MADFAH3O.js";
 import {
   packageName
 } from "./chunk-Q2DGFCO7.js";

package/dist/chunks/{chunk-NBW3BWOJ.js → chunk-TDGK45FB.js}

@@ -8,10 +8,10 @@ import {
   VERCEL_DIR,
   VERCEL_DIR_PROJECT,
   require_lib
-} from "./chunk-WYU64FLP.js";
+} from "./chunk-MADFAH3O.js";
 import {
   require_dist
-} from "./chunk-QFAS4OVW.js";
+} from "./chunk-ZW6HETRE.js";
 import {
   __toESM
 } from "./chunk-TZ2YI2VH.js";

package/dist/chunks/{chunk-WNAKOXGK.js → chunk-TO7QZGYK.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   require_isexe
-} from "./chunk-5XECIWME.js";
+} from "./chunk-5NF5HOBJ.js";
 import {
   __commonJS,
   __require

package/dist/chunks/{chunk-QDV5LZ4Q.js → chunk-UA55I7M6.js}

@@ -7,25 +7,29 @@ const __dirname = __dirname_(__filename);
 import {
   outputError,
   writeJsonError
-} from "./chunk-3T7WSWZH.js";
+} from "./chunk-KFWQ3EFH.js";
 import {
-  detectExplicitScope,
-  getLinkedProject,
-  getScope,
   resolveProjectContext
-} from "./chunk-WYU64FLP.js";
+} from "./chunk-X6TGUHFD.js";
+import {
+  detectExplicitScope,
+  getScope
+} from "./chunk-ABSZNJQO.js";
 import {
   printError
-} from "./chunk-AYLY3ZVL.js";
+} from "./chunk-3VM7HWF6.js";
+import {
+  getLinkedProject
+} from "./chunk-MADFAH3O.js";
 import {
   isAPIError
-} from "./chunk-BMKU5KEL.js";
+} from "./chunk-CV5YC2EN.js";
 import {
   getCommandName
 } from "./chunk-Q2DGFCO7.js";
 import {
   output_manager_default
-} from "./chunk-QFAS4OVW.js";
+} from "./chunk-2JIX6UMI.js";
 
 // src/commands/comments/errors.ts
 function handleCommentsParseError(err, subcommandName) {

package/dist/chunks/{chunk-FWKSJYDV.js → chunk-UG2WOB5L.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   getEnvTargetPlaceholder
-} from "./chunk-FXD67VN5.js";
+} from "./chunk-XUAWTW4W.js";
 import {
   packageName,
   projectOption,

package/dist/chunks/chunk-UJPVHLL5.js

@@ -0,0 +1,233 @@
+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_dist as require_dist2,
+  validateConfig
+} from "./chunk-VJSREJVM.js";
+import {
+  require_dist2 as require_dist
+} from "./chunk-332LMJLZ.js";
+import {
+  readJSONFile
+} from "./chunk-32XSMM3W.js";
+import {
+  compileVercelConfig
+} from "./chunk-YPMFZRTN.js";
+import {
+  CantParseJSONFile
+} from "./chunk-CV5YC2EN.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/projects/detect-services.ts
+var import_fs_detectors = __toESM(require_dist(), 1);
+var import_service_topology = __toESM(require_dist2(), 1);
+import { readFile, writeFile } from "fs/promises";
+import { basename, join as join2 } from "path";
+import { parse as tomlParse, stringify as tomlStringify } from "smol-toml";
+
+// src/util/projects/detect-entrypoint.ts
+import { join } from "path";
+import {
+  isPythonFramework,
+  isNodeBackendFramework,
+  normalizePath
+} from "@vercel/build-utils";
+function createDetectEntrypoint(projectRoot) {
+  return async ({ workPath, framework }) => {
+    const absWorkPath = normalizePath(join(projectRoot, workPath));
+    let builderName;
+    if (isPythonFramework(framework)) {
+      builderName = "@vercel/python";
+    } else if (isNodeBackendFramework(framework)) {
+      builderName = "@vercel/backends";
+    } else if (framework === "go") {
+      builderName = "@vercel/go";
+    } else if (framework === "rust") {
+      builderName = "@vercel/rust";
+    } else {
+      return null;
+    }
+    const detectEntrypoint = await loadBuilderDetectEntrypoint(
+      builderName,
+      projectRoot
+    );
+    if (!detectEntrypoint) {
+      return null;
+    }
+    if (builderName === "@vercel/python") {
+      return detectEntrypoint({
+        workPath: absWorkPath,
+        framework
+      });
+    }
+    return detectEntrypoint({ workPath: absWorkPath });
+  };
+}
+async function loadBuilderDetectEntrypoint(name, projectRoot) {
+  const { importBuilders } = await import("./import-builders-FNMYJZGG.js");
+  const builders = await importBuilders(/* @__PURE__ */ new Set([name]), projectRoot);
+  const loaded = builders.get(name);
+  if (!loaded) {
+    return void 0;
+  }
+  const detect = loaded.builder.detectEntrypoint;
+  return typeof detect === "function" ? detect : void 0;
+}
+
+// src/util/projects/detect-services.ts
+async function isExperimentalServicesEnabled(cwd) {
+  return process.env.VERCEL_USE_EXPERIMENTAL_SERVICES === "1" || process.env.VERCEL_USE_EXPERIMENTAL_SERVICES?.toLowerCase() === "true" || await hasExperimentalServicesConfig(cwd);
+}
+async function hasExperimentalServicesConfig(cwd) {
+  try {
+    const compileResult = await compileVercelConfig(cwd);
+    if (!compileResult.configPath)
+      return false;
+    const config = await readJSONFile(
+      compileResult.configPath
+    );
+    if (!config || config instanceof Error)
+      return false;
+    return config.experimentalServices != null && typeof config.experimentalServices === "object" || config.services != null && typeof config.services === "object" || config.experimentalServicesV2 != null && typeof config.experimentalServicesV2 === "object";
+  } catch {
+    return false;
+  }
+}
+async function tryDetectServices(cwd) {
+  const isServicesEnabled = await isExperimentalServicesEnabled(cwd);
+  if (!isServicesEnabled) {
+    return null;
+  }
+  const fs = new import_fs_detectors.LocalFileSystemDetector(cwd);
+  const result = await (0, import_service_topology.detectServices)({
+    fs,
+    detectEntrypoint: createDetectEntrypoint(cwd)
+  });
+  const hasNoServicesError = result.errors.some(
+    (e) => e.code === "NO_SERVICES_CONFIGURED"
+  );
+  if (hasNoServicesError) {
+    return null;
+  }
+  return result;
+}
+async function writeServicesConfig(cwd, config) {
+  const prepared = await prepareServicesConfigWrite(cwd, config);
+  await writeFile(prepared.configPath, prepared.content, "utf8");
+  return { configFileName: basename(prepared.configPath) };
+}
+async function getServicesConfigWriteBlocker(cwd, config) {
+  try {
+    await prepareServicesConfigWrite(cwd, config);
+    return null;
+  } catch (error) {
+    return getServicesConfigWriteBlockerFromError(error);
+  }
+}
+function toProjectServicesConfigPatch(config) {
+  const services = {};
+  for (const [name, svc] of Object.entries(config)) {
+    const buildCommand = svc.preDeployCommand && svc.buildCommand ? `${svc.buildCommand} && ${svc.preDeployCommand}` : svc.preDeployCommand || svc.buildCommand;
+    services[name] = {
+      root: svc.root,
+      ...svc.framework ? { framework: svc.framework } : {},
+      ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {},
+      ...buildCommand ? { buildCommand } : {}
+    };
+  }
+  const rewrites = (0, import_service_topology.generateServiceRewrites)(config);
+  return {
+    services,
+    ...rewrites.length > 0 ? { rewrites } : {}
+  };
+}
+async function prepareServicesConfigWrite(cwd, config) {
+  const compileResult = await compileVercelConfig(cwd);
+  const configPath = join2(cwd, "vercel.json");
+  if (compileResult.sourceFile === "vercel.toml") {
+    return prepareTomlServicesConfigWrite(join2(cwd, "vercel.toml"), config);
+  }
+  if (compileResult.wasCompiled) {
+    throw new Error(
+      `Cannot automatically update ${compileResult.sourceFile ?? "the current Vercel config"}.`
+    );
+  }
+  let existingConfig = {};
+  if (compileResult.configPath && basename(compileResult.configPath) === "vercel.json") {
+    const result = await readJSONFile(configPath);
+    if (result instanceof CantParseJSONFile) {
+      throw result;
+    }
+    existingConfig = result ?? {};
+  }
+  const patch = toProjectServicesConfigPatch(config);
+  const nextConfig = {
+    ...existingConfig,
+    ...patch,
+    // Preserve existing user rewrites; append auto-detected service rewrites.
+    ...patch.rewrites ? {
+      rewrites: [
+        ...existingConfig.rewrites ?? [],
+        ...patch.rewrites
+      ]
+    } : {}
+  };
+  const validationError = validateConfig(nextConfig);
+  if (validationError) {
+    throw validationError;
+  }
+  return {
+    configPath,
+    content: JSON.stringify(nextConfig, null, 2) + "\n"
+  };
+}
+async function prepareTomlServicesConfigWrite(configPath, config) {
+  const patch = toProjectServicesConfigPatch(config);
+  const patchKeys = Object.keys(patch);
+  let existingContent;
+  try {
+    existingContent = await readFile(configPath, "utf8");
+  } catch {
+    existingContent = "";
+  }
+  if (existingContent.trim()) {
+    const existingParsed = tomlParse(existingContent);
+    const overlapping = patchKeys.filter((key) => key in existingParsed);
+    if (overlapping.length > 0) {
+      const plural = overlapping.length > 1;
+      const keyList = overlapping.map((k) => `"${k}"`).join(", ");
+      throw new Error(
+        `Cannot automatically update vercel.toml: key${plural ? "s" : ""} ${keyList} already exist${plural ? "" : "s"}.`
+      );
+    }
+  }
+  const patchToml = tomlStringify(patch);
+  const content = existingContent.trim() ? existingContent.trimEnd() + "\n\n" + patchToml + "\n" : patchToml + "\n";
+  return { configPath, content };
+}
+function getServicesConfigWriteBlockerFromError(error) {
+  switch (error?.code) {
+    case "EXPERIMENTAL_SERVICES_AND_BUILDS":
+    case "SERVICES_AND_BUILDS":
+      return "builds";
+    case "EXPERIMENTAL_SERVICES_AND_FUNCTIONS":
+    case "SERVICES_AND_FUNCTIONS":
+      return "functions";
+    default:
+      return null;
+  }
+}
+
+export {
+  createDetectEntrypoint,
+  isExperimentalServicesEnabled,
+  tryDetectServices,
+  writeServicesConfig,
+  getServicesConfigWriteBlocker
+};

package/dist/chunks/chunk-V4RMJKQP.js

@@ -0,0 +1,36 @@
+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);
+
+// src/util/input/prompt-cancellation.ts
+var PromptCanceledError = class extends Error {
+  constructor() {
+    super("Prompt canceled");
+    this.name = "PromptCanceledError";
+  }
+};
+var PromptBackError = class extends Error {
+  constructor() {
+    super("Prompt back");
+    this.name = "PromptBackError";
+  }
+};
+function isPromptBackError(error) {
+  return error instanceof PromptBackError;
+}
+function isPromptCanceledError(error) {
+  if (error instanceof PromptCanceledError) {
+    return true;
+  }
+  return error instanceof Error && error.message.includes("User force closed the prompt");
+}
+
+export {
+  PromptCanceledError,
+  PromptBackError,
+  isPromptBackError,
+  isPromptCanceledError
+};