@koda-sl/baker-cli 0.124.0-dev.8e4328629 → 0.124.0-dev.efe965ce2

package/README.md

@@ -2132,6 +2132,8 @@ Auto-ingests with prefetched bytes (no double-fetch). The screenshot bytes thems
 
 ScreenshotOne caches captures for 30 days, so re-shotting the same URL within that window returns the cached capture.
 
+If the target page is unreachable or returns a non-2xx status (e.g. a 404 path or a login wall), the command fails with an actionable `VALIDATION_ERROR` naming the page and the status it returned, plus a `fix` hint — verify the URL and retry, or continue without the screenshot. It no longer surfaces a generic "Internal server error".
+
 **Flags:**
 
 | Flag           | Description                                                                                |
@@ -2502,6 +2504,46 @@ Rules:
 
 ---
 
+### Marketing Tags (`baker tags`)
+
+Read the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, PostHog, …) — production tags overlaid with the changes staged in this chat.
+
+**The CLI is read-only.** Every tag change (create, edit, delete) goes through the `request_tag_input` tool (`baker_ui` MCP server): the agent proposes one or more changes — each becomes a tab in one blocking approval form — pre-filling the non-secret fields it knows; the user reviews, edits, fills secret fields, and approves or skips each tab. Approved changes stage on the chat and apply when the chat is published; discarding the chat drops them.
+
+`BAKER_CHAT_ID` must be set.
+
+```bash
+baker tags list       # effective view: production + staged, full readable config + secret status
+baker tags draft      # review the staged changes awaiting publish
+```
+
+Notes:
+
+- **`list` prints each tag's full readable config.** Every non-secret field is shown in full under the tag — the Clarity `projectId`, GA4 `measurementId`, the entire custom `code` snippet, etc. — so the agent reuses a stored value to pre-fill a follow-up change instead of asking the user for something already installed. Secrets are never among these fields. (`--json` emits the same data as the raw envelope.)
+- **Secrets never travel through this CLI or the chat.** Secret fields (`accessToken`, `apiSecret`, `authorizationToken`, `apiKey`, `conversionToken`, `oauthProviderId`) are entered only in the dashboard's secure tag form and flow straight into the staged draft; tool responses only ever name which secret fields are set/pending.
+- Staged creates get a server-generated `tag_temp_*` ref (returned in the tool result and printed by `list`). Use it (or a real tag id) as flow side-effect `tagIds` — the published tag keeps resolving under the temp ref.
+- Proposing a delete on a `tag_temp_*` ref drops the staged create instead.
+- Single-instance types (`code`, `posthog`, `datafast`) reject a second instance against the chat's effective view.
+- Conflicts at publish (tag deleted in the dashboard, config invalid) skip the op with a recorded reason — they never block the publish.
+
+### Forms / Flows (`baker flows`)
+
+Read this workspace's Forms (flows) and the configuration status of each one's **confidential fields** — side-effect connection secrets, OAuth connections, and third-party field definitions (HubSpot, Calendly, HighLevel, SavvyCal). Reads the local `_data.json` files; no secret values are ever decrypted or printed.
+
+**The CLI is read-only.** Author a Form's structure (nodes, conditions, side effects, field mappings) by editing its `_data.json` with the flow-builder skill. Configure the confidential fields it reports as `[missing]` / `[needs connection]` / `not selected` through the `request_flow_input` tool (`baker_ui` MCP server): the agent authors the surrounding structure, references it by `nodeId`/`sideEffectId`, and the user enters secrets, connects/picks OAuth accounts, and picks third-party forms in the dashboard. Those values are written (encrypted, where a secret) into the Form on the chat's branch and go live when the chat is published.
+
+```bash
+baker flows list            # every Form + how many confidential fields still need setup
+baker flows show contact    # one Form's confidential fields and their status
+baker flows show contact --full   # include the full flow tree (secret values redacted)
+```
+
+Notes:
+
+- **Secrets never travel through this CLI or the chat.** `show` reports only whether each field is configured (`[set]`/`[missing]`, `[connected]`/`[needs connection]`, selected/not selected) — never a value. Configured secrets appear only as `[configured]` ciphertext markers.
+- Confidential side-effect types: `httpWebhook`, `zapier`, `crmble` (typed credentials); `pipedrive`, `googleSpreadsheet`, `hubspotForm`, `goHighlevelContact` (OAuth connection + resource); `email`. Widget node types needing a resource pick: `calendly`, `savvycal`, `hubspot`, `hubspotMeeting`, `highlevel`, `highlevelForm`.
+- `request_flow_input` changes stage on the chat's branch and apply when the chat is published; discarding the chat drops them.
+
 ### Action Items (`baker actions`)
 
 Manage action items for the current chat. Most write operations stage on the chat's draft and apply atomically when the chat is published. Claim/release run live so other chats can see who's working on what.
@@ -3945,6 +3987,7 @@ Validate, then execute the graph. Blocks until done. Logs one line per node. Ret
 | `--cache-policy <policy>` | `read_write` | `read_write`, `bypass`, or `read_only`. |
 | `--concurrency <n>` | `5` (or `BAKER_CANVAS_CONCURRENCY`) | Max nodes executing at once within a layer. |
 | `--remote-cache <on\|off>` | `on` (or `BAKER_CANVAS_REMOTE_CACHE`) | Company-scoped remote cache + durable asset persistence. |
+| `--max-credits <n>` | uncapped (or `BAKER_CANVAS_MAX_CREDITS`) | Credit ceiling: aborts before billing when the estimate exceeds it, and at layer boundaries once actual spend does. Completed nodes stay cached, so retrying with a higher cap loses nothing. |
 | `--no-record` | records | Skip posting the durable run-history record (and its live progress). |
 
 **Run history streams live.** The run posts its plan (every node + its dependency edges) the moment validation passes, then re-posts a progress snapshot as each node starts and settles — the dashboard's creative workflow graph shows nodes flipping pending → running → done in real time, with each node's outputs attached as they land. A failed run keeps its per-node trail (what completed, what died). All best-effort: an unreachable backend never changes the run's outcome.
@@ -4069,7 +4112,25 @@ baker canvas run ./static-ad.canvas.json
 
 Scaffolding runs (and bills) the two vision passes; **running** the result generates a billed image. `baker canvas validate` does not check that the `[TODO]` paths exist — supply the real files before `run`.
 
-**Resuming an interrupted run.** A long `baker canvas run` (multi-clip video) that is killed mid-render — session end, sandbox pause — leaves a marker under the outputs dir. The next `baker canvas run` of the same canvas automatically **resumes** that run: it reuses the run id so still-running billed jobs re-attach instead of being abandoned and re-billed, and completed nodes come from the cache. A clean completion (or a handled failure) clears the marker, so a normal re-run starts a fresh generation. Force a new run with `--fresh`, or pin a specific run with `--run-id <id>`. Independent same-layer nodes (e.g. video clips) fan out in parallel up to `--parallel`/`--concurrency` (default 8; env `BAKER_CANVAS_CONCURRENCY`).
+**Resuming an interrupted run.** A long `baker canvas run` (multi-clip video) that is killed mid-render — session end, sandbox pause — leaves a marker under the outputs dir. The next `baker canvas run` of the same canvas automatically **resumes** that run: it reuses the run id so still-running billed jobs re-attach instead of being abandoned and re-billed, and completed nodes come from the cache. Resume also works from a **different workspace or a fresh sandbox**: when no local marker survives, the run history is consulted and an interrupted (or stale) run of the exact same canvas is adopted automatically. Ctrl-C / SIGTERM aborts gracefully — no new nodes dispatch, a resumable snapshot is flushed, and the marker survives. A clean completion (or a handled failure) clears the marker, so a normal re-run starts a fresh generation. Force a new run with `--fresh`, or pin a specific run with `--run-id <id>` (also the escape hatch to adopt a run that is reported as concurrently live). Independent same-layer nodes (e.g. video clips) fan out in parallel up to `--parallel`/`--concurrency` (default 8; env `BAKER_CANVAS_CONCURRENCY`).
+
+#### `baker canvas rerun <slug> [flags]`
+
+Re-run a creative's latest recorded canvas **from run history** — no local files needed. Every `canvas run` of a creative uploads a portable snapshot (the canvas JSON plus the local files it ingests: prompt blueprints, composition dirs, reference images) to durable storage and records it on the run. `rerun` restores those files into `src/creatives/<slug>/` (sha-verified; files already matching are left untouched) and then executes the normal run flow — so an interrupted run **resumes** (in-flight jobs re-attach) and a completed one re-renders from the cache at zero credits.
+
+| Flag | Default | Meaning |
+| --- | --- | --- |
+| `--force-remote` | off | Overwrite local files whose content differs from the snapshot (otherwise a conflict aborts with the differing paths). |
+| `--fresh` | off | Start a new run id instead of resuming an interrupted one. |
+| `--regenerate <ids>` | — | Same as `canvas run --regenerate`. |
+| `--concurrency <n>` | — | Same as `canvas run --concurrency`. |
+
+```bash
+baker canvas rerun spring-offer-4x5
+baker canvas rerun spring-offer-4x5 --force-remote --regenerate gen_4x5
+```
+
+Use it when a creative was built in another conversation (or its sandbox is gone) and you need to continue or re-render it here. Files the snapshot could not include (missing at run time, or oversized) are listed as warnings — supply those locally only if the run actually needs to regenerate the nodes that read them.
 
 #### `baker canvas inspect <run_id> [--thumbnails]`
 

package/dist/{chunk-Q3K5TXC6.js → chunk-TKL2CJ6G.js}

@@ -812,10 +812,10 @@ var BackendClient = class {
       await sleep(pollInterval(attempt));
     }
   }
-  presignAssetUpload(sha256, mime, signal) {
+  presignAssetUpload(sha256, mime, signal, purpose) {
     return this.http.postJson(
       "/api/canvas/assets/presign",
-      { sha256, mime },
+      { sha256, mime, purpose },
       signal
     );
   }
@@ -840,6 +840,39 @@ var BackendClient = class {
   async recordRun(payload, signal) {
     await this.http.postJson("/api/canvas/runs", payload, signal);
   }
+  /**
+   * Resumable-run lookup — GET /api/canvas/runs/active. Returns the newest
+   * still-running/interrupted run for the creative (pinned to the exact canvas
+   * sha), so a fresh sandbox can adopt its run id and re-attach billed
+   * in-flight jobs. Null on no active run — or an older backend without the
+   * route (both 404).
+   */
+  async getActiveRun(creativeSlug, canvasSha, signal) {
+    const params = new URLSearchParams({ slug: creativeSlug });
+    if (canvasSha) params.set("sha", canvasSha);
+    try {
+      const res = await this.http.getJson(`/api/canvas/runs/active?${params}`, signal);
+      return res.run;
+    } catch (e) {
+      if (e instanceof BackendHttpError && "status" in e.detail && e.detail.status === 404) return null;
+      throw e;
+    }
+  }
+  /**
+   * Portable-rerun lookup — GET /api/canvas/runs/latest. The newest run for
+   * the creative that recorded a canvas snapshot manifest; null when none
+   * exists (or the backend predates the route — both 404).
+   */
+  async getLatestSnapshotRun(creativeSlug, signal) {
+    const params = new URLSearchParams({ slug: creativeSlug });
+    try {
+      const res = await this.http.getJson(`/api/canvas/runs/latest?${params}`, signal);
+      return res.run;
+    } catch (e) {
+      if (e instanceof BackendHttpError && "status" in e.detail && e.detail.status === 404) return null;
+      throw e;
+    }
+  }
   /**
    * Chat-scoped blueprint sync — POST /api/creatives/definition. Lets the
    * dashboard draw a scaffolded creative's workflow graph BEFORE the first run.
@@ -907,6 +940,14 @@ var NodeExecutionError = class extends CanvasError {
     this.cause = cause;
   }
 };
+var RunAbortedError = class extends CanvasError {
+  reason;
+  constructor(reason, message2) {
+    super(message2);
+    this.name = "RunAbortedError";
+    this.reason = reason;
+  }
+};
 var LayerExecutionError = class extends CanvasError {
   failures;
   constructor(failures) {
@@ -1732,18 +1773,43 @@ function message(e) {
 }
 
 // src/engine/nodes/remote/upload.ts
+var PUT_MAX_ATTEMPTS = 4;
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function presignAndPut(args) {
-  const { putUrl, publicUrl } = await args.ctx.client.presignAssetUpload(args.sha256, args.mime, args.ctx.signal);
-  const putRes = await fetch(putUrl, {
-    method: "PUT",
-    body: new Uint8Array(args.bytes),
-    headers: { "Content-Type": args.mime },
-    signal: args.ctx.signal
-  });
-  if (!putRes.ok) {
-    throw new Error(`upload: presigned PUT failed ${putRes.status} ${putRes.statusText}`);
+  let lastFailure = null;
+  for (let attempt = 0; attempt < PUT_MAX_ATTEMPTS; attempt++) {
+    if (args.ctx.signal?.aborted) break;
+    if (attempt > 0) await sleep2(500 * 2 ** (attempt - 1) * (1 + Math.random() * 0.25));
+    const result = await attemptPresignedPut(args);
+    if (result.ok) return result.url;
+    lastFailure = result.failure;
+    if (!result.retryable) break;
+  }
+  throw lastFailure ?? new Error("upload: aborted before the PUT could start");
+}
+async function attemptPresignedPut(args) {
+  try {
+    const { putUrl, publicUrl } = await args.ctx.client.presignAssetUpload(args.sha256, args.mime, args.ctx.signal);
+    const putRes = await fetch(putUrl, {
+      method: "PUT",
+      body: new Uint8Array(args.bytes),
+      headers: { "Content-Type": args.mime },
+      signal: args.ctx.signal
+    });
+    if (putRes.ok) return { ok: true, url: publicUrl };
+    return {
+      ok: false,
+      failure: new Error(`upload: presigned PUT failed ${putRes.status} ${putRes.statusText}`),
+      // Only transient statuses warrant a replay — a 400/403 fails identically every attempt.
+      retryable: putRes.status >= 500 || putRes.status === 429 || putRes.status === 408
+    };
+  } catch (e) {
+    return {
+      ok: false,
+      failure: e instanceof Error ? e : new Error(String(e)),
+      retryable: args.ctx.signal?.aborted !== true
+    };
   }
-  return publicUrl;
 }
 async function ensureUploaded(ref, ctx) {
   if (ref.url) return ref;
@@ -3065,6 +3131,12 @@ var Engine = class {
   async run(input, opts = {}) {
     const validation = await this.validateDeep(input);
     if (!validation.ok) throw new ValidationError(validation.issues);
+    if (opts.max_credits !== void 0 && validation.estimatedCredits > opts.max_credits) {
+      throw new RunAbortedError(
+        "cost_cap",
+        `estimated ${validation.estimatedCredits} credits exceeds the ${opts.max_credits}-credit cap \u2014 nothing was billed; raise --max-credits or shrink the canvas`
+      );
+    }
     const canvas = validation.canvas;
     const runId = opts.run_id ?? `r_${ulid()}`;
     const writer = new OutputWriter({ outputsDir: this.outputsDir, runId });
@@ -3115,7 +3187,17 @@ var Engine = class {
     const layers = topologicalLayers(graph);
     const limit = resolveConcurrency(opts.concurrency);
     for (const layer of layers) {
+      if (opts.signal?.aborted) throw new RunAbortedError("signal", "run aborted before layer dispatch");
+      if (opts.max_credits !== void 0 && counters.totalCredits > opts.max_credits) {
+        throw new RunAbortedError(
+          "cost_cap",
+          `spent ${counters.totalCredits} credits, over the ${opts.max_credits}-credit cap \u2014 completed nodes are cached; raise --max-credits to continue where this stopped`
+        );
+      }
       const settled = await mapWithConcurrency(layer, limit, (nodeId) => {
+        if (opts.signal?.aborted) {
+          return Promise.reject(new RunAbortedError("signal", "run aborted before node dispatch"));
+        }
         this.emitProgress(opts, { kind: "node_start", node_id: nodeId });
         return this.executeOne(canvas, nodeId, outputs, runId, writer, opts, needsBytes.has(nodeId)).then((r) => {
           if (r.cached) counters.cachedNodes++;
@@ -3138,10 +3220,12 @@ var Engine = class {
       settled.forEach((result, i) => {
         const nodeId = layer[i];
         if (result.status === "rejected" && nodeId) {
+          if (result.reason instanceof RunAbortedError) return;
           failures.push({ nodeId, reason: result.reason });
           this.emitProgress(opts, { kind: "node_failed", node_id: nodeId });
         }
       });
+      if (opts.signal?.aborted) throw new RunAbortedError("signal", "run aborted by signal");
       if (failures.length === 1 && failures[0]) throw failures[0].reason;
       if (failures.length > 1) throw new LayerExecutionError(failures);
     }
@@ -6929,7 +7013,9 @@ function createEngineFromEnv(opts = {}) {
 }
 
 export {
+  BackendClient,
   requireCredentialsFromEnv,
+  RunAbortedError,
   LayerExecutionError,
   describeFailureReason,
   SEEDANCE_DURATIONS,
@@ -6945,7 +7031,7 @@ export {
   sha256Hex,
   elementMentionKeywords,
   toModelSafeImage,
-  BackendClient2 as BackendClient,
+  BackendClient2,
   Engine2 as Engine,
   LocalAssetStore2 as LocalAssetStore,
   LocalCacheStore2 as LocalCacheStore,
@@ -6955,4 +7041,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-Q3K5TXC6.js.map
+//# sourceMappingURL=chunk-TKL2CJ6G.js.map