vercel 56.4.1 → 56.5.0

package/dist/chunks/chunk-WR7JTCGL.js

@@ -0,0 +1,104 @@
+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 {
+  canPrompt
+} from "./chunk-2473DUBR.js";
+import {
+  outputError
+} from "./chunk-BUZRVER7.js";
+
+// src/commands/comments/content.ts
+import { readFileSync } from "fs";
+function readAllStandardInput(stdin) {
+  if (stdin.isTTY) {
+    return Promise.resolve("");
+  }
+  return new Promise((resolve) => {
+    const chunks = [];
+    const timer = setTimeout(() => {
+      if (chunks.length === 0) {
+        cleanup();
+        resolve("");
+      }
+    }, 500);
+    const onData = (chunk) => {
+      chunks.push(String(chunk));
+    };
+    const onEnd = () => {
+      cleanup();
+      resolve(chunks.join(""));
+    };
+    function cleanup() {
+      clearTimeout(timer);
+      stdin.off("data", onData);
+      stdin.off("end", onEnd);
+    }
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    stdin.on("end", onEnd);
+  });
+}
+async function resolveMessageContent(client, flags, jsonOutput) {
+  if (flags.message !== void 0 && flags.file !== void 0) {
+    return outputError(
+      client,
+      jsonOutput,
+      "CONFLICTING_CONTENT",
+      "Use either --message or --file, not both."
+    );
+  }
+  if (flags.message !== void 0) {
+    return flags.message;
+  }
+  if (flags.file !== void 0) {
+    if (flags.file === "-") {
+      const piped2 = await readAllStandardInput(client.stdin);
+      if (piped2) {
+        return piped2;
+      }
+      return outputError(
+        client,
+        jsonOutput,
+        "MISSING_CONTENT",
+        "No content received on stdin for `--file -`."
+      );
+    }
+    try {
+      return readFileSync(flags.file, "utf8");
+    } catch (err) {
+      return outputError(
+        client,
+        jsonOutput,
+        "FILE_READ_ERROR",
+        `Could not read ${flags.file}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const piped = await readAllStandardInput(client.stdin);
+  if (piped) {
+    return piped;
+  }
+  if (flags.hasAttachments) {
+    return void 0;
+  }
+  if (canPrompt(client) && !jsonOutput) {
+    const text = await client.input.text({ message: "Comment message:" });
+    if (text) {
+      return text;
+    }
+  }
+  return outputError(
+    client,
+    jsonOutput,
+    "MISSING_CONTENT",
+    'No content provided. Pass -m <text>, --file <path>, or pipe stdin (e.g. `echo "LGTM" | vercel comments reply <thread>`).'
+  );
+}
+
+export {
+  resolveMessageContent
+};

package/dist/chunks/{chunk-HZKJMZEQ.js → chunk-X43U65TH.js}

@@ -6,14 +6,14 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   setupAndLink
-} from "./chunk-MQRHJEBS.js";
+} from "./chunk-PPEQUJ7T.js";
 import {
   detectExplicitScope,
   getLinkedProject,
   param,
   printProjectNotFoundError,
   resolveProjectCwd
-} from "./chunk-GLAHGVBS.js";
+} from "./chunk-TMK6RSYW.js";
 import {
   buildCommandWithYes,
   outputActionRequired

package/dist/chunks/chunk-YTFJGKRG.js

@@ -0,0 +1,247 @@
+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 {
+  outputError
+} from "./chunk-BUZRVER7.js";
+import {
+  getLinkedProject,
+  getProjectByNameOrId,
+  getScope
+} from "./chunk-TMK6RSYW.js";
+import {
+  printError
+} from "./chunk-SZXT3PDQ.js";
+import {
+  ProjectNotFound,
+  getCommandName,
+  isAPIError
+} from "./chunk-KSSNLCL4.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+
+// src/commands/comments/errors.ts
+function handleCommentsParseError(err, subcommandName) {
+  printError(err);
+  if (err instanceof Error && /unknown or unexpected option: -[^-]/.test(err.message)) {
+    output_manager_default.log(
+      `An argument starting with "-"? Put it after \`--\`: ${getCommandName(`comments ${subcommandName} -- <arg>`)}`
+    );
+  }
+  output_manager_default.log(
+    `Run ${getCommandName(`comments ${subcommandName} --help`)} for usage.`
+  );
+  return 1;
+}
+function threadNotFoundMessage(threadId, scope) {
+  return `Comment not found: ${threadId} in team ${scope.teamSlug ?? scope.teamId}. If it belongs to another team, pass --scope <team>.`;
+}
+
+// src/commands/comments/api.ts
+function query(teamId, params = {}) {
+  const search = new URLSearchParams({ teamId });
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        search.append(key, entry);
+      }
+    } else {
+      search.set(key, String(value));
+    }
+  }
+  return search.toString();
+}
+var fetchOpts = { useCurrentTeam: false };
+function listThreads(client, teamId, params) {
+  return client.fetch(
+    `/toolbar/threads?${query(teamId, { ...params })}`,
+    fetchOpts
+  );
+}
+function getThread(client, teamId, threadId) {
+  return client.fetch(
+    `/toolbar/threads/${encodeURIComponent(threadId)}?${query(teamId)}`,
+    fetchOpts
+  );
+}
+function updateThread(client, teamId, threadId, resolved) {
+  return client.fetch(
+    `/toolbar/threads/${encodeURIComponent(threadId)}?${query(teamId)}`,
+    { ...fetchOpts, method: "PATCH", body: { resolved } }
+  );
+}
+function listMessages(client, teamId, threadId, opts = {}) {
+  return client.fetch(
+    `/toolbar/threads/${encodeURIComponent(threadId)}/messages?${query(teamId, { ...opts })}`,
+    fetchOpts
+  );
+}
+function addMessage(client, teamId, threadId, body) {
+  return client.fetch(
+    `/toolbar/threads/${encodeURIComponent(threadId)}/messages?${query(teamId)}`,
+    { ...fetchOpts, method: "POST", body }
+  );
+}
+function updateMessage(client, teamId, threadId, messageId, body) {
+  return client.fetch(
+    `/toolbar/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}?${query(teamId)}`,
+    { ...fetchOpts, method: "PATCH", body }
+  );
+}
+function deleteMessage(client, teamId, threadId, messageId) {
+  return client.fetch(
+    `/toolbar/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}?${query(teamId)}`,
+    { ...fetchOpts, method: "DELETE" }
+  );
+}
+function toApiErrorParts(err) {
+  const apiErr = err;
+  return {
+    code: apiErr.code || "API_ERROR",
+    message: apiErr.serverMessage || `API error (${apiErr.status ?? "unknown"}).`
+  };
+}
+
+// src/commands/comments/scope.ts
+import { spawnSync } from "child_process";
+function scopeIsExplicit(client) {
+  return client.argv.some(
+    (arg) => arg === "--scope" || arg === "-S" || arg.startsWith("--scope=") || arg === "--team" || arg.startsWith("--team=") || arg === "-T"
+  );
+}
+async function resolveCommentsScope(client, opts) {
+  if (opts.urlTeamSlug && !opts.project && !scopeIsExplicit(client)) {
+    return { teamId: opts.urlTeamSlug, teamSlug: opts.urlTeamSlug };
+  }
+  if (opts.project) {
+    const { team: team2 } = await getScope(client);
+    if (!team2) {
+      return outputError(
+        client,
+        opts.jsonOutput,
+        "NO_TEAM",
+        "No team context found. Run `vercel switch` to select a team, or run `vercel link` in a project directory."
+      );
+    }
+    let project;
+    try {
+      project = await getProjectByNameOrId(client, opts.project, team2.id);
+    } catch (err) {
+      if (isAPIError(err)) {
+        return outputError(
+          client,
+          opts.jsonOutput,
+          err.code || "API_ERROR",
+          err.serverMessage || `API error (${err.status}).`
+        );
+      }
+      throw err;
+    }
+    if (project instanceof ProjectNotFound) {
+      return outputError(
+        client,
+        opts.jsonOutput,
+        "PROJECT_NOT_FOUND",
+        `Project "${opts.project}" was not found in team "${team2.slug}".`
+      );
+    }
+    return {
+      teamId: team2.id,
+      teamSlug: team2.slug,
+      projectId: project.id,
+      projectName: project.name
+    };
+  }
+  const linked = await getLinkedProject(client);
+  if (linked.status === "error") {
+    return linked.exitCode;
+  }
+  if (linked.status === "linked") {
+    if (scopeIsExplicit(client)) {
+      const { team: team2 } = await getScope(client);
+      if (!team2) {
+        return outputError(
+          client,
+          opts.jsonOutput,
+          "NO_TEAM",
+          "No team context found for --scope."
+        );
+      }
+      if (team2.id !== linked.org.id) {
+        if (opts.requireProject) {
+          return outputError(
+            client,
+            opts.jsonOutput,
+            "SCOPE_PROJECT_MISMATCH",
+            `--scope ${team2.slug} does not match the linked project's team (${linked.org.slug}). Pass --project <name-or-id> for a project in ${team2.slug}.`
+          );
+        }
+        return { teamId: team2.id, teamSlug: team2.slug };
+      }
+    }
+    return {
+      teamId: linked.org.id,
+      teamSlug: linked.org.slug,
+      projectId: linked.project.id,
+      projectName: linked.project.name,
+      linked: true
+    };
+  }
+  if (opts.requireProject) {
+    return outputError(
+      client,
+      opts.jsonOutput,
+      "NOT_LINKED",
+      "No linked project found. Run `vercel link` to link a project, or pass --project <name-or-id>."
+    );
+  }
+  const { team } = await getScope(client);
+  if (!team) {
+    return outputError(
+      client,
+      opts.jsonOutput,
+      "NO_TEAM",
+      "No team context found. Run `vercel switch` to select a team, or run `vercel link` in a project directory."
+    );
+  }
+  return { teamId: team.id, teamSlug: team.slug };
+}
+function inferBranch(cwd) {
+  const result = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    cwd,
+    encoding: "utf8"
+  });
+  if (result.status === 0) {
+    const branch = result.stdout.trim();
+    if (branch && branch !== "HEAD") {
+      return { value: branch, source: "git" };
+    }
+  }
+  const ciRef = process.env.VERCEL_GIT_COMMIT_REF || process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME;
+  if (ciRef) {
+    return { value: ciRef, source: "ci" };
+  }
+  return void 0;
+}
+
+export {
+  handleCommentsParseError,
+  threadNotFoundMessage,
+  listThreads,
+  getThread,
+  updateThread,
+  listMessages,
+  addMessage,
+  updateMessage,
+  deleteMessage,
+  toApiErrorParts,
+  resolveCommentsScope,
+  inferBranch
+};

package/dist/chunks/{compile-vercel-config-J2X5OV6K.js → compile-vercel-config-IFET4E6H.js}

@@ -11,9 +11,9 @@ import {
   findSourceVercelConfigFile,
   getVercelConfigPath,
   normalizeConfig
-} from "./chunk-GLAHGVBS.js";
-import "./chunk-UDWRZXIT.js";
+} from "./chunk-TMK6RSYW.js";
 import "./chunk-ECCWJHC6.js";
+import "./chunk-UDWRZXIT.js";
 import "./chunk-SZXT3PDQ.js";
 import "./chunk-KSSNLCL4.js";
 import "./chunk-P4QNYOFB.js";