@runcofactor/cli 0.10.0

package/dist/spec-RA3CFEKG.js

@@ -0,0 +1,951 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  ApiSequenceFileSchema,
+  diffWorkflow,
+  emitSpec,
+  extractPreservedFrontmatter,
+  hasAnyChange,
+  lintSpec,
+  parseSpec,
+  reconcileLinearEdges,
+  summarize,
+  workflowToSpec,
+  writeNodeIds,
+  writeWorkflowId
+} from "./chunk-B2VISN2V.js";
+import "./chunk-SJJW77WN.js";
+import {
+  fetchOrExit
+} from "./chunk-3CZU7XCS.js";
+import {
+  getArgValue,
+  hasFlag,
+  resolveAppUrl
+} from "./chunk-A4OFTUVV.js";
+import "./chunk-VKVL7WBN.js";
+
+// src/spec/index.ts
+import fs from "fs/promises";
+import path from "path";
+import process from "process";
+
+// src/spec/sync.ts
+async function applyDiff(ctx, diff, emitted, live) {
+  const deletes = diff.ops.filter((o) => o.kind === "delete");
+  if (deletes.length > 0) {
+    await postJson(ctx, `/workflows/${ctx.workflowId}/nodes/bulk-delete`, {
+      nodeIds: deletes.map((o) => o.nodeId),
+      reconnect: true
+    });
+  }
+  const creates = diff.ops.filter((o) => o.kind === "create");
+  const createdIds = /* @__PURE__ */ new Map();
+  const writebackPairs = [];
+  for (const op of creates) {
+    const res = await postJson(
+      ctx,
+      `/workflows/${ctx.workflowId}/nodes`,
+      {
+        nodeType: op.nodeType,
+        configJson: op.configJson,
+        orderIndex: op.orderIndex
+      }
+    );
+    const created = res.node;
+    if (!created) {
+      throw new Error(
+        `Failed to create node at orderIndex ${op.orderIndex}: ${res.error ?? JSON.stringify(res)}`
+      );
+    }
+    createdIds.set(op.specIndex, created.id);
+    if (op.sourceLine !== void 0) {
+      writebackPairs.push({ sourceLine: op.sourceLine, nodeId: created.id });
+    }
+  }
+  const updates = diff.ops.filter((o) => o.kind === "update");
+  for (const op of updates) {
+    if (!op.changes.configChanged && !op.changes.orderChanged) continue;
+    await putJson(ctx, `/workflows/${ctx.workflowId}/nodes/${op.nodeId}`, {
+      ...op.changes.configChanged ? { configJson: op.configJson } : {},
+      ...op.changes.orderChanged ? { orderIndex: op.orderIndex } : {}
+    });
+  }
+  if (diff.ops.length > 0) {
+    const finalNodeIds = computeFinalNodeOrder(diff, live, createdIds);
+    const fresh = await getJson(
+      ctx,
+      `/workflows/${ctx.workflowId}`
+    );
+    const liveEdges = fresh.workflow?.edges ?? live.edges ?? [];
+    const { ops: edgeOps } = reconcileLinearEdges(finalNodeIds, liveEdges);
+    for (const op of edgeOps) {
+      if (op.kind === "delete") {
+        await deleteJson(ctx, `/workflows/${ctx.workflowId}/edges/${op.edgeId}`);
+      } else {
+        await postJson(ctx, `/workflows/${ctx.workflowId}/edges`, {
+          sourceNodeId: op.sourceNodeId,
+          targetNodeId: op.targetNodeId,
+          edgeType: "default"
+        });
+      }
+    }
+  }
+  rejectUnsupportedFieldEdits(diff.workflowFieldChanges);
+  if (Object.keys(diff.workflowFieldChanges).length > 0) {
+    const payload = await resolveFieldUpdatePayload(ctx, diff.workflowFieldChanges);
+    await putJson(ctx, `/workflows/${ctx.workflowId}`, payload);
+  }
+  if (emitted.apiSequenceConfig) {
+    await postJson(ctx, `/api-sequences/save`, {
+      workflowId: ctx.workflowId,
+      config: emitted.apiSequenceConfig
+    });
+  }
+  return { created: writebackPairs };
+}
+async function resolveTeardownWorkflowId(ctx, specName) {
+  const res = await getJson(
+    ctx,
+    `/workflows?search=${encodeURIComponent(specName)}&flowType=teardown&pageSize=50`
+  );
+  const match = (res.data ?? []).find(
+    (w) => w.name === specName && w.flowType === "teardown"
+  );
+  if (!match) {
+    throw new Error(
+      `Teardown workflow "${specName}" not found (flowType=teardown). Compile the teardown spec first so the seed can link to it by name.`
+    );
+  }
+  return match.id;
+}
+async function resolveFieldUpdatePayload(ctx, changes) {
+  const payload = fieldUpdatePayload(changes);
+  if ("teardownSpec" in payload) {
+    const specName = payload.teardownSpec;
+    delete payload.teardownSpec;
+    if (specName === null) {
+      payload.teardownWorkflowId = null;
+    } else if (typeof specName === "string") {
+      payload.teardownWorkflowId = await resolveTeardownWorkflowId(ctx, specName);
+    }
+  }
+  if ("teardownSnapshotVersion" in payload) {
+    if (payload.teardownSnapshotVersion === "latest") payload.teardownSnapshotVersion = null;
+  }
+  if ("seedOutputs" in payload) {
+    const inputRows = payload.seedOutputs;
+    delete payload.seedOutputs;
+    if (inputRows) {
+      const propIds = await resolvePropertyNameMap(
+        ctx,
+        Array.from(new Set(inputRows.map((r) => r.propertyName).filter((p) => !!p)))
+      );
+      payload.seedOutputsJson = inputRows.map((r) => {
+        const propertyId = r.propertyName ? propIds.get(r.propertyName) : void 0;
+        if (r.propertyName && !propertyId) {
+          throw new Error(
+            `Declared output "${r.dataKey}": property "${r.propertyName}" not found in this org.`
+          );
+        }
+        return {
+          dataKey: r.dataKey,
+          name: r.dataKey,
+          displayLabel: r.label ?? r.dataKey,
+          ...r.description ? { description: r.description } : {},
+          ...propertyId ? { propertyId } : {},
+          ...r.credentialOutput !== void 0 ? { credentialOutput: r.credentialOutput } : {},
+          ...r.attributes !== void 0 ? { attributes: r.attributes } : {}
+        };
+      });
+    }
+  }
+  return payload;
+}
+async function resolvePropertyNameMap(ctx, names) {
+  const out = /* @__PURE__ */ new Map();
+  if (names.length === 0) return out;
+  const res = await getJson(ctx, `/org/properties`);
+  const all = res.data ?? res.properties ?? [];
+  for (const want of names) {
+    const match = all.find((p) => p.name === want);
+    if (match) out.set(want, match.id);
+  }
+  return out;
+}
+var UnsupportedFieldEditError = class extends Error {
+  constructor(fields) {
+    super(
+      `Editing ${fields.join(", ")} via .canary.md is not supported yet. These fields require name \u2192 id resolution that lands in a follow-up. Edit them in the Canary UI for now; the rest of your changes will still apply.`
+    );
+    this.name = "UnsupportedFieldEditError";
+  }
+};
+function rejectUnsupportedFieldEdits(changes) {
+  const unsupported = ["tags", "environmentConstraints", "sandboxTemplate"].filter(
+    (k) => changes[k] !== void 0
+  );
+  if (unsupported.length > 0) throw new UnsupportedFieldEditError(unsupported);
+}
+function computeFinalNodeOrder(diff, live, createdIds) {
+  const liveById = new Map(live.nodes.map((n) => [n.id, n]));
+  const total = diff.ops.filter((o) => o.kind !== "delete").length;
+  const result = Array.from({ length: total });
+  for (const op of diff.ops) {
+    if (op.kind === "create") {
+      const id = createdIds.get(op.specIndex);
+      if (!id) throw new Error(`Missing created node id for specIndex ${op.specIndex}`);
+      result[op.specIndex] = id;
+    } else if (op.kind === "update") {
+      if (!liveById.has(op.nodeId)) {
+        throw new Error(`UPDATE references nodeId ${op.nodeId} not in live workflow`);
+      }
+      result[op.specIndex] = op.nodeId;
+    }
+  }
+  return result;
+}
+function fieldUpdatePayload(changes) {
+  const payload = {};
+  for (const k of Object.keys(changes)) {
+    if (k === "scenariosJson" && Array.isArray(changes.scenariosJson)) {
+      payload.scenariosJson = changes.scenariosJson.map((s) => {
+        const { skipReason: _skip, ...rest } = s;
+        return rest;
+      });
+    } else {
+      payload[k] = changes[k];
+    }
+  }
+  return payload;
+}
+async function postJson(ctx, path2, body) {
+  const res = await fetchOrExit(`${ctx.apiUrl}${path2}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${ctx.token}`,
+      "Content-Type": "application/json"
+    },
+    token: ctx.token,
+    body: JSON.stringify(body)
+  });
+  return await res.json();
+}
+async function putJson(ctx, path2, body) {
+  const res = await fetchOrExit(`${ctx.apiUrl}${path2}`, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${ctx.token}`,
+      "Content-Type": "application/json"
+    },
+    token: ctx.token,
+    body: JSON.stringify(body)
+  });
+  return await res.json();
+}
+async function getJson(ctx, path2) {
+  const res = await fetchOrExit(`${ctx.apiUrl}${path2}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${ctx.token}` },
+    token: ctx.token
+  });
+  return await res.json();
+}
+async function deleteJson(ctx, path2) {
+  const res = await fetchOrExit(`${ctx.apiUrl}${path2}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${ctx.token}` },
+    token: ctx.token
+  });
+  return await res.json();
+}
+
+// src/spec/index.ts
+async function handleSpec(argv, apiUrl, token) {
+  const sub = argv[0];
+  switch (sub) {
+    case "validate":
+      await handleValidate(argv.slice(1));
+      return;
+    case "compile":
+      await handleCompile(argv.slice(1), apiUrl, token);
+      return;
+    case "pull":
+      await handlePull(argv.slice(1), apiUrl, token);
+      return;
+    case "diff":
+      await handleDiff(argv.slice(1), apiUrl, token);
+      return;
+    default:
+      printSpecHelp();
+      process.exit(sub ? 1 : 0);
+  }
+}
+function printSpecHelp() {
+  console.log(
+    [
+      "Usage: canary spec <subcommand> <file>",
+      "",
+      "Subcommands:",
+      "  validate <file>           Parse + lint the spec offline",
+      "  compile  <file>           Validate, then create the workflow",
+      "  diff     <file>           Preview what `compile` would change (no writes)",
+      "  pull     <workflow-id>    Reverse: workflow \u2192 round-trippable .canary.md",
+      "  pull     --all            Sync a directory of specs down from all workflows",
+      "",
+      "Compile flags:",
+      "  --publish                 Create as published instead of draft",
+      "  --run-and-publish         After create, trigger a test run; publish if green",
+      "  --allow-duplicate         Fresh compile: create even when a same-named workflow exists",
+      "  --create-with-duplicate-title",
+      "                            Alias for --allow-duplicate",
+      "  --json                    Machine-readable output",
+      "",
+      "Pull flags:",
+      "  --output <path|dir>       File (single) or directory (--all); default canary/specs/",
+      "  --all                     Sync every workflow into the directory (add new, update matching by workflowId)",
+      "  --status <s>              With --all, filter workflows by status (draft|published|\u2026)",
+      "  --force                   Overwrite an existing file (single pull)"
+    ].join("\n")
+  );
+}
+async function handleValidate(argv) {
+  const file = argv[0];
+  if (!file) {
+    console.error("Error: canary spec validate <file>");
+    process.exit(1);
+  }
+  const json = hasFlag(argv, "--json");
+  const result = await loadAndValidate(file);
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          ok: result.ok,
+          issues: result.issues,
+          ...result.ok ? { workflowName: result.ast.frontmatter.name } : {}
+        },
+        null,
+        2
+      )
+    );
+    process.exit(result.ok ? 0 : 1);
+  }
+  printIssues(result.issues, file);
+  if (!result.ok) {
+    process.exit(1);
+  }
+  console.log(`\u2713 ${file} validates`);
+}
+async function handleCompile(argv, apiUrl, token) {
+  const file = argv[0];
+  if (!file) {
+    console.error("Error: canary spec compile <file>");
+    process.exit(1);
+  }
+  const result = await loadAndValidate(file);
+  printIssues(result.issues, file);
+  if (!result.ok) {
+    process.exit(1);
+  }
+  const ast = result.ast;
+  const emitted = emitSpec(ast, { appendDefaultEnd: !ast.frontmatter.workflowId });
+  try {
+    emitted.apiSequenceConfig = await loadApiSequenceSidecar(emitted.nodes, file);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  if (emitted.workflowId) {
+    await runRecompile({ argv, apiUrl, token, file, emitted });
+    return;
+  }
+  await runFreshCompile({ argv, apiUrl, token, file, emitted });
+}
+async function loadApiSequenceSidecar(nodes, specFile) {
+  const refs = nodes.filter((n) => n.nodeType === "api_sequence").map((n) => n.configJson["__apiSequenceSidecar"]).filter((p) => typeof p === "string" && p.length > 0);
+  if (refs.length === 0) return void 0;
+  const unique = Array.from(new Set(refs));
+  if (unique.length > 1) {
+    throw new Error(
+      `Spec has divergent api_sequence sidecar paths: ${unique.map((p) => `"${p}"`).join(", ")}. The DB stores one config per workflow \u2014 pick a single path.`
+    );
+  }
+  const sidecarPath = path.resolve(path.dirname(specFile), unique[0]);
+  let raw;
+  try {
+    raw = await fs.readFile(sidecarPath, "utf-8");
+  } catch (err) {
+    throw new Error(
+      `Could not read api_sequence sidecar at ${sidecarPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const yaml = await import("yaml");
+  let parsed;
+  try {
+    parsed = yaml.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `Sidecar YAML at ${sidecarPath} is invalid: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const validated = ApiSequenceFileSchema.safeParse(parsed);
+  if (!validated.success) {
+    throw new Error(
+      `Sidecar at ${sidecarPath} doesn't match the api_sequence shape: ${validated.error.message}`
+    );
+  }
+  return validated.data;
+}
+async function handleDiff(argv, apiUrl, token) {
+  const file = argv[0];
+  if (!file) {
+    console.error("Error: canary spec diff <file>");
+    process.exit(1);
+  }
+  const result = await loadAndValidate(file);
+  printIssues(result.issues, file);
+  if (!result.ok) process.exit(1);
+  const emitted = emitSpec(result.ast, { appendDefaultEnd: false });
+  if (!emitted.workflowId) {
+    console.log(
+      `\u2139 ${file} has no workflowId in frontmatter \u2014 \`canary spec compile\` would create a new workflow.`
+    );
+    console.log(`  Nodes that would be created: ${emitted.nodes.length}`);
+    return;
+  }
+  const liveRes = await fetchOrExit(`${apiUrl}/workflows/${emitted.workflowId}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` },
+    token
+  });
+  if (!liveRes.ok) {
+    console.error(`Error: failed to fetch workflow ${emitted.workflowId} (${liveRes.status})`);
+    process.exit(1);
+  }
+  const liveBody = await liveRes.json().catch(() => ({}));
+  const live = liveBody.workflow;
+  if (!live) {
+    console.error(`Error: workflow ${emitted.workflowId} not found.`);
+    process.exit(1);
+  }
+  let diff;
+  try {
+    diff = diffWorkflow(emitted, live);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify({ ok: true, summary: summarize(diff), diff }, null, 2));
+    return;
+  }
+  if (!hasAnyChange(diff)) {
+    console.log(`\u2713 ${file} \u2014 in sync with workflow ${emitted.workflowId}`);
+    return;
+  }
+  const s = summarize(diff);
+  console.log(`
+Preview for "${live.name}" (${emitted.workflowId}):`);
+  console.log(
+    `  +${s.created} create  \xB7  ~${s.updated} update  \xB7  -${s.deleted} delete  \xB7  \u21BB ${s.moved} move`
+  );
+  if (diff.nameDrift) console.log(`  \u270E rename: "${diff.nameDrift.from}" \u2192 "${diff.nameDrift.to}"`);
+  const fieldKeys = Object.keys(diff.workflowFieldChanges).filter((k) => k !== "name");
+  if (fieldKeys.length > 0) console.log(`  \u270E workflow fields: ${fieldKeys.join(", ")}`);
+  console.log(`
+Run \`canary spec compile ${file}\` to apply.`);
+}
+async function handlePull(argv, apiUrl, token) {
+  if (hasFlag(argv, "--all")) {
+    await handlePullAll(argv, apiUrl, token);
+    return;
+  }
+  const workflowId = argv.find((a) => !a.startsWith("-"));
+  if (!workflowId) {
+    console.error("Error: canary spec pull <workflow-id> [--output <path>] [--force]");
+    console.error("       canary spec pull --all [--output <dir>] [--status <s>] [--force]");
+    process.exit(1);
+  }
+  const json = hasFlag(argv, "--json");
+  const force = hasFlag(argv, "--force");
+  const live = await fetchWorkflow(apiUrl, token, workflowId);
+  if (!live) {
+    console.error(`Error: workflow ${workflowId} not found (or no permission).`);
+    process.exit(1);
+  }
+  const outPath = getArgValue(argv, "--output") ?? path.join("canary", "specs", `${slugify(live.name)}.canary.md`);
+  const preserved = await readPreservedFrontmatter(outPath);
+  const sidecarPath = await fetchAndWriteApiSequenceSidecar(
+    apiUrl,
+    token,
+    workflowId,
+    live,
+    outPath
+  );
+  if (sidecarPath) {
+    for (const node of live.nodes) {
+      if (node.nodeType === "api_sequence") {
+        node.configJson = {
+          ...node.configJson,
+          __apiSequenceSidecar: path.relative(path.dirname(outPath), sidecarPath)
+        };
+      }
+    }
+  }
+  const source = workflowToSpec(live, preserved);
+  const parsed = parseSpec(source);
+  const lintIssues = parsed.ok ? lintSpec(parsed.ast) : [];
+  const parseIssues = parsed.ok ? [] : parsed.issues;
+  const issues = [...parseIssues, ...lintIssues];
+  if (!force) {
+    try {
+      await fs.access(outPath);
+      console.error(
+        `Error: ${outPath} already exists. Use --output <path> or --force to overwrite.`
+      );
+      process.exit(1);
+    } catch {
+    }
+  }
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  await fs.writeFile(outPath, source, "utf-8");
+  if (json) {
+    console.log(JSON.stringify({ ok: true, file: outPath, workflowId, issues }, null, 2));
+    return;
+  }
+  console.log(`
+\u2713 Pulled "${live.name}" \u2192 ${outPath}`);
+  console.log(`  Nodes:  ${live.nodes.length}`);
+  console.log(`  Edit the file, then \`canary spec compile ${outPath}\` to push changes back.`);
+  if (issues.length > 0) {
+    console.log("\n  Notes:");
+    printIssues(issues, outPath);
+  }
+}
+async function handlePullAll(argv, apiUrl, token) {
+  const json = hasFlag(argv, "--json");
+  const dir = getArgValue(argv, "--output") ?? argv.find((a) => !a.startsWith("-")) ?? path.join("canary", "specs");
+  const status = getArgValue(argv, "--status");
+  const workflows = await fetchWorkflowList(apiUrl, token, status);
+  const byWorkflowId = await indexSpecFiles(dir);
+  const usedNames = new Set([...byWorkflowId.values()].map((p) => path.basename(p)));
+  const results = [];
+  for (const wf of workflows) {
+    const live = await fetchWorkflow(apiUrl, token, wf.id);
+    if (!live) {
+      results.push({ id: wf.id, name: wf.name, file: "", action: "failed", note: "fetch failed" });
+      continue;
+    }
+    const existing = byWorkflowId.get(wf.id);
+    let target;
+    let isNew = false;
+    if (existing) {
+      target = existing;
+    } else {
+      target = path.join(dir, uniqueName(slugify(live.name), wf.id, usedNames));
+      usedNames.add(path.basename(target));
+      isNew = true;
+    }
+    let prior = null;
+    try {
+      prior = await fs.readFile(target, "utf-8");
+    } catch {
+    }
+    const preserved = prior ? extractPreservedFrontmatter(prior) : {};
+    const source = workflowToSpec(live, preserved);
+    if (prior === source) {
+      results.push({ id: wf.id, name: live.name, file: target, action: "unchanged" });
+      continue;
+    }
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.writeFile(target, source, "utf-8");
+    results.push({ id: wf.id, name: live.name, file: target, action: isNew ? "added" : "synced" });
+  }
+  if (json) {
+    console.log(JSON.stringify({ ok: true, dir, results }, null, 2));
+    return;
+  }
+  const count = (a) => results.filter((r) => r.action === a).length;
+  console.log(`
+\u2713 Synced ${results.length} workflow(s) \u2192 ${dir}`);
+  console.log(
+    `  +${count("added")} added  \xB7  ~${count("synced")} synced  \xB7  =${count("unchanged")} unchanged${count("failed") ? `  \xB7  \u2717${count("failed")} failed` : ""}`
+  );
+  for (const r of results) {
+    if (r.action === "unchanged") continue;
+    const mark = r.action === "added" ? "+" : r.action === "synced" ? "~" : "\u2717";
+    console.log(
+      `  ${mark} ${path.relative(process.cwd(), r.file) || r.file}${r.note ? `  (${r.note})` : ""}`
+    );
+  }
+}
+async function fetchAndWriteApiSequenceSidecar(apiUrl, token, workflowId, live, outPath) {
+  if (!live.nodes.some((n) => n.nodeType === "api_sequence")) return null;
+  const res = await fetchOrExit(`${apiUrl}/api-sequences/by-workflow/${workflowId}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` },
+    token
+  });
+  if (!res.ok) {
+    return null;
+  }
+  const body = await res.json().catch(() => ({}));
+  const config = body.data?.config;
+  if (!config) return null;
+  const sequencesDir = path.join(path.dirname(outPath), "sequences");
+  const sidecarSlug = slugify(live.name);
+  const sidecarPath = path.join(sequencesDir, `${sidecarSlug}.yaml`);
+  await fs.mkdir(sequencesDir, { recursive: true });
+  const yaml = await import("yaml");
+  await fs.writeFile(sidecarPath, yaml.stringify(config), "utf-8");
+  return sidecarPath;
+}
+async function readPreservedFrontmatter(target) {
+  try {
+    const prior = await fs.readFile(target, "utf-8");
+    return extractPreservedFrontmatter(prior);
+  } catch {
+    return {};
+  }
+}
+async function fetchWorkflow(apiUrl, token, workflowId) {
+  const res = await fetchOrExit(`${apiUrl}/workflows/${workflowId}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` },
+    token
+  });
+  if (!res.ok) return null;
+  const body = await res.json().catch(() => ({}));
+  return body.workflow ?? null;
+}
+async function fetchWorkflowList(apiUrl, token, status) {
+  const out = [];
+  let page = 1;
+  for (; ; ) {
+    const params = new URLSearchParams({ page: String(page), pageSize: "100" });
+    if (status) params.set("status", status);
+    const res = await fetchOrExit(`${apiUrl}/workflows?${params.toString()}`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${token}` },
+      token
+    });
+    if (!res.ok) {
+      console.error(`Error: failed to list workflows (${res.status})`);
+      process.exit(1);
+    }
+    const body = await res.json().catch(() => ({}));
+    for (const w of body.data ?? []) out.push({ id: w.id, name: w.name });
+    const pg = body.pagination;
+    if (!pg || pg.page >= pg.totalPages || (body.data ?? []).length === 0) break;
+    page += 1;
+  }
+  return out;
+}
+async function indexSpecFiles(dir) {
+  const map = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { recursive: true });
+  } catch {
+    return map;
+  }
+  const ID_RE = /^workflowId:\s*([0-9a-f-]{36})\s*$/im;
+  for (const rel of entries) {
+    if (!rel.endsWith(".canary.md")) continue;
+    const full = path.join(dir, rel);
+    try {
+      const src = await fs.readFile(full, "utf-8");
+      const m = ID_RE.exec(src);
+      if (m && !map.has(m[1])) map.set(m[1], full);
+    } catch {
+    }
+  }
+  return map;
+}
+function uniqueName(slug, workflowId, used) {
+  let name = `${slug}.canary.md`;
+  if (used.has(name)) name = `${slug}-${workflowId.slice(0, 8)}.canary.md`;
+  return name;
+}
+async function runFreshCompile(opts) {
+  const { argv, apiUrl, token, file, emitted } = opts;
+  const duplicateMatches = await fetchFreshCompileDuplicateWorkflows({
+    argv,
+    apiUrl,
+    token,
+    workflowName: emitted.name
+  });
+  if (duplicateMatches.length > 0) {
+    const message = formatDuplicateWorkflowTitleWarning({
+      file,
+      workflowName: emitted.name,
+      matches: duplicateMatches
+    });
+    if (hasFlag(argv, "--json")) {
+      console.log(
+        JSON.stringify(
+          {
+            ok: false,
+            error: "duplicate_workflow_title",
+            message,
+            workflows: duplicateMatches
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(message);
+    }
+    process.exit(1);
+  }
+  const status = hasFlag(argv, "--publish") ? "published" : emitted.status ?? "draft";
+  const payload = {
+    name: emitted.name,
+    description: emitted.description,
+    preflight: emitted.preflight,
+    cleanup: emitted.cleanup,
+    status,
+    flowType: emitted.flowType,
+    createdVia: "cli-spec",
+    // The route only knows about (nodeType, configJson) — strip our meta.
+    nodes: emitted.nodes.map(({ nodeType, configJson }) => ({ nodeType, configJson })),
+    ...emitted.inputsJson.length > 0 ? { inputsJson: emitted.inputsJson } : {},
+    ...emitted.scenariosJson.length > 0 ? { scenariosJson: emitted.scenariosJson } : {}
+  };
+  const res = await fetchOrExit(`${apiUrl}/workflows/create-with-nodes`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    token,
+    body: JSON.stringify(payload)
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.ok || !body.workflow) {
+    console.error(`Error: ${body.error ?? `${res.status} ${res.statusText}`}`);
+    process.exit(1);
+  }
+  const writebackPairs = [];
+  if (body.nodes && body.nodes.length === emitted.nodes.length) {
+    for (let i = 0; i < emitted.nodes.length; i++) {
+      const sourceLine = emitted.nodes[i].sourceLine;
+      if (sourceLine === void 0) continue;
+      writebackPairs.push({ sourceLine, nodeId: body.nodes[i].id });
+    }
+  }
+  try {
+    const source = await fs.readFile(file, "utf-8");
+    const withWorkflowId = writeWorkflowId(source, body.workflow.id);
+    const lineShift = withWorkflowId.split("\n").length - source.split("\n").length;
+    const shiftedPairs = writebackPairs.map((p) => ({
+      ...p,
+      sourceLine: p.sourceLine + lineShift
+    }));
+    const next = writeNodeIds(withWorkflowId, shiftedPairs);
+    if (next !== source) {
+      await fs.writeFile(file, next, "utf-8");
+    }
+  } catch (err) {
+    console.warn(
+      `\u26A0 Workflow created, but failed to write IDs back to ${file}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify({ ok: true, workflow: body.workflow, writebackPairs }, null, 2));
+    return;
+  }
+  const appUrl = resolveAppUrl(apiUrl);
+  console.log(`
+\u2713 Spec compiled: ${body.workflow.name}`);
+  console.log(`  ID:     ${body.workflow.id}`);
+  console.log(`  Status: ${body.workflow.status}`);
+  console.log(`  Nodes:  ${body.nodes?.length ?? 0}`);
+  console.log(`  URL:    ${appUrl}/flows/${body.workflow.id}`);
+  console.log(`  \u2192 wrote workflowId + @id markers back to ${file}`);
+  if (body.warnings && body.warnings.length > 0) {
+    console.log("\n  Warnings:");
+    for (const w of body.warnings) console.log(`    \u26A0 ${w}`);
+  }
+  if (hasFlag(argv, "--run-and-publish")) {
+    console.log("\n\u2139 --run-and-publish for spec compile is not wired in this MVP. Run:");
+    console.log(`  canary workflow run ${body.workflow.id} --publish-on-pass`);
+  }
+}
+var DUPLICATE_WORKFLOW_TITLE_ALLOW_FLAGS = [
+  "--allow-duplicate",
+  "--create-with-duplicate-title"
+];
+function allowsDuplicateWorkflowTitle(argv) {
+  return DUPLICATE_WORKFLOW_TITLE_ALLOW_FLAGS.some((flag) => hasFlag(argv, flag));
+}
+function exactWorkflowTitleMatches(workflows, workflowName) {
+  return workflows.filter((workflow) => workflow.name === workflowName);
+}
+function formatDuplicateWorkflowTitleWarning(opts) {
+  const first = opts.matches[0];
+  const stampedFile = stampedSpecPath(opts.file);
+  const workflowLines = opts.matches.map((workflow) => {
+    const details = [workflow.status, workflow.flowType].filter(Boolean).join(", ");
+    return `  - ${workflow.id}${details ? ` (${details})` : ""}`;
+  }).join("\n");
+  return [
+    `Error: fresh spec compile would create a duplicate workflow named "${opts.workflowName}".`,
+    "",
+    "Existing workflow(s):",
+    workflowLines,
+    "",
+    "To update an existing workflow instead, pull a stamped spec, re-apply your edits, then compile it:",
+    `  canary spec pull ${first.id} --output ${stampedFile}`,
+    `  canary spec compile ${stampedFile}`,
+    "",
+    "To intentionally create another workflow with the same title, re-run with:",
+    `  canary spec compile ${opts.file} --allow-duplicate`
+  ].join("\n");
+}
+async function fetchFreshCompileDuplicateWorkflows(opts) {
+  if (allowsDuplicateWorkflowTitle(opts.argv)) return [];
+  const params = new URLSearchParams({
+    search: opts.workflowName,
+    pageSize: "50"
+  });
+  const res = await fetchOrExit(`${opts.apiUrl}/workflows?${params.toString()}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${opts.token}` },
+    token: opts.token
+  });
+  if (!res.ok) {
+    console.error(`Error: failed to check for existing workflow titles (${res.status})`);
+    process.exit(1);
+  }
+  const body = await res.json().catch(() => ({}));
+  return exactWorkflowTitleMatches(body.data ?? [], opts.workflowName);
+}
+function stampedSpecPath(file) {
+  if (file.endsWith(".canary.md")) {
+    return `${file.slice(0, -".canary.md".length)}.stamped.canary.md`;
+  }
+  return `${file}.stamped.canary.md`;
+}
+async function runRecompile(opts) {
+  const { argv, apiUrl, token, file, emitted } = opts;
+  const workflowId = emitted.workflowId;
+  const liveRes = await fetchOrExit(`${apiUrl}/workflows/${workflowId}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` },
+    token
+  });
+  if (!liveRes.ok) {
+    console.error(`Error: failed to fetch workflow ${workflowId} (${liveRes.status})`);
+    process.exit(1);
+  }
+  const liveBody = await liveRes.json().catch(() => ({}));
+  const live = liveBody.workflow;
+  if (!live) {
+    console.error(`Error: workflow ${workflowId} not found (or no permission).`);
+    process.exit(1);
+  }
+  let diff;
+  try {
+    diff = diffWorkflow(emitted, live);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  if (!hasAnyChange(diff)) {
+    console.log(`\u2713 ${file} \u2014 no changes (workflow ${workflowId} already in sync)`);
+    return;
+  }
+  const ctx = { apiUrl, token, workflowId };
+  const sync = await applyDiff(ctx, diff, emitted, live);
+  if (sync.created.length > 0) {
+    try {
+      const source = await fs.readFile(file, "utf-8");
+      const next = writeNodeIds(source, sync.created);
+      if (next !== source) await fs.writeFile(file, next, "utf-8");
+    } catch (err) {
+      console.warn(
+        `\u26A0 Recompile applied, but failed to write new @id markers to ${file}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const s = summarize(diff);
+  const appUrl = resolveAppUrl(apiUrl);
+  console.log(`
+\u2713 Recompiled "${live.name}"`);
+  console.log(
+    `  +${s.created} created  \xB7  ~${s.updated} updated  \xB7  -${s.deleted} deleted  \xB7  \u21BB ${s.moved} moved`
+  );
+  console.log(`  URL: ${appUrl}/flows/${workflowId}`);
+  if (diff.nameDrift) {
+    console.log(`  \u270E renamed: "${diff.nameDrift.from}" \u2192 "${diff.nameDrift.to}"`);
+  }
+  if (live.status === "published") {
+    console.log(
+      `  \u26A0 workflow is published \u2014 changes land on draft state; next publish captures them.`
+    );
+  }
+  if (diff.duplicateSpecIds.length > 0) {
+    console.log(
+      `  \u26A0 duplicate @id in spec (treated as fresh creates): ${diff.duplicateSpecIds.join(", ")}`
+    );
+  }
+  if (diff.orphanedSpecIds.length > 0) {
+    console.log(
+      `  \u26A0 stale @id in spec (no matching node \u2014 rebound to new): ${diff.orphanedSpecIds.join(", ")}`
+    );
+  }
+  if (hasFlag(argv, "--json")) {
+    console.log(JSON.stringify({ ok: true, workflowId, summary: s, diff }, null, 2));
+  }
+}
+async function loadAndValidate(file) {
+  let source;
+  try {
+    source = await fs.readFile(file, "utf-8");
+  } catch (err) {
+    return {
+      ok: false,
+      issues: [
+        {
+          severity: "error",
+          message: `Could not read ${file}: ${err instanceof Error ? err.message : String(err)}`
+        }
+      ]
+    };
+  }
+  const parsed = parseSpec(source);
+  if (!parsed.ok) return { ok: false, issues: parsed.issues };
+  const lintIssues = lintSpec(parsed.ast);
+  const allIssues = [...lintIssues];
+  const hasError = allIssues.some((i) => i.severity === "error");
+  if (hasError) return { ok: false, issues: allIssues };
+  return { ok: true, ast: parsed.ast, issues: allIssues };
+}
+function slugify(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+  return slug || "workflow";
+}
+function printIssues(issues, file) {
+  if (issues.length === 0) return;
+  for (const i of issues) {
+    const prefix = i.severity === "error" ? "\u2717 error" : "\u26A0 warn";
+    const loc = i.line ? `${file}:${i.line}` : file;
+    console.error(`${prefix} ${loc}: ${i.message}`);
+    if (i.hint) console.error(`         hint: ${i.hint}`);
+  }
+}
+export {
+  DUPLICATE_WORKFLOW_TITLE_ALLOW_FLAGS,
+  allowsDuplicateWorkflowTitle,
+  emitSpec,
+  exactWorkflowTitleMatches,
+  formatDuplicateWorkflowTitleWarning,
+  handleCompile,
+  handleSpec,
+  handleValidate,
+  lintSpec,
+  parseSpec
+};
+//# sourceMappingURL=spec-RA3CFEKG.js.map