vercel 59.13.1 → 59.15.0

package/dist/chunks/update-VMS45VF2.js

@@ -1,224 +0,0 @@
-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-DQ23J2KG.js";
-import "./chunk-GDOUDU6O.js";
-import {
-  emitRulesArgParseError,
-  fetchRule,
-  handleRulesApiError,
-  outputRulesError,
-  readRuleBody,
-  resolveRulesProject,
-  resolveRulesTeam,
-  rulesItemPath
-} from "./chunk-LVCCV2YJ.js";
-import "./chunk-2GXA4NGG.js";
-import "./chunk-GZLPFESR.js";
-import "./chunk-A3NYPUKZ.js";
-import "./chunk-KFWQ3EFH.js";
-import "./chunk-FGDKMNEN.js";
-import "./chunk-PRWJUY5U.js";
-import "./chunk-XEVKGAVI.js";
-import "./chunk-AINIBIP4.js";
-import "./chunk-EEV2LKFC.js";
-import "./chunk-ND5CF2H3.js";
-import {
-  validateJsonOutput
-} from "./chunk-KXDWXXJH.js";
-import "./chunk-V4RMJKQP.js";
-import {
-  rulesUpdateSubcommand
-} from "./chunk-EDMW7SBH.js";
-import "./chunk-N6HP5BLI.js";
-import "./chunk-P7VSBDR4.js";
-import "./chunk-L4H3DP65.js";
-import "./chunk-ZDU2NODC.js";
-import "./chunk-PEC3CQSK.js";
-import "./chunk-GGP5R3FU.js";
-import "./chunk-VUS2JQB2.js";
-import "./chunk-GQRG7VFK.js";
-import "./chunk-HRXRELD3.js";
-import "./chunk-B5XLQKHI.js";
-import "./chunk-76CB3CF2.js";
-import "./chunk-XNIZGCN5.js";
-import "./chunk-NW34PW6V.js";
-import {
-  printError
-} from "./chunk-3VM7HWF6.js";
-import {
-  parseArguments
-} from "./chunk-57RHXXXG.js";
-import "./chunk-7F5RNOTP.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

@@ -1,322 +0,0 @@
-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
-};