vercel 59.11.2 → 59.12.0

package/dist/chunks/update-X6JB3NPI.js

@@ -0,0 +1,224 @@
+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 {
+  printRuleMutationReceipt
+} from "./chunk-2NIDTSQJ.js";
+import "./chunk-GDOUDU6O.js";
+import {
+  emitRulesArgParseError,
+  fetchRule,
+  handleRulesApiError,
+  outputRulesError,
+  readRuleBody,
+  resolveRulesProject,
+  resolveRulesTeam,
+  rulesItemPath
+} from "./chunk-HR2MP4XF.js";
+import "./chunk-3BB2HOO2.js";
+import "./chunk-GZLPFESR.js";
+import "./chunk-A3NYPUKZ.js";
+import "./chunk-KFWQ3EFH.js";
+import "./chunk-FGDKMNEN.js";
+import "./chunk-PRWJUY5U.js";
+import "./chunk-WT2Y7FRD.js";
+import "./chunk-AINIBIP4.js";
+import "./chunk-QB2UHSUB.js";
+import "./chunk-ND5CF2H3.js";
+import {
+  validateJsonOutput
+} from "./chunk-KXDWXXJH.js";
+import "./chunk-V4RMJKQP.js";
+import {
+  rulesUpdateSubcommand
+} from "./chunk-EDMW7SBH.js";
+import "./chunk-WT6C2ALC.js";
+import "./chunk-P7VSBDR4.js";
+import "./chunk-YPMFZRTN.js";
+import "./chunk-ZDU2NODC.js";
+import "./chunk-PEC3CQSK.js";
+import "./chunk-GGP5R3FU.js";
+import "./chunk-VUS2JQB2.js";
+import "./chunk-KAF4WFF3.js";
+import "./chunk-HRXRELD3.js";
+import "./chunk-B5XLQKHI.js";
+import "./chunk-ABSZNJQO.js";
+import "./chunk-XNIZGCN5.js";
+import "./chunk-NW34PW6V.js";
+import {
+  printError
+} from "./chunk-3VM7HWF6.js";
+import {
+  parseArguments
+} from "./chunk-57RHXXXG.js";
+import "./chunk-MADFAH3O.js";
+import "./chunk-G5FBSUL4.js";
+import "./chunk-26CU4Q3C.js";
+import "./chunk-XPJLPUKO.js";
+import {
+  isAPIError
+} from "./chunk-CV5YC2EN.js";
+import {
+  getFlagsSpecification,
+  packageName
+} from "./chunk-Q2DGFCO7.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+import "./chunk-P4QNYOFB.js";
+import "./chunk-ZW6HETRE.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/update.ts
+function sameScope(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function scopeForRule(client, type, scope, flags, jsonOutput) {
+  if (flags["--project"]) {
+    return type === "custom" ? { type: "project", projectId: scope.projectId } : { type: "include", projectIds: [scope.projectId] };
+  }
+  if (type === "custom") {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "INVALID_SCOPE",
+      "Custom alert rules must target one project. Use --project <name-or-id>."
+    );
+  }
+  return { type: "all" };
+}
+async function resolveUpdateScope(client, flags, jsonOutput, ruleId) {
+  if (flags["--project"] && flags["--all"]) {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "MUTUAL_EXCLUSIVITY",
+      "Cannot specify both --all and --project. Use one or the other."
+    );
+  }
+  return flags["--project"] ? resolveRulesProject(
+    client,
+    flags["--project"],
+    jsonOutput,
+    `alerts rules update ${ruleId}`
+  ) : resolveRulesTeam(client, jsonOutput);
+}
+function writeRuleResult(client, jsonOutput, action, rule) {
+  if (jsonOutput) {
+    client.stdout.write(`${JSON.stringify({ rule }, null, 2)}
+`);
+  } else {
+    printRuleMutationReceipt(action, rule, client.argv);
+  }
+}
+async function update(client, argv) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(rulesUpdateSubcommand.options)
+    );
+  } catch (error) {
+    emitRulesArgParseError(
+      client,
+      error,
+      "alerts rules update <rule-id> --project <name-or-id>"
+    );
+    printError(error);
+    return 1;
+  }
+  const flags = parsedArgs.flags;
+  const format = validateJsonOutput(flags);
+  if (!format.valid) {
+    return outputRulesError(client, false, "INVALID_ARGUMENTS", format.error);
+  }
+  const ruleId = parsedArgs.args[0];
+  if (!ruleId) {
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "MISSING_ARGUMENTS",
+      `Missing rule ID. Example: ${packageName} alerts rules update <rule-id> --body <file>`
+    );
+  }
+  const hasScopeFlag = Boolean(flags["--project"] || flags["--all"]);
+  if (!flags["--body"] && !hasScopeFlag) {
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "MISSING_ARGUMENTS",
+      "Provide --body <PATH>, --project <name-or-id>, or --all."
+    );
+  }
+  const body = flags["--body"] ? readRuleBody(client, flags["--body"], format.jsonOutput) : {};
+  if (typeof body === "number")
+    return body;
+  if (Object.hasOwn(body, "type") && body.type !== "built-in" && body.type !== "custom") {
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "INVALID_RULE_TYPE",
+      "When provided, update body type must be built-in or custom."
+    );
+  }
+  if (hasScopeFlag && Object.hasOwn(body, "ruleScope")) {
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "SCOPE_CONFLICT",
+      "Specify rule scope either in the body or with --project/--all, not both."
+    );
+  }
+  const scope = await resolveUpdateScope(
+    client,
+    flags,
+    format.jsonOutput,
+    ruleId
+  );
+  if (typeof scope === "number")
+    return scope;
+  try {
+    let existing;
+    if (hasScopeFlag) {
+      output_manager_default.spinner("Fetching alert rule\u2026");
+      existing = await fetchRule(client, scope, ruleId);
+      const desiredScope = scopeForRule(
+        client,
+        existing.type,
+        scope,
+        flags,
+        format.jsonOutput
+      );
+      if (typeof desiredScope === "number")
+        return desiredScope;
+      if (!sameScope(existing.ruleScope, desiredScope)) {
+        body.ruleScope = desiredScope;
+      } else if (Object.keys(body).length === 0) {
+        output_manager_default.stopSpinner();
+        writeRuleResult(client, format.jsonOutput, "Unchanged", existing);
+        return 0;
+      }
+    }
+    output_manager_default.spinner("Updating alert rule\u2026");
+    const response = await client.fetch(
+      rulesItemPath(scope.teamId, ruleId),
+      { method: "PATCH", body }
+    );
+    writeRuleResult(client, format.jsonOutput, "Updated", response.rule);
+    return 0;
+  } catch (error) {
+    if (isAPIError(error)) {
+      return handleRulesApiError(client, error, format.jsonOutput);
+    }
+    throw error;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  update as default
+};

package/dist/chunks/vlt-builder-importer-USCFHWPL.js

@@ -0,0 +1,322 @@
+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 "./chunk-TZ2YI2VH.js";
+
+// src/builders/vlt-builder-importer.ts
+import { createHash, randomBytes } from "crypto";
+import {
+  link,
+  lstat,
+  mkdir,
+  open,
+  readFile,
+  rename,
+  rm,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { join } from "path";
+import { install } from "@vltpkg/graph";
+import { PackageInfoClient } from "@vltpkg/package-info";
+import { PackageJson } from "@vltpkg/package-json";
+import { getCachePath } from "@vercel/cli-config";
+import { PathScurry } from "path-scurry";
+var LOCK_RETRY_MS = 50;
+var LOCK_WAIT_MS = 5 * 60 * 1e3;
+var LOCK_EMPTY_GRACE_MS = 1e3;
+var TARBALL_FETCH_TIMEOUT_MS = 2 * 60 * 1e3;
+var activeInstallations = /* @__PURE__ */ new Map();
+function compareKeys(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([a], [b]) => compareKeys(a, b)).map(([key, child]) => [key, canonicalize(child)])
+    );
+  }
+  return value;
+}
+function validateGraph(graph) {
+  const { hash, ...contents } = graph;
+  const actual = createHash("sha256").update(JSON.stringify(canonicalize(contents))).digest("hex");
+  if (actual !== hash) {
+    throw new Error(
+      `The embedded vlt Builder graph for ${graph.name} is invalid.`
+    );
+  }
+}
+async function wait(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function hasErrorCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return hasErrorCode(error, "EPERM");
+  }
+}
+async function isLockHolderAlive(path) {
+  try {
+    const pid = Number.parseInt((await readFile(path, "utf8")).trim(), 10);
+    return Number.isInteger(pid) && pid > 0 && isProcessAlive(pid);
+  } catch {
+    return false;
+  }
+}
+async function tryStealStaleLock(path, emptyGraceMs) {
+  let first;
+  try {
+    first = await lstat(path);
+  } catch {
+    return true;
+  }
+  if (first.size === 0 && Date.now() - first.mtimeMs < emptyGraceMs) {
+    return false;
+  }
+  if (await isLockHolderAlive(path))
+    return false;
+  let second;
+  try {
+    second = await lstat(path);
+  } catch {
+    return true;
+  }
+  if (second.dev !== first.dev || second.ino !== first.ino || second.mtimeMs !== first.mtimeMs || second.size !== first.size) {
+    return false;
+  }
+  try {
+    await unlink(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function acquireLock(path, {
+  waitMs = LOCK_WAIT_MS,
+  emptyGraceMs = LOCK_EMPTY_GRACE_MS
+} = {}) {
+  await mkdir(join(path, ".."), { recursive: true });
+  const startedAt = Date.now();
+  while (true) {
+    const tmp = `${path}.${process.pid}-${randomBytes(6).toString("hex")}`;
+    await writeFile(tmp, `${process.pid}
+`, { flag: "wx" });
+    try {
+      await link(tmp, path);
+      await unlink(tmp).catch(() => void 0);
+      return await open(path, "r");
+    } catch (error) {
+      await unlink(tmp).catch(() => void 0);
+      if (!hasErrorCode(error, "EEXIST"))
+        throw error;
+      if (await tryStealStaleLock(path, emptyGraceMs))
+        continue;
+      if (Date.now() - startedAt > waitMs) {
+        throw new Error(`Timed out waiting for vlt Builder lock "${path}".`);
+      }
+      await wait(LOCK_RETRY_MS);
+    }
+  }
+}
+async function installationComplete(root, graph) {
+  try {
+    return (await readFile(join(root, ".vercel-builder-graph"), "utf8")).trim() === graph.hash;
+  } catch {
+    return false;
+  }
+}
+var EmbeddedPackageInfoClient = class extends PackageInfoClient {
+  constructor(options, fetchTimeoutMs = TARBALL_FETCH_TIMEOUT_MS) {
+    super(options);
+    this.fetchTimeoutMs = fetchTimeoutMs;
+  }
+  async extract(...args) {
+    const [rawSpec, target, rawOptions = {}] = args;
+    const spec = rawSpec;
+    const options = rawOptions;
+    if (spec.final?.type === "remote" && options.resolved) {
+      if (!options.integrity) {
+        throw new Error(
+          `Missing integrity for remote Builder dependency ${options.resolved}`
+        );
+      }
+      let response;
+      try {
+        response = await fetch(options.resolved, {
+          signal: AbortSignal.timeout(this.fetchTimeoutMs)
+        });
+      } catch (error) {
+        const aborted = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+        if (aborted) {
+          throw new Error(
+            `Timed out downloading remote Builder dependency ${options.resolved}`
+          );
+        }
+        throw error;
+      }
+      if (!response.ok) {
+        throw new Error(
+          `Could not download remote Builder dependency ${options.resolved}: ${response.status}`
+        );
+      }
+      const bytes = Buffer.from(await response.arrayBuffer());
+      const integrity = `sha512-${createHash("sha512").update(new Uint8Array(bytes)).digest("base64")}`;
+      if (options.integrity !== integrity) {
+        throw new Error(
+          `Integrity check failed for remote Builder dependency ${options.resolved}`
+        );
+      }
+      const prototype = PackageInfoClient.prototype;
+      await (await prototype.getTarPool.call(this)).unpack(
+        new Uint8Array(bytes),
+        target
+      );
+      return { resolved: options.resolved, integrity, spec: rawSpec };
+    }
+    return super.extract(...args);
+  }
+};
+async function reifyGraph(root, graph, packageInfoFactory) {
+  const packageJson = new PackageJson();
+  const packageInfo = packageInfoFactory({
+    ...graph.lockfile.options,
+    projectRoot: root,
+    packageJson
+  });
+  await install({
+    ...graph.lockfile.options,
+    projectRoot: root,
+    packageJson,
+    packageInfo,
+    scurry: new PathScurry(root),
+    allowScripts: ":not(*)",
+    frozenLockfile: true,
+    cleanInstall: true
+  });
+}
+async function ensureGraph(graph, cacheRoot, packageInfoFactory) {
+  validateGraph(graph);
+  const root = join(cacheRoot, graph.hash);
+  const active = activeInstallations.get(root);
+  if (active)
+    return active;
+  const installation = (async () => {
+    if (await installationComplete(root, graph))
+      return root;
+    const lockPath = join(cacheRoot, "locks", `${graph.hash}.lock`);
+    const lock = await acquireLock(lockPath);
+    let temporaryRoot;
+    try {
+      if (await installationComplete(root, graph))
+        return root;
+      await rm(root, { recursive: true, force: true });
+      temporaryRoot = process.platform === "win32" ? root : join(
+        cacheRoot,
+        "tmp",
+        `${graph.hash}-${process.pid}-${randomBytes(6).toString("hex")}`
+      );
+      await mkdir(temporaryRoot, { recursive: true });
+      await writeFile(
+        join(temporaryRoot, "package.json"),
+        `${JSON.stringify(graph.manifest, null, 2)}
+`
+      );
+      await writeFile(
+        join(temporaryRoot, "vlt-lock.json"),
+        `${JSON.stringify(graph.lockfile, null, 2)}
+`
+      );
+      await reifyGraph(temporaryRoot, graph, packageInfoFactory);
+      await writeFile(
+        join(temporaryRoot, ".vercel-builder-graph"),
+        `${graph.hash}
+`
+      );
+      if (temporaryRoot !== root) {
+        await mkdir(join(root, ".."), { recursive: true });
+        await rename(temporaryRoot, root);
+      }
+      temporaryRoot = void 0;
+      return root;
+    } finally {
+      await lock.close();
+      await unlink(lockPath).catch(() => void 0);
+      if (temporaryRoot)
+        await rm(temporaryRoot, { recursive: true, force: true });
+    }
+  })();
+  activeInstallations.set(root, installation);
+  const clearInstallation = () => {
+    if (activeInstallations.get(root) === installation) {
+      activeInstallations.delete(root);
+    }
+  };
+  void installation.then(clearInstallation, clearInstallation);
+  return installation;
+}
+function createVltBuilderImporter({
+  graphs,
+  loadGraphs = async () => graphs,
+  require: require2,
+  cacheRoot = join(getCachePath(), "builders-vlt"),
+  packageInfoFactory = (options) => new EmbeddedPackageInfoClient(options),
+  debug = () => void 0
+}) {
+  return async function importVltBuilders(specs) {
+    if (specs.size === 0)
+      return /* @__PURE__ */ new Map();
+    const loadedGraphs = await loadGraphs();
+    if (loadedGraphs.schemaVersion !== 1) {
+      throw new Error("The embedded vlt Builder graph index is invalid.");
+    }
+    const builders = /* @__PURE__ */ new Map();
+    await Promise.all(
+      [...specs].map(async ([spec, name]) => {
+        const graph = loadedGraphs.builders[name];
+        if (!graph)
+          throw new Error(`No pinned vlt graph exists for ${name}.`);
+        const root = await ensureGraph(graph, cacheRoot, packageInfoFactory);
+        const pkgPath = require2.resolve(`${name}/package.json`, {
+          paths: [root]
+        });
+        const pkg = JSON.parse(
+          await readFile(pkgPath, "utf8")
+        );
+        if (pkg.name !== name || pkg.version !== graph.version) {
+          throw new Error(
+            `The vlt Builder graph materialized ${String(pkg.name)}@${String(
+              pkg.version
+            )} instead of ${name}@${graph.version}.`
+          );
+        }
+        const path = require2.resolve(name, { paths: [root] });
+        debug(`Resolved ${name}@${graph.version} with vlt from ${root}`);
+        builders.set(spec, {
+          path,
+          pkgPath,
+          pkg: { ...pkg, name },
+          builder: require2(path),
+          dynamicallyInstalled: true
+        });
+      })
+    );
+    return builders;
+  };
+}
+export {
+  EmbeddedPackageInfoClient,
+  TARBALL_FETCH_TIMEOUT_MS,
+  acquireLock,
+  createVltBuilderImporter
+};