@koda-sl/baker-cli 0.489.0 → 0.491.0

package/dist/chunk-ZEPUDYPL.js

@@ -0,0 +1,122 @@
+import {
+  prepareCanvas,
+  unsuppliedPlaceholderAssets
+} from "./chunk-YLYXSJ6O.js";
+import {
+  isSourceStale
+} from "./chunk-DAO63OOP.js";
+
+// src/commands/canvas/render-state.ts
+import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+var RENDER_STATE_DIR = ".rendered";
+function statePath(canvasRoot, slug) {
+  return path.join(canvasRoot, RENDER_STATE_DIR, `${slug}.json`);
+}
+async function readRenderState(canvasRoot, slug) {
+  try {
+    const parsed = JSON.parse(await readFile(statePath(canvasRoot, slug), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function latestVersion(canvasRoot, slug) {
+  return (await readRenderState(canvasRoot, slug)).rendered?.runId ?? null;
+}
+async function updateRenderState(canvasRoot, slug, patch) {
+  try {
+    const next = { ...await readRenderState(canvasRoot, slug), ...patch };
+    await mkdir(path.join(canvasRoot, RENDER_STATE_DIR), { recursive: true });
+    await writeFile(statePath(canvasRoot, slug), `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+async function recordRenderAttempt(canvasRoot, slug, sourceSha) {
+  if (!sourceSha) return;
+  await updateRenderState(canvasRoot, slug, { attempted: { sourceSha, at: Date.now() } });
+}
+async function recordRendered(canvasRoot, slug, sourceSha, runId, drawn = {}) {
+  if (!sourceSha) return;
+  await updateRenderState(canvasRoot, slug, {
+    rendered: { sourceSha, runId, at: Date.now() },
+    ...drawn.prompt !== void 0 ? { prompt: drawn.prompt } : {},
+    ...drawn.anchor ? { anchor: drawn.anchor } : {},
+    ...drawn.idea ? { idea: drawn.idea } : {},
+    lastFix: drawn.lastFix,
+    picture: drawn.picture,
+    ...drawn.seriesLeadRun ? { seriesLeadRun: drawn.seriesLeadRun } : {}
+  });
+}
+async function recordSeen(canvasRoot, slug, seen) {
+  await updateRenderState(canvasRoot, slug, { seen });
+}
+async function recordIdeaLines(canvasRoot, slug, idea) {
+  if ((await readRenderState(canvasRoot, slug)).idea) return;
+  await updateRenderState(canvasRoot, slug, { idea });
+}
+async function recordReviewOutcome(canvasRoot, slug, outcome) {
+  await updateRenderState(canvasRoot, slug, outcome);
+}
+async function recordSeriesLeadRun(canvasRoot, slug, leadRunId) {
+  await updateRenderState(canvasRoot, slug, { seriesLeadRun: leadRunId });
+}
+async function recordSnapshot(canvasRoot, slug, snapshot) {
+  await updateRenderState(canvasRoot, slug, { snapshot });
+}
+function isRenderStale(state, currentSourceSha) {
+  if (!state.rendered) return false;
+  if (!isSourceStale(currentSourceSha, state.rendered.sourceSha)) return false;
+  return state.attempted?.sourceSha !== currentSourceSha;
+}
+async function staleCreatives(workspaceRoot) {
+  const creativesDir = path.join(workspaceRoot, "src", "creatives");
+  const canvasRoot = path.join(workspaceRoot, "canvas");
+  let slugs;
+  try {
+    slugs = (await readdir(creativesDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const stale = [];
+  for (const slug of slugs.sort()) {
+    const state = await readRenderState(canvasRoot, slug);
+    if (!state.rendered) continue;
+    const canvasPath = path.join(creativesDir, slug, `${slug}.canvas.json`);
+    let prepared;
+    try {
+      prepared = await prepareCanvas(canvasPath, { write: false });
+    } catch {
+      continue;
+    }
+    if (unsuppliedPlaceholderAssets(prepared.fileGraph).length > 0) continue;
+    const current = prepared.sourceSha;
+    if (!current || !isRenderStale(state, current)) continue;
+    stale.push({
+      slug,
+      canvasPath: path.relative(workspaceRoot, canvasPath).split(path.sep).join("/"),
+      renderedRunId: state.rendered.runId,
+      sourceSha: current
+    });
+  }
+  return stale;
+}
+async function clearLegacyDirtyMarker(canvasRoot, slug) {
+  await rm(path.join(canvasRoot, ".dirty", `${slug}.json`), { force: true }).catch(() => void 0);
+}
+
+export {
+  readRenderState,
+  latestVersion,
+  recordRenderAttempt,
+  recordRendered,
+  recordSeen,
+  recordIdeaLines,
+  recordReviewOutcome,
+  recordSeriesLeadRun,
+  recordSnapshot,
+  staleCreatives,
+  clearLegacyDirtyMarker
+};
+//# sourceMappingURL=chunk-ZEPUDYPL.js.map

package/dist/chunk-ZJSGGJ5R.js

@@ -0,0 +1,167 @@
+import {
+  parseRefExpr
+} from "./chunk-JQH5VG6F.js";
+import {
+  collectAssetRefLikes,
+  isPersistedAssetRef
+} from "./chunk-2FSEESJU.js";
+
+// src/commands/canvas/run-record.ts
+import path from "path";
+var MAX_RUN_NODES = 200;
+var MAX_OUTPUTS_PER_NODE = 10;
+var MAX_FINAL_OUTPUTS = 10;
+var MAX_NODE_FACTS_CHARS = 4096;
+var MAX_CREATIVE_SLUG_LENGTH = 100;
+function creativeSlugFromCanvasPath(filePath) {
+  const normalized = filePath.split(path.sep).join("/");
+  const match = normalized.match(/(?:^|\/)src\/creatives\/([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\//);
+  const slug = match?.[1] ?? null;
+  return slug && slug.length <= MAX_CREATIVE_SLUG_LENGTH ? slug : null;
+}
+function finalOutputLabelsFromCanvas(parsed) {
+  const canvas = parsed;
+  const outputNodeId = canvas?.output?.node;
+  if (typeof outputNodeId !== "string" || !Array.isArray(canvas?.nodes)) return null;
+  const node = canvas.nodes.find((n) => n?.id === outputNodeId);
+  if (node?.type !== "collect") return null;
+  const explicit = node.params?.labels;
+  if (Array.isArray(explicit) && explicit.every((l) => typeof l === "string")) {
+    return { nodeId: outputNodeId, labels: explicit };
+  }
+  const images = node.inputs?.images;
+  if (!Array.isArray(images)) return null;
+  const labels = images.map((entry) => {
+    if (typeof entry !== "string") return void 0;
+    return parseRefExpr(entry)?.nodeId;
+  });
+  return { nodeId: outputNodeId, labels };
+}
+var OUTPUT_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "json", "text", "font"]);
+function toRecordOutput(slot, value, label) {
+  const refs = collectAssetRefLikes(value);
+  const ref = refs.length === 1 ? refs[0] : null;
+  if (!ref || !isPersistedAssetRef(ref)) return null;
+  const kind = typeof ref.kind === "string" && OUTPUT_KINDS.has(ref.kind) ? ref.kind : null;
+  if (!kind) return null;
+  return {
+    slot,
+    label,
+    kind,
+    sha256: ref.sha256,
+    url: ref.url,
+    mime: ref.mime,
+    width: typeof ref.width === "number" ? ref.width : void 0,
+    height: typeof ref.height === "number" ? ref.height : void 0,
+    durationMs: typeof ref.duration_ms === "number" ? ref.duration_ms : void 0
+  };
+}
+function nodeOutputsToRecord(nodeOutputs, labels) {
+  const out = [];
+  for (const [slot, value] of Object.entries(nodeOutputs)) {
+    if (Array.isArray(value)) {
+      value.forEach((item, i) => {
+        const rec = toRecordOutput(`${slot}#${i}`, item, labels?.[i]);
+        if (rec) out.push(rec);
+      });
+    } else {
+      const rec = toRecordOutput(slot, value);
+      if (rec) out.push(rec);
+    }
+  }
+  return out.slice(0, MAX_OUTPUTS_PER_NODE);
+}
+function finalOutputsToRecord(output, labels) {
+  if (Array.isArray(output)) {
+    return output.map((item, i) => toRecordOutput(`final#${i}`, item, labels?.[i])).filter((rec2) => rec2 !== null).slice(0, MAX_FINAL_OUTPUTS);
+  }
+  const rec = toRecordOutput("final", output);
+  return rec ? [rec] : [];
+}
+function finalFiles(output, labels) {
+  const items = Array.isArray(output) ? output : [output];
+  const files = {};
+  items.forEach((item, i) => {
+    const ref = collectAssetRefLikes(item)[0];
+    if (ref && typeof ref.path === "string") files[labels?.[i] ?? `final#${i}`] = ref.path;
+  });
+  return files;
+}
+function withFacts(nodeOutputs) {
+  const facts = nodeOutputs.facts;
+  if (facts === void 0 || facts === null) return {};
+  const json = JSON.stringify(facts);
+  return json.length <= MAX_NODE_FACTS_CHARS ? { facts: json } : {};
+}
+function buildRunRecord(result, meta, plan, finalLabels) {
+  const nodes = result.node_runs.slice(0, MAX_RUN_NODES).map((run) => {
+    const planned = plan?.get(run.node_id);
+    return {
+      nodeId: run.node_id,
+      nodeType: run.node_type,
+      cached: run.cached,
+      credits: run.credits,
+      durationMs: run.duration_ms,
+      outputs: nodeOutputsToRecord(
+        result.outputs_by_node[run.node_id] ?? {},
+        run.node_id === finalLabels?.nodeId ? finalLabels.labels : void 0
+      ),
+      deps: planned?.deps,
+      status: plan ? "completed" : void 0,
+      paramsPreview: planned?.paramsPreview,
+      ...planned?.role !== void 0 ? { role: planned.role } : {},
+      ...withFacts(result.outputs_by_node[run.node_id] ?? {})
+    };
+  });
+  const finalOutputs = finalOutputsToRecord(result.output, finalLabels?.labels);
+  return {
+    runId: result.run_id,
+    ...meta,
+    status: "completed",
+    stats: {
+      totalNodes: result.stats.total_nodes,
+      cachedNodes: result.stats.cached_nodes,
+      totalCredits: result.stats.total_credits,
+      durationMs: result.stats.duration_ms
+    },
+    nodes,
+    finalOutputs: finalOutputs.length > 0 ? finalOutputs : void 0,
+    // Sent whenever the review RAN, empty list included. Sending it only when there
+    // were findings makes a clean render and an unreviewed one look identical in the
+    // record — which is the exact ambiguity this field was added to remove: proving a
+    // review had happened once meant re-running a cached canvas and reading raw JSON.
+    // Only the fields the backend keeps: a static review's typed fields (`kind`) stay in the CLI.
+    ...meta.review ? { review: meta.review.slice(0, 40).map(({ severity, what, scene }) => ({ severity, what, ...scene ? { scene } : {} })) } : {}
+  };
+}
+function buildInitialRunRecord(runId, meta) {
+  return {
+    runId,
+    ...meta,
+    status: "running",
+    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
+    nodes: []
+  };
+}
+function buildFailedRunRecord(runId, errorMessage, meta) {
+  return {
+    runId,
+    ...meta,
+    status: "failed",
+    errorMessage: errorMessage.slice(0, 2e3),
+    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
+    nodes: []
+  };
+}
+
+export {
+  creativeSlugFromCanvasPath,
+  finalOutputLabelsFromCanvas,
+  nodeOutputsToRecord,
+  finalFiles,
+  withFacts,
+  buildRunRecord,
+  buildInitialRunRecord,
+  buildFailedRunRecord
+};
+//# sourceMappingURL=chunk-ZJSGGJ5R.js.map

package/dist/claim-J2LYNHZK.js

@@ -0,0 +1,197 @@
+import {
+  failApi,
+  failValidation
+} from "./chunk-GBFL4TD2.js";
+import "./chunk-DAO63OOP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-WTJSMYY2.js";
+import {
+  apiPost,
+  validateConvexId
+} from "./chunk-XDZVBX6L.js";
+import "./chunk-N5O67GK5.js";
+import {
+  requireChatId
+} from "./chunk-EE72SSB2.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-WNSE7N75.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/claim.ts
+import { defineCommand } from "citty";
+
+// src/commands/actions/skillCatalog.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+var DESCRIPTION_MAX = 600;
+var SKILLS_SUBPATH = join(".claude", "skills");
+var EXCLUDED_SKILLS = /* @__PURE__ */ new Set(["actions"]);
+function stripQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\n/g, "\n");
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).replace(/''/g, "'");
+  }
+  return trimmed;
+}
+function extractFrontmatterLines(md) {
+  if (!md.startsWith("---")) return null;
+  const end = md.indexOf("\n---", 3);
+  if (end === -1) return null;
+  return md.slice(md.indexOf("\n", 3) + 1, end).split("\n");
+}
+var BLOCK_SCALAR = /^([|>])[+-]?$/;
+function collectBlockLines(lines, start) {
+  const collected = [];
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "") {
+      collected.push("");
+    } else if (/^\s/.test(line)) {
+      collected.push(line.trim());
+    } else {
+      break;
+    }
+  }
+  while (collected.length > 0 && collected.at(-1) === "") collected.pop();
+  return collected;
+}
+function foldLines(collected) {
+  const paragraphs = [];
+  let buffer = [];
+  for (const line of collected) {
+    if (line === "") {
+      if (buffer.length > 0) paragraphs.push(buffer.join(" "));
+      buffer = [];
+    } else {
+      buffer.push(line);
+    }
+  }
+  if (buffer.length > 0) paragraphs.push(buffer.join(" "));
+  return paragraphs.join("\n");
+}
+function readBlockScalar(lines, start, style) {
+  const collected = collectBlockLines(lines, start);
+  return style === "|" ? collected.join("\n") : foldLines(collected);
+}
+function readField(lines, field) {
+  for (let i = 0; i < lines.length; i++) {
+    const match = (lines[i] ?? "").match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match || match[1] !== field) continue;
+    const inline = (match[2] ?? "").trim();
+    const scalar = inline.match(BLOCK_SCALAR);
+    if (scalar) {
+      return readBlockScalar(lines, i + 1, scalar[1]);
+    }
+    return stripQuotes(inline);
+  }
+  return null;
+}
+function parseSkillFrontmatter(md) {
+  const lines = extractFrontmatterLines(md);
+  if (!lines) return null;
+  const name = readField(lines, "name");
+  const description = readField(lines, "description");
+  if (!name || !description) return null;
+  const trimmed = description.length > DESCRIPTION_MAX ? `${description.slice(0, DESCRIPTION_MAX)}\u2026` : description;
+  return { name, description: trimmed };
+}
+function findSkillsDir(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    const candidate = join(dir, SKILLS_SUBPATH);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readSkillCatalog(startDir) {
+  const skillsDir = findSkillsDir(startDir);
+  if (!skillsDir) return [];
+  const entries = [];
+  for (const dirent of readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!dirent.isDirectory() || EXCLUDED_SKILLS.has(dirent.name)) continue;
+    const skillFile = join(skillsDir, dirent.name, "SKILL.md");
+    if (!existsSync(skillFile)) continue;
+    try {
+      const parsed = parseSkillFrontmatter(readFileSync(skillFile, "utf8"));
+      if (parsed) entries.push(parsed);
+    } catch {
+    }
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/commands/actions/claim.ts
+registerSchema({
+  command: "actions.claim",
+  description: "Claim an action for the current chat (live \u2014 visible to other chats immediately). Claim only what you're actively working on now: it's required before `complete`, but NOT for `update` or `discard` (those stage without a claim). Returns action details plus a fast-model recommendation of which skills to load for the work (`recommendedSkills`) and a routing hint: load every skill that owns part of the work and the tool doc for each baker CLI family you'll use.",
+  args: {
+    id: { type: "string", description: "Action ID", required: true }
+  }
+});
+async function recommendSkills(actionId) {
+  const skills = readSkillCatalog(process.cwd());
+  if (skills.length === 0) return [];
+  const response = await apiPost("/api/actions/recommend-skills", {
+    actionId,
+    skills
+  });
+  return response.data.recommendations;
+}
+var ROUTING_HINT = "Actions often span several surfaces (a landing page plus a Google Ads change, a sheet pull plus an audience upload). Before starting, load EVERY skill that owns part of the work and read the tool doc (__tooling__/docs/tools/baker/<family>.md) for each baker CLI family you'll use. If the action references source material living in a connected tool (an email attachment, a call, a CRM record, a spreadsheet), reach for that tool too. If it describes recurring or future-dated work, it belongs on a schedule \u2014 see __tooling__/docs/tools/baker/scheduled-agents.md.";
+function buildHints(recommendations) {
+  if (recommendations.length === 0) {
+    return ["Review the action name, description, and tags above.", ROUTING_HINT];
+  }
+  return [
+    "Recommended skills for this action (load the ones you'll use):",
+    ...recommendations.map((r) => `  /${r.name} \u2014 ${r.reason}`),
+    "Suggestions come from the action's name/description/tags only \u2014 the work may need more.",
+    ROUTING_HINT
+  ];
+}
+var claimCommand = defineCommand({
+  meta: {
+    name: "claim",
+    description: "Claim an action so other chats see you're working on it. Required before `complete` (update and discard don't need a claim). Example: baker actions claim <action-id>"
+  },
+  args: {
+    id: { type: "positional", description: "Action ID", required: false },
+    "action-id": { type: "string", description: "Action ID", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id || args["action-id"];
+      if (!id) {
+        failValidation("Action ID is required.");
+      }
+      validateConvexId(id);
+      const chatId = requireChatId();
+      const response = await apiPost("/api/actions/claim", {
+        actionId: id,
+        chatId
+      });
+      let recommendedSkills = [];
+      try {
+        recommendedSkills = await recommendSkills(id);
+      } catch {
+      }
+      const data = response.data ? { ...response.data, recommendedSkills } : response.data;
+      writeJson({ ok: response.ok, data, hints: buildHints(recommendedSkills) });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  claimCommand
+};
+//# sourceMappingURL=claim-J2LYNHZK.js.map

package/dist/cli.js

@@ -112,41 +112,41 @@ Formats: --output json works on every command that prints the envelope. --output
 Introspection: Run 'baker schema <command>' to inspect argument schemas.`
   },
   subCommands: {
-    capabilities: () => import("./capabilities-2KT6TCGZ.js").then((m) => m.capabilitiesCommand),
-    actions: () => import("./actions-HNLISA7T.js").then((m) => m.actionsCommand),
-    "scheduled-agents": () => import("./scheduled-agents-FCQHQ6KR.js").then((m) => m.scheduledAgentsCommand),
-    ads: () => import("./ads-G6AS5L7G.js").then((m) => m.adsCommand),
-    brand: () => import("./brand-T3OACVQX.js").then((m) => m.brandCommand),
-    analytics: () => import("./analytics-QKP3A5F3.js").then((m) => m.analyticsCommand),
-    experiment: () => import("./experiment-G3FQVAJU.js").then((m) => m.experimentCommand),
-    ga4: () => import("./ga4-2BL5YAYN.js").then((m) => m.ga4Command),
-    gsc: () => import("./gsc-UU3T2C6B.js").then((m) => m.gscCommand),
-    research: () => import("./research-BLDY5UWH.js").then((m) => m.researchCommand),
+    capabilities: () => import("./capabilities-SNGGAOV3.js").then((m) => m.capabilitiesCommand),
+    actions: () => import("./actions-QMUHOAXG.js").then((m) => m.actionsCommand),
+    "scheduled-agents": () => import("./scheduled-agents-HDABMHZI.js").then((m) => m.scheduledAgentsCommand),
+    ads: () => import("./ads-HGDPNIT6.js").then((m) => m.adsCommand),
+    brand: () => import("./brand-MXGETE4R.js").then((m) => m.brandCommand),
+    analytics: () => import("./analytics-VH74LMMC.js").then((m) => m.analyticsCommand),
+    experiment: () => import("./experiment-7N4QFRWV.js").then((m) => m.experimentCommand),
+    ga4: () => import("./ga4-LPDIBNYP.js").then((m) => m.ga4Command),
+    gsc: () => import("./gsc-FIZTQX3N.js").then((m) => m.gscCommand),
+    research: () => import("./research-LOQRIBO6.js").then((m) => m.researchCommand),
     decide: () => import("./decide-TWKH5QQU.js").then((m) => m.decideCommand),
-    creatives: () => import("./creatives-S5QUWUL6.js").then((m) => m.creativesCommand),
-    flows: () => import("./flows-Z7355RMD.js").then((m) => m.flowsCommand),
-    funnel: () => import("./funnel-2B3JXJPX.js").then((m) => m.funnelCommand),
-    images: () => import("./images-WCKTD6Z2.js").then((m) => m.imagesCommand),
-    studio: () => import("./studio-MARZ22J2.js").then((m) => m.studioCommand),
-    avatars: () => import("./avatars-MXTI74VC.js").then((m) => m.avatarsCommand),
-    landing: () => import("./landing-WUILAWDS.js").then((m) => m.landingCommand),
-    videos: () => import("./videos-I6YXFBFT.js").then((m) => m.videosCommand),
-    testimonials: () => import("./testimonials-YMMA5YWL.js").then((m) => m.testimonialsCommand),
-    canvas: () => import("./canvas-GJAQAVS6.js").then((m) => m.canvasCommand),
-    tags: () => import("./tags-B473RWAA.js").then((m) => m.tagsCommand),
-    "tag-manager": () => import("./tag-manager-G3LBQZUL.js").then((m) => m.tagManagerCommand),
-    chats: () => import("./chats-INN2OHSH.js").then((m) => m.chatsCommand),
-    history: () => import("./history-YMK2JNZU.js").then((m) => m.historyCommand),
-    credentials: () => import("./credentials-YTQ6BHWV.js").then((m) => m.credentialsCommand),
-    hubspot: () => import("./hubspot-BUFS7S33.js").then((m) => m.hubspotCommand),
-    activecampaign: () => import("./activecampaign-I5CILZPU.js").then((m) => m.activecampaignCommand),
-    accounts: () => import("./accounts-RTN5ZGTU.js").then((m) => m.accountsCommand),
-    "winning-ads": () => import("./winning-ads-ABN5OULS.js").then((m) => m.winningAdsCommand),
-    "media-sources": () => import("./media-sources-PEHUMH7C.js").then((m) => m.mediaSourcesCommand),
-    site: () => import("./site-PZPJY33N.js").then((m) => m.siteCommand),
-    mcp: () => import("./mcp-RKAXC6IP.js").then((m) => m.mcpCommand),
-    "setup-links": () => import("./setup-links-QVI6NAOK.js").then((m) => m.setupLinksCommand),
-    organization: () => import("./organization-SHREKDST.js").then((m) => m.organizationCommand),
+    creatives: () => import("./creatives-HYPSTANO.js").then((m) => m.creativesCommand),
+    flows: () => import("./flows-CVORIQ4B.js").then((m) => m.flowsCommand),
+    funnel: () => import("./funnel-XLKDLXMG.js").then((m) => m.funnelCommand),
+    images: () => import("./images-TWZOROCT.js").then((m) => m.imagesCommand),
+    studio: () => import("./studio-ZLCGXFAN.js").then((m) => m.studioCommand),
+    avatars: () => import("./avatars-VEATUUKU.js").then((m) => m.avatarsCommand),
+    landing: () => import("./landing-VFDRADZY.js").then((m) => m.landingCommand),
+    videos: () => import("./videos-5IDZTEWC.js").then((m) => m.videosCommand),
+    testimonials: () => import("./testimonials-WT43CF7V.js").then((m) => m.testimonialsCommand),
+    canvas: () => import("./canvas-VJ3XKCAC.js").then((m) => m.canvasCommand),
+    tags: () => import("./tags-RIVD54ZG.js").then((m) => m.tagsCommand),
+    "tag-manager": () => import("./tag-manager-3CJ66GKJ.js").then((m) => m.tagManagerCommand),
+    chats: () => import("./chats-2DRTB7GK.js").then((m) => m.chatsCommand),
+    history: () => import("./history-43BBQZOB.js").then((m) => m.historyCommand),
+    credentials: () => import("./credentials-4H4AUYJN.js").then((m) => m.credentialsCommand),
+    hubspot: () => import("./hubspot-S44MPK3G.js").then((m) => m.hubspotCommand),
+    activecampaign: () => import("./activecampaign-J3QN5FMG.js").then((m) => m.activecampaignCommand),
+    accounts: () => import("./accounts-AQFW4ZUM.js").then((m) => m.accountsCommand),
+    "winning-ads": () => import("./winning-ads-I4DMP7RU.js").then((m) => m.winningAdsCommand),
+    "media-sources": () => import("./media-sources-VMMMW5UM.js").then((m) => m.mediaSourcesCommand),
+    site: () => import("./site-NV4U7PIF.js").then((m) => m.siteCommand),
+    mcp: () => import("./mcp-GFKHLWDB.js").then((m) => m.mcpCommand),
+    "setup-links": () => import("./setup-links-CNNJA7AB.js").then((m) => m.setupLinksCommand),
+    organization: () => import("./organization-BVTXCZIV.js").then((m) => m.organizationCommand),
     schema: () => import("./schema-XKEEAUXP.js").then((m) => m.schemaCommand)
   }
 });