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

package/README.md

@@ -2132,8 +2132,6 @@ 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                                                                                |
@@ -2504,46 +2502,6 @@ 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.
@@ -3987,7 +3945,6 @@ 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.
@@ -4112,25 +4069,7 @@ 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. 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.
+**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`).
 
 #### `baker canvas inspect <run_id> [--thumbnails]`
 

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

@@ -812,10 +812,10 @@ var BackendClient = class {
       await sleep(pollInterval(attempt));
     }
   }
-  presignAssetUpload(sha256, mime, signal, purpose) {
+  presignAssetUpload(sha256, mime, signal) {
     return this.http.postJson(
       "/api/canvas/assets/presign",
-      { sha256, mime, purpose },
+      { sha256, mime },
       signal
     );
   }
@@ -840,39 +840,6 @@ 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.
@@ -940,14 +907,6 @@ 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) {
@@ -1773,43 +1732,18 @@ 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) {
-  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
-    };
+  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}`);
   }
+  return publicUrl;
 }
 async function ensureUploaded(ref, ctx) {
   if (ref.url) return ref;
@@ -3131,12 +3065,6 @@ 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 });
@@ -3187,17 +3115,7 @@ 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++;
@@ -3220,12 +3138,10 @@ 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);
     }
@@ -7013,9 +6929,7 @@ function createEngineFromEnv(opts = {}) {
 }
 
 export {
-  BackendClient,
   requireCredentialsFromEnv,
-  RunAbortedError,
   LayerExecutionError,
   describeFailureReason,
   SEEDANCE_DURATIONS,
@@ -7031,7 +6945,7 @@ export {
   sha256Hex,
   elementMentionKeywords,
   toModelSafeImage,
-  BackendClient2,
+  BackendClient2 as BackendClient,
   Engine2 as Engine,
   LocalAssetStore2 as LocalAssetStore,
   LocalCacheStore2 as LocalCacheStore,
@@ -7041,4 +6955,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-TKL2CJ6G.js.map
+//# sourceMappingURL=chunk-Q3K5TXC6.js.map