@koda-sl/baker-cli 0.478.0 → 0.480.0

package/dist/chunk-XDZVBX6L.js

@@ -0,0 +1,220 @@
+import {
+  debugLogHttp,
+  readBodyForLog
+} from "./chunk-N5O67GK5.js";
+import {
+  getEnv,
+  optionalTargetCompany
+} from "./chunk-EE72SSB2.js";
+
+// src/client.ts
+var MAX_RATE_LIMIT_RETRIES = 3;
+var MAX_TOTAL_WAIT_MS = 2 * 60 * 1e3;
+async function fetchWithRateLimitRetry(url, init) {
+  let totalWaited = 0;
+  for (let attempt = 0; attempt <= MAX_RATE_LIMIT_RETRIES; attempt++) {
+    const response = await fetch(url, init);
+    if (response.status !== 429 || attempt >= MAX_RATE_LIMIT_RETRIES) {
+      return response;
+    }
+    const retryAfterHeader = response.headers.get("Retry-After");
+    const waitMs = retryAfterHeader ? Number(retryAfterHeader) * 1e3 : 2e3 * 2 ** attempt;
+    if (totalWaited + waitMs > MAX_TOTAL_WAIT_MS) {
+      return response;
+    }
+    totalWaited += waitMs;
+    await new Promise((resolve) => setTimeout(resolve, waitMs));
+  }
+  return fetch(url, init);
+}
+var ApiError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ApiError";
+    this.code = code;
+  }
+};
+var CONVEX_ID_RE = /^[a-zA-Z0-9_]+$/;
+function hasControlCharacters(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
+      return true;
+    }
+  }
+  return false;
+}
+function validateStringValue(value) {
+  if (hasControlCharacters(value)) {
+    throw new ApiError("VALIDATION_ERROR", "String value contains invalid control characters");
+  }
+}
+function validateConvexId(id) {
+  if (!CONVEX_ID_RE.test(id)) {
+    throw new ApiError("VALIDATION_ERROR", `Invalid ID format: "${id}". Expected alphanumeric string.`);
+  }
+}
+function sanitizeParams(params) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(params)) {
+    validateStringValue(value);
+    sanitized[key] = value;
+  }
+  return sanitized;
+}
+function chatHeader() {
+  const { BAKER_CHAT_ID: chatId, BAKER_THREAD_ID: threadId, BAKER_KEY_SCOPE: keyScope } = getEnv();
+  const targetCompany = optionalTargetCompany();
+  return {
+    ...chatId ? { "x-baker-chat-id": chatId } : {},
+    ...threadId ? { "x-baker-thread-id": threadId } : {},
+    // Only ever narrows the key (`KEY_SCOPE_HEADER` in the backend).
+    ...keyScope ? { "x-baker-key-scope": keyScope } : {},
+    // `--company`: read another company of the organization (`TARGET_COMPANY_HEADER`).
+    ...targetCompany ? { "x-baker-company": targetCompany } : {}
+  };
+}
+function mapHttpError(status) {
+  if (status === 401) {
+    return "UNAUTHORIZED";
+  }
+  if (status === 403) {
+    return "FORBIDDEN";
+  }
+  if (status === 404) {
+    return "NOT_FOUND";
+  }
+  if (status === 422 || status === 400) {
+    return "VALIDATION_ERROR";
+  }
+  if (status === 409) {
+    return "CONFLICT";
+  }
+  if (status === 429) {
+    return "RATE_LIMITED";
+  }
+  if (status === 503) {
+    return "UNAVAILABLE";
+  }
+  return "INTERNAL_ERROR";
+}
+async function handleResponse(response) {
+  const body = await response.text();
+  if (!response.ok) {
+    let message = `HTTP ${response.status}: ${response.statusText}`;
+    try {
+      const parsed = JSON.parse(body);
+      if (typeof parsed.error === "string") {
+        message = parsed.error;
+      } else if (parsed.error?.message) {
+        message = parsed.error.message;
+      } else if (parsed.message) {
+        message = parsed.message;
+      }
+    } catch {
+    }
+    throw new ApiError(mapHttpError(response.status), message);
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw new ApiError("INTERNAL_ERROR", "Failed to parse API response as JSON");
+  }
+}
+async function apiGetWithHeaders(path, params) {
+  const env = getEnv();
+  const url = new URL(path, env.BAKER_API_URL);
+  if (params) {
+    const clean = sanitizeParams(params);
+    for (const [key, value] of Object.entries(clean)) {
+      url.searchParams.set(key, value);
+    }
+  }
+  const urlStr = url.toString();
+  const startedAt = Date.now();
+  let response;
+  try {
+    response = await fetchWithRateLimitRetry(urlStr, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${env.BAKER_API_KEY}`,
+        Accept: "application/json",
+        ...chatHeader()
+      },
+      signal: AbortSignal.timeout(6e4)
+    });
+  } catch (err) {
+    debugLogHttp({ source: "cli", method: "GET", url: urlStr, durationMs: Date.now() - startedAt, error: err });
+    if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
+      throw new ApiError("TIMEOUT", "Request timed out after 60 seconds");
+    }
+    throw new ApiError("NETWORK_ERROR", `Request failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+  }
+  debugLogHttp({
+    source: "cli",
+    method: "GET",
+    url: urlStr,
+    status: response.status,
+    ok: response.ok,
+    responseBody: await readBodyForLog(response),
+    durationMs: Date.now() - startedAt
+  });
+  return { data: await handleResponse(response), headers: response.headers };
+}
+async function apiGet(path, params) {
+  return (await apiGetWithHeaders(path, params)).data;
+}
+async function apiPost(path, body, opts) {
+  const env = getEnv();
+  const timeoutMs = opts?.timeoutMs ?? 6e4;
+  const urlStr = new URL(path, env.BAKER_API_URL).toString();
+  const startedAt = Date.now();
+  let response;
+  try {
+    response = await fetchWithRateLimitRetry(urlStr, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${env.BAKER_API_KEY}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...chatHeader()
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    debugLogHttp({
+      source: "cli",
+      method: "POST",
+      url: urlStr,
+      requestBody: body,
+      durationMs: Date.now() - startedAt,
+      error: err
+    });
+    if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
+      throw new ApiError("TIMEOUT", `Request timed out after ${Math.round(timeoutMs / 1e3)} seconds`);
+    }
+    throw new ApiError("NETWORK_ERROR", `Request failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+  }
+  debugLogHttp({
+    source: "cli",
+    method: "POST",
+    url: urlStr,
+    requestBody: body,
+    status: response.status,
+    ok: response.ok,
+    responseBody: await readBodyForLog(response),
+    durationMs: Date.now() - startedAt
+  });
+  return handleResponse(response);
+}
+
+export {
+  ApiError,
+  validateConvexId,
+  apiGetWithHeaders,
+  apiGet,
+  apiPost
+};
+//# sourceMappingURL=chunk-XDZVBX6L.js.map

package/dist/chunk-XGOEX2VJ.js

@@ -0,0 +1,55 @@
+import {
+  ApiError
+} from "./chunk-XDZVBX6L.js";
+import {
+  writeJson
+} from "./chunk-WNSE7N75.js";
+
+// src/commands/media-sources/shared.ts
+function driveRefusalFix(input, code) {
+  if (!/drive\.google\.com/i.test(input) || code !== "BAD_REQUEST") return void 0;
+  return `A Google Drive folder is never added by link \u2014 don't retry. Call request_connection with platform "google-drive" and choose "media-folder": the card lets the user pick the folder in the chat (only the Baker team can for now; anyone else is told the team will set it up). A connected result carries the new source's mediaSourceKey; if it is declined, carry on with the rest of the task.`;
+}
+function reportError(err, input) {
+  if (err instanceof ApiError) {
+    const fix = input ? driveRefusalFix(input, err.code) : void 0;
+    writeJson({ ok: false, error: { code: err.code, message: err.message, ...fix ? { fix } : {} } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function halfState(half) {
+  if (!half) return null;
+  return {
+    status: half.syncStatus === "fetching" || half.syncStatus === "processing" ? "importing" : half.syncStatus,
+    stored: half.storedCount ?? 0,
+    ...half.pendingItems ? { pending: half.pendingItems } : {},
+    ...half.failedItems ? { failed: half.failedItems } : {},
+    ...half.lastSyncedAt ? { lastSyncedAt: new Date(half.lastSyncedAt).toISOString() } : {},
+    ...half.errorMessage ? { error: half.errorMessage } : {}
+  };
+}
+function compactSource(source) {
+  return {
+    key: source.key,
+    platform: source.platform,
+    label: source.label,
+    url: source.profileUrl,
+    autoSync: source.refreshInterval,
+    images: halfState(source.images),
+    videos: halfState(source.videos)
+  };
+}
+function isImporting(source) {
+  return [source.images, source.videos].some(
+    (half) => half?.syncStatus === "fetching" || half?.syncStatus === "processing"
+  );
+}
+
+export {
+  reportError,
+  compactSource,
+  isImporting
+};
+//# sourceMappingURL=chunk-XGOEX2VJ.js.map

package/dist/chunk-XUB2EK65.js

@@ -0,0 +1,57 @@
+import {
+  formEventKey
+} from "./chunk-BC2BXRXY.js";
+import {
+  flowNodeTriggers
+} from "./chunk-FRK7SSEH.js";
+
+// ../api/src/analytics/flowEventKeys.ts
+function flowNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  const record = node;
+  acc.push(record);
+  if (Array.isArray(record.children)) for (const child of record.children) flowNodes(child, acc);
+  return acc;
+}
+function flowEventKeys(tree, slug) {
+  const primary = [];
+  const secondary = [];
+  const nodes = flowNodes(tree).filter((node) => typeof node.id === "string" && node.id !== "");
+  if (nodes.length === 0) return [];
+  for (const node of nodes) {
+    const id = node.id;
+    const triggers = flowNodeTriggers(node.nodeData);
+    for (const triggerId of triggers.available) {
+      const candidate = {
+        eventKey: formEventKey(slug, id, triggerId),
+        nodeId: id,
+        nodeName: typeof node.name === "string" ? node.name : id,
+        nodeType: triggers.type,
+        triggerId,
+        isCompletion: triggers.completion === triggerId
+      };
+      (candidate.isCompletion ? primary : secondary).push(candidate);
+    }
+  }
+  return [
+    ...primary,
+    ...secondary,
+    {
+      eventKey: `submit:${slug}`,
+      nodeId: null,
+      nodeName: "the Form ran out of steps",
+      nodeType: null,
+      triggerId: null,
+      // A Form reaching its last node is as primary as an outcome gets for a
+      // Form with no widget in it — but it never fires on one that ends in a
+      // booking widget or a redirect, so it does not lead the list.
+      isCompletion: false
+    }
+  ];
+}
+
+export {
+  flowNodes,
+  flowEventKeys
+};
+//# sourceMappingURL=chunk-XUB2EK65.js.map

package/dist/chunk-XUR4QWCS.js

@@ -0,0 +1,206 @@
+import {
+  RESEARCH_GOOGLE_ADS_MAX_COPY
+} from "./chunk-FRK7SSEH.js";
+
+// src/commands/research/hints.ts
+var AD_COPY_ROUTE = 'This returns competing domains and their SERP economics \u2014 no ad copy, no headlines, no creative. For a competitor\'s Google ads and their copy: `baker research google-ads <competitor.com> --copy` (Google\'s Ads Transparency Center: every ad, how long it has run, and the text ads\' headline and description). For Meta and LinkedIn: `baker winning-ads advertisers "<brand>"` \u2192 `baker winning-ads search "<brief>" --advertiser-id <id>` \u2192 `baker winning-ads content <adId>` (`primary_text` / `headline` / `cta`, plus the spoken transcript and on-screen text for video). Do not keep querying this command for copy.';
+function noSerpRowsHints(rowCount, queryContext) {
+  if (rowCount > 0) {
+    return [];
+  }
+  const defaulted = queryContext.location_is_default || queryContext.language_is_default;
+  if (defaulted) {
+    return [
+      `No rows for ${queryContext.location} / ${queryContext.language} \u2014 the market you did not set. Set --location and --language for the client's actual market and re-run once (\`baker research countries\` / \`baker research languages\` for the accepted codes) before you touch the keyword.`
+    ];
+  }
+  return [
+    `No rows for ${queryContext.location} / ${queryContext.language}, which you set explicitly. This term has no third-party SERP coverage in that market \u2014 move on rather than re-querying it. For demand signal try \`baker research autocomplete\`; for a competitor's actual terms, \`baker research keywords-for-site <domain>\`.`
+  ];
+}
+function advertisersHints(rowCount, queryContext) {
+  return [...noSerpRowsHints(rowCount, queryContext), AD_COPY_ROUTE];
+}
+function keywordsForSiteHints(rowCount, queryContext, typeFilter) {
+  if (rowCount > 0) {
+    return [];
+  }
+  if (typeFilter === "paid" || typeFilter === "organic") {
+    return [
+      `No rows with --type ${typeFilter} in ${queryContext.location} / ${queryContext.language}. A domain with zero ${typeFilter} keywords in a market is itself the finding \u2014 record it and move on. Confirm once with --type all (nothing at all there means the domain has no SERP coverage, not that it has no ads) instead of re-running with a different --sort or --limit.`
+    ];
+  }
+  return noSerpRowsHints(rowCount, queryContext);
+}
+var THIN_ANSWER_CHARS = 600;
+var THIN_SOURCE_COUNT = 2;
+var ESCALATION = {
+  medium: "`medium` is a quick lookup, not a search. Re-ask the SAME question once with `--depth high` before concluding the web has nothing on it.",
+  high: "`high` already thought hard about this. `--depth xhigh` is the only step left and it can run 15 minutes \u2014 take it only if this answer blocks a deliverable; otherwise record the gap and move on."
+};
+function fetchHints({
+  truncated,
+  contentChars,
+  shownChars
+}) {
+  const hints = [];
+  if (shownChars < contentChars) {
+    hints.push(
+      `Showing the first ${shownChars.toLocaleString("en-US")} of ${contentChars.toLocaleString("en-US")} characters. Re-run the same command with \`--full\` for the whole page \u2014 the read is cached for 24h, so it costs no extra time and no extra credit.`
+    );
+  }
+  if (truncated) {
+    hints.push(
+      "This page is longer than one read returns, so the end of it is missing. Don't present this as the complete page; if the part you need is further down, fetch the deeper URL directly."
+    );
+  }
+  return hints;
+}
+function webDepthHints({
+  answer,
+  sourceCount,
+  depth
+}) {
+  const thin = answer.length < THIN_ANSWER_CHARS || sourceCount <= THIN_SOURCE_COUNT;
+  const escalation = ESCALATION[depth];
+  if (!thin || !escalation) {
+    return [];
+  }
+  return [`Thin answer (${answer.length} chars, ${sourceCount} source(s)). ${escalation}`];
+}
+function keywordMetricsHints({
+  rows,
+  asked,
+  clickstream,
+  queryContext
+}) {
+  if (rows.length === 0) {
+    return noSerpRowsHints(0, queryContext);
+  }
+  const provenance = "DataForSEO resells Google's Keyword Planner volume \u2014 planner_search_volume here is the SAME number `baker ads google keywords metrics` returns, not an independent reading of it. Quoting the two as agreeing sources is not corroboration." + (clickstream ? " clickstream_search_volume IS independent (DataForSEO's own panels); when the two disagree, say which one you are quoting." : " For a genuinely independent estimate of demand, re-run with --clickstream (costs 2x), or use first-party data: `baker gsc query` for what already reaches the site, or the account's own search terms.");
+  const hints = [provenance];
+  const empty = rows.filter((row) => row.search_volume === null).map((row) => row.keyword);
+  if (empty.length > 0) {
+    hints.push(
+      `${empty.length} of ${asked.length} keywords came back with no data in ${queryContext.location} / ${queryContext.language}: ${empty.join(", ")}. That is missing coverage, NOT zero demand \u2014 do not report them as unsearched, and do not re-query them reworded. \`baker research autocomplete\` on the head term is the way to find the phrasing that market uses.`
+    );
+  }
+  return hints;
+}
+var ARCHIVE_NOTE = "Read from the Reddit archive: the words are as posted, but points and comment counts on anything under ~36h old are as first captured \u2014 don't quote those numbers as current.";
+function redditSearchHints({
+  resultCount,
+  kind,
+  source
+}) {
+  const hints = [];
+  if (resultCount === 0) {
+    hints.push(
+      'Nothing matched. Reddit search matches words, not meaning: try the audience\'s own phrasing (one distinctive word, or a seed from `baker research autocomplete`), a longer --since window, or other subreddits \u2014 `baker research reddit subreddits "<topic>"` finds where the audience actually talks' + (kind === "posts" ? ", and try --kind comments \u2014 most of the voice is in the replies." : ".")
+    );
+  } else if (kind === "posts") {
+    hints.push(
+      "Titles rarely carry the voice. Read the promising threads with `baker research reddit thread <permalink>` for the replies, or search the replies directly with --kind comments."
+    );
+  }
+  if (source === "archive" && resultCount > 0) hints.push(ARCHIVE_NOTE);
+  return hints;
+}
+function redditThreadHints({
+  commentsShown,
+  commentsAsked,
+  commentCount,
+  source
+}) {
+  const hints = [];
+  if (commentsAsked > 0 && commentsShown === 0 && (commentCount ?? 0) > 0) {
+    hints.push(
+      `This thread has ${commentCount} comments but none could be read just now. Quote the post only, and don't describe the replies.`
+    );
+  }
+  if (source === "archive") hints.push(ARCHIVE_NOTE);
+  return hints;
+}
+var REDDIT_HOST = /(^|\.)reddit\.com$|^redd\.it$/i;
+function redditSubredditsHints({ resultCount }) {
+  if (resultCount === 0) {
+    return [
+      'No subreddits matched. Try the audience\'s role or the platform they work on ("amazon flex", "deliveroo", "nurses"), one word at a time, or a web search for `site:reddit.com <topic>`.'
+    ];
+  }
+  return [
+    'Members say how big a subreddit is, not how active it is. Before mining one, run `baker research reddit search "<word>" --subreddit <name> --since <a recent date>`: nothing back means it is quiet, so pick another. `restricted` can still be read; `private` cannot.'
+  ];
+}
+var REDDIT_LINK_REJECTED = {
+  action: "reject",
+  explanation: "Do not quote anything attributed to this link \u2014 it does not lead to those words. Find the real thread with `baker research reddit search`, and if you already wrote a quote from it, remove it."
+};
+function redditPageFix(url, code) {
+  let host;
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    return null;
+  }
+  if (!REDDIT_HOST.test(host)) return null;
+  if (code === "NOT_FOUND") return REDDIT_LINK_REJECTED;
+  if (code !== "FORBIDDEN") return null;
+  return {
+    action: "retry_with_changes",
+    explanation: 'Read Reddit with its own commands: `baker research reddit search "<words>" --subreddit <name>` to find what people said, `baker research reddit thread <url>` for one thread.'
+  };
+}
+function googleAdsHints({
+  target,
+  adCount,
+  located,
+  textWithoutCopy,
+  copyAsked,
+  copyUnread,
+  visual
+}) {
+  if (adCount === 0) {
+    return [
+      `No Google ads point to ${target}${located ? " in that region" : ""} \u2014 that is the answer, not a failed call: this competitor is not advertising on Google there, or its ads point to another domain. ` + (located ? "Re-run once without --location to see every region; then move on. " : "Move on. ") + `Its paid search terms, if any: \`baker research keywords-for-site ${target} --type paid\`.`
+    ];
+  }
+  const hints = [];
+  if (!copyAsked && textWithoutCopy > 0) {
+    hints.push(
+      `${textWithoutCopy} text ads came back without their words. Re-run with --copy to read the headline and description of up to ${RESEARCH_GOOGLE_ADS_MAX_COPY} (cached, so only the reading is new).`
+    );
+  }
+  const pastCap = copyAsked ? textWithoutCopy - copyUnread : 0;
+  if (pastCap > 0) {
+    hints.push(
+      `${pastCap} text ads past the first ${RESEARCH_GOOGLE_ADS_MAX_COPY} were not read \u2014 one request reads at most ${RESEARCH_GOOGLE_ADS_MAX_COPY}. Narrow with --since, --location or --platform google_search and re-run for their words.`
+    );
+  }
+  if (visual > 0 || copyUnread > 0) {
+    const without = [
+      visual > 0 ? `${visual} image or video ads (Google gives no text for those)` : "",
+      copyUnread > 0 ? `${copyUnread} text ads whose image could not be read` : ""
+    ].filter(Boolean);
+    hints.push(
+      `No copy for ${without.join(" and ")}: show those by their \`transparency_url\`. Do not open the Transparency Center in agent-browser to read them \u2014 it is the browser load this command exists to avoid.`
+    );
+  }
+  return hints;
+}
+
+export {
+  noSerpRowsHints,
+  advertisersHints,
+  keywordsForSiteHints,
+  fetchHints,
+  webDepthHints,
+  keywordMetricsHints,
+  redditSearchHints,
+  redditThreadHints,
+  redditSubredditsHints,
+  REDDIT_LINK_REJECTED,
+  redditPageFix,
+  googleAdsHints
+};
+//# sourceMappingURL=chunk-XUR4QWCS.js.map

package/dist/chunk-XZ4YMCZK.js

@@ -0,0 +1,66 @@
+import {
+  canvasOutputsRoot
+} from "./chunk-23H4ZJRP.js";
+import {
+  optionalChatId
+} from "./chunk-EE72SSB2.js";
+
+// src/commands/canvas/creative-limit.ts
+import { existsSync } from "fs";
+import { mkdir, readdir, writeFile } from "fs/promises";
+import path from "path";
+var NEW_CREATIVES_PER_CHAT = 10;
+function claimNewCreative(made, slug) {
+  if (made.includes(slug)) return { allowed: true, count: made.length };
+  if (made.length >= NEW_CREATIVES_PER_CHAT) return { allowed: false, count: made.length };
+  return { allowed: true, count: made.length + 1 };
+}
+function chatDir(canvasRoot, chatId) {
+  return path.join(canvasRoot, ".creative-limit", (chatId ?? "no-chat").replace(/[^A-Za-z0-9_-]/g, "_"));
+}
+async function madeInChat(dir) {
+  return readdir(dir).catch(() => []);
+}
+async function claimNewCreativeInWorkspace(canvasRoot, slug, chatId, definitionPath, exists = existsSync) {
+  const dir = chatDir(canvasRoot, chatId);
+  const made = await madeInChat(dir);
+  if (!made.includes(slug) && exists(definitionPath)) return { allowed: true, count: made.length };
+  const claim = claimNewCreative(made, slug);
+  if (claim.allowed && !made.includes(slug)) {
+    try {
+      await mkdir(dir, { recursive: true });
+      await writeFile(path.join(dir, slug), "", { flag: "wx" });
+    } catch {
+    }
+  }
+  return claim;
+}
+function creativeLimitRefusal(slug) {
+  return {
+    ok: false,
+    error: {
+      code: "CREATIVE_LIMIT",
+      message: `${slug} would be new creative number ${NEW_CREATIVES_PER_CHAT + 1} in this chat. A chat makes at most ${NEW_CREATIVES_PER_CHAT} new creatives.`,
+      fix: `Build nothing more. Finish and show the ${NEW_CREATIVES_PER_CHAT} you have, and tell the person in one line that a chat makes up to ${NEW_CREATIVES_PER_CHAT} new creatives, so the rest go in a new chat. Editing or resizing the ones already made still works here. Working as a subagent: return now and say the limit was reached.`
+    }
+  };
+}
+async function enforceNewCreativeLimit(slug, canvasPath) {
+  const claim = await claimNewCreativeInWorkspace(
+    canvasOutputsRoot(canvasPath),
+    slug,
+    optionalChatId() ?? null,
+    path.join(path.dirname(path.resolve(canvasPath)), "_definition.md")
+  );
+  if (claim.allowed) return;
+  process.stderr.write(`${JSON.stringify(creativeLimitRefusal(slug), null, 2)}
+`);
+  process.exit(2);
+}
+
+export {
+  claimNewCreativeInWorkspace,
+  creativeLimitRefusal,
+  enforceNewCreativeLimit
+};
+//# sourceMappingURL=chunk-XZ4YMCZK.js.map

package/dist/chunk-Y3VRMFGF.js

@@ -0,0 +1,42 @@
+import {
+  ApiError
+} from "./chunk-XDZVBX6L.js";
+import {
+  writeJson
+} from "./chunk-WNSE7N75.js";
+
+// src/commands/studio/errors.ts
+var CREDIT_HINTS = ["credit", "top up", "billing", "quota"];
+function studioStartFix(message) {
+  const lower = message.toLowerCase();
+  if (CREDIT_HINTS.some((hint) => lower.includes(hint))) {
+    return {
+      action: "Stop generating and finish the task with assets that already exist",
+      explanation: "No generation will run until the plan is topped up, so retrying costs time and changes nothing. Source or reuse an image instead, complete the rest of the work, and tell the user the new artwork could not be produced."
+    };
+  }
+  return {
+    action: "Drop or correct the setting the message names, then run the command once more",
+    explanation: "The message says which model was chosen and what it accepts. If the setting is not essential to the brief, leave it out rather than switching model. Do not abort the wider job over one refused setting."
+  };
+}
+function failStudioCommand(error, opts = {}) {
+  if (error instanceof ApiError) {
+    writeJson({
+      ok: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        ...opts.withFix ? { fix: studioStartFix(error.message) } : {}
+      }
+    });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+
+export {
+  failStudioCommand
+};
+//# sourceMappingURL=chunk-Y3VRMFGF.js.map