@apicircle/cli 1.0.6 → 1.0.8

package/dist/bin/cli.cjs

@@ -37,10 +37,30 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@apicircle/cli",
-      version: "1.0.6",
+      version: "1.0.8",
       private: false,
       type: "module",
       description: "Command-line interface for API Circle Studio. Run mock servers, drive the MCP server, and import OpenAPI / Postman / Insomnia collections from any terminal.",
+      keywords: [
+        "apicircle",
+        "api-circle",
+        "cli",
+        "command-line",
+        "api",
+        "api-client",
+        "http",
+        "http-client",
+        "mock-server",
+        "mcp",
+        "mcp-server",
+        "openapi",
+        "swagger",
+        "postman",
+        "insomnia",
+        "import",
+        "workspace",
+        "headless"
+      ],
       license: "SEE LICENSE IN LICENSE",
       repository: {
         type: "git",
@@ -246,8 +266,8 @@ async function ensureWorkspace(dir) {
       ui: {
         activeRequestId: null,
         sidebarExpandedSections: [],
-        themeId: "command-center",
-        fontId: "cascadia-code",
+        themeId: "one-dark-pro",
+        fontId: "system-sans",
         fontSizePercent: import_shared2.FONT_SIZE_PERCENT_DEFAULT
       },
       settings: { validateOnSend: true, monacoConsumesWheel: false },
@@ -461,8 +481,8 @@ function buildEmptyState(workspaceId, now, withSample) {
       ui: {
         activeRequestId: sample?.id ?? null,
         sidebarExpandedSections: [],
-        themeId: "command-center",
-        fontId: "cascadia-code",
+        themeId: "one-dark-pro",
+        fontId: "system-sans",
         fontSizePercent: 100
       },
       settings: { validateOnSend: true, monacoConsumesWheel: false },
@@ -551,7 +571,10 @@ var init_mcp = __esm({
 
 // src/commands/import.ts
 function registerImportCommand(program) {
-  program.command("import").description("Import a spec into a workspace folder").argument("<type>", "Source type: openapi | postman | insomnia | curl").argument("<input>", "Path to a spec file, or `-` to read from stdin").option(
+  program.command("import").description("Import a spec into a workspace folder").argument(
+    "<type>",
+    "Source type: openapi | postman | insomnia | curl | apicircle (the apicircle.folder/v1 envelope produced by `apicircle export folder`)"
+  ).argument("<input>", "Path to a spec file, or `-` to read from stdin").option(
     "--workspace-name <name-or-id>",
     "Registry workspace name (case-insensitive) or id. Defaults to the active workspace."
   ).option(
@@ -641,6 +664,40 @@ function registerImportCommand(program) {
           })
         );
       }
+    } else if (type === "apicircle") {
+      let parsedEnvelope;
+      try {
+        parsedEnvelope = (0, import_core.parseApicircleFolderExport)(raw);
+      } catch (err) {
+        process.stderr.write(
+          `${import_kleur3.default.red("error")}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+        process.exit(2);
+      }
+      const out = (0, import_core.applyMutation)(
+        { synced: nextSynced, local: nextLocal },
+        { kind: "folder.import_apicircle", parsed: parsedEnvelope, parentFolderId: null }
+      );
+      nextSynced = out.next.synced;
+      nextLocal = out.next.local;
+      for (const r of parsedEnvelope.requests) created.push(r.id);
+      for (const w of parsedEnvelope.warnings) {
+        process.stderr.write(`${import_kleur3.default.yellow("warning")}: ${w}
+`);
+      }
+      await (0, import_file_backed3.saveToFile)(dir, { synced: nextSynced, local: nextLocal });
+      process.stdout.write(
+        `${import_kleur3.default.green("imported")} folder "${parsedEnvelope.rootFolder.name}" (${parsedEnvelope.subfolders.length + 1} folders, ${parsedEnvelope.requests.length} requests) into ${dir}
+`
+      );
+      if (parsedEnvelope.dependencies.files.length > 0) {
+        process.stderr.write(
+          `${import_kleur3.default.yellow("note")}: ${parsedEnvelope.dependencies.files.length} file asset${parsedEnvelope.dependencies.files.length === 1 ? "" : "s"} landed without bytes \u2014 re-attach them inside Global Assets \u2192 Global Files.
+`
+        );
+      }
+      return;
     } else {
       process.stderr.write(`${import_kleur3.default.red("error")}: unknown type '${String(type)}'
 `);
@@ -655,13 +712,13 @@ function registerImportCommand(program) {
 }
 async function readInput(p) {
   if (p === "-") {
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       let data = "";
       process.stdin.setEncoding("utf-8");
       process.stdin.on("data", (chunk) => {
         data += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
       });
-      process.stdin.on("end", () => resolve7(data));
+      process.stdin.on("end", () => resolve8(data));
       process.stdin.on("error", reject);
     });
   }
@@ -700,14 +757,120 @@ var init_import = __esm({
   }
 });
 
+// src/commands/export.ts
+function registerExportCommand(program) {
+  const exportCmd = program.command("export").description("Export workspace entities to portable JSON.");
+  exportCmd.command("folder").description("Export a folder (and its subtree) as an apicircle.folder/v1 JSON envelope.").argument(
+    "<folder>",
+    "Folder id, or display name (case-insensitive). Unique within the workspace."
+  ).option("-o, --out <path>", "Write the JSON to this file. Defaults to stdout.").option(
+    "--include-credential <id>",
+    "Keep the credential field with this id (repeatable). Use --list-credentials to see ids.",
+    (value, prev = []) => [...prev, value],
+    []
+  ).option(
+    "--list-credentials",
+    "Print the detected credentials + their ids and exit without writing anything."
+  ).option(
+    "--workspace-name <name-or-id>",
+    "Registry workspace name (case-insensitive) or id. Defaults to the active workspace."
+  ).option(
+    "-w, --workspace-path <dir>",
+    "Filesystem directory containing workspace.synced.json (skips the registry)."
+  ).action(async (folder, opts) => {
+    let dir;
+    try {
+      const resolved = await resolveWorkspace({
+        name: opts.workspaceName,
+        path: opts.workspacePath
+      });
+      dir = resolved.dir;
+    } catch (err) {
+      if (err instanceof WorkspaceResolutionError) {
+        process.stderr.write(`${import_kleur4.default.red("error")}: ${err.message}
+`);
+        process.exit(2);
+      }
+      throw err;
+    }
+    const state = await ensureWorkspace(dir);
+    const folderId = resolveFolderId(state.synced.collections.folders, folder);
+    if (!folderId) {
+      process.stderr.write(`${import_kleur4.default.red("error")}: no folder matches "${folder}" in ${dir}
+`);
+      process.exit(2);
+    }
+    const collected = (0, import_core2.collectFolderExport)({ synced: state.synced, folderId });
+    if (!collected) {
+      process.stderr.write(`${import_kleur4.default.red("error")}: folder "${folder}" no longer exists
+`);
+      process.exit(2);
+    }
+    if (opts.listCredentials) {
+      if (collected.report.credentials.length === 0) {
+        process.stdout.write("No credential-bearing auth fields detected.\n");
+        return;
+      }
+      for (const cred of collected.report.credentials) {
+        process.stdout.write(`${cred.id}	${cred.label}	${cred.ownerName}
+`);
+      }
+      return;
+    }
+    const includeIds = new Set(opts.includeCredential ?? []);
+    const envelope = (0, import_core2.redactFolderExportCredentials)(collected.envelope, includeIds);
+    const json = (0, import_core2.serializeFolderExport)(envelope);
+    if (opts.out) {
+      const outPath = path5.resolve(opts.out);
+      await import_node_fs5.promises.writeFile(outPath, json, "utf-8");
+      process.stderr.write(
+        `${import_kleur4.default.green("exported")} folder "${collected.report.folderName}" \u2192 ${outPath}
+`
+      );
+    } else {
+      process.stdout.write(json);
+      process.stdout.write("\n");
+      process.stderr.write(
+        `${import_kleur4.default.green("exported")} folder "${collected.report.folderName}" (${collected.report.totalFolderCount} folders, ${collected.report.requestCount} requests, ${collected.report.credentials.length - includeIds.size} credentials redacted)
+`
+      );
+    }
+    if (!opts.out) {
+      process.stderr.write(
+        `${import_kleur4.default.dim("hint")}: save with .apicircle.json, e.g. ${(0, import_core2.suggestFolderExportFilename)(envelope)}
+`
+      );
+    }
+  });
+}
+function resolveFolderId(folders, query) {
+  if (folders[query]) return query;
+  const norm = query.trim().toLowerCase();
+  const matches = Object.values(folders).filter((f) => f.name.trim().toLowerCase() === norm);
+  if (matches.length === 1) return matches[0].id;
+  return null;
+}
+var import_node_fs5, path5, import_kleur4, import_core2;
+var init_export = __esm({
+  "src/commands/export.ts"() {
+    "use strict";
+    import_node_fs5 = require("fs");
+    path5 = __toESM(require("path"), 1);
+    import_kleur4 = __toESM(require("kleur"), 1);
+    import_core2 = require("@apicircle/core");
+    init_loadWorkspace();
+    init_resolveWorkspace();
+  }
+});
+
 // src/util/secrets.ts
 async function buildSecretsFromCli(options = {}) {
   const env = options.env ?? process.env;
   const prefix = options.envPrefix ?? DEFAULT_PREFIX;
   const byId = {};
   if (options.secretsFile) {
-    const resolved = path5.resolve(options.secretsFile);
-    const raw = await import_node_fs5.promises.readFile(resolved, "utf8");
+    const resolved = path6.resolve(options.secretsFile);
+    const raw = await import_node_fs6.promises.readFile(resolved, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       throw new Error(
@@ -728,21 +891,21 @@ async function buildSecretsFromCli(options = {}) {
   }
   return { byId };
 }
-var path5, import_node_fs5, DEFAULT_PREFIX;
+var path6, import_node_fs6, DEFAULT_PREFIX;
 var init_secrets = __esm({
   "src/util/secrets.ts"() {
     "use strict";
-    path5 = __toESM(require("path"), 1);
-    import_node_fs5 = require("fs");
+    path6 = __toESM(require("path"), 1);
+    import_node_fs6 = require("fs");
     DEFAULT_PREFIX = "APICIRCLE_SECRET_";
   }
 });
 
 // src/util/executionAttachments.ts
 async function prepareExecutionAttachments(workspaceDir, state, plan) {
-  const cacheDir = path6.resolve(workspaceDir, ATTACHMENTS_DIR);
+  const cacheDir = path7.resolve(workspaceDir, ATTACHMENTS_DIR);
   const requirements = collectExecutionAttachmentRequirements(state, plan);
-  await import_node_fs6.promises.mkdir(cacheDir, { recursive: true });
+  await import_node_fs7.promises.mkdir(cacheDir, { recursive: true });
   let downloaded = 0;
   let alreadyPresent = 0;
   let failed = 0;
@@ -751,7 +914,7 @@ async function prepareExecutionAttachments(workspaceDir, state, plan) {
   };
   const entries = [];
   for (const requirement of requirements) {
-    const localPath = path6.join(cacheDir, encodeURIComponent(requirement.slotId));
+    const localPath = path7.join(cacheDir, encodeURIComponent(requirement.slotId));
     const present = await hasExpectedFile(localPath, requirement.sha256);
     if (present) {
       alreadyPresent++;
@@ -768,7 +931,7 @@ async function prepareExecutionAttachments(workspaceDir, state, plan) {
             `Attachment ${attachmentLabel(requirement)} failed checksum verification.`
           );
         }
-        await import_node_fs6.promises.writeFile(localPath, bytes, { mode: 384 });
+        await import_node_fs7.promises.writeFile(localPath, bytes, { mode: 384 });
         downloaded++;
       } catch (err) {
         failed++;
@@ -825,7 +988,7 @@ function createFileAttachmentResolver(state) {
   return async (slotId) => {
     const meta = state.local.attachmentCache?.[slotId];
     if (!meta) return null;
-    const bytes = await import_node_fs6.promises.readFile(meta.localPath);
+    const bytes = await import_node_fs7.promises.readFile(meta.localPath);
     const view = new Uint8Array(bytes);
     const body = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
     return {
@@ -845,7 +1008,7 @@ function collectExecutionAttachmentRequirements(state, plan) {
       )
     )
   } : state.synced.collections;
-  const workspaceSlots = (0, import_core2.collectAttachmentSlots)({ ...state.synced, collections: localCollections });
+  const workspaceSlots = (0, import_core3.collectAttachmentSlots)({ ...state.synced, collections: localCollections });
   for (const slot of workspaceSlots) {
     const requiredBy = collectRequiredBy(localCollections.requests, slot.slotId);
     if (requiredBy.length === 0) continue;
@@ -877,7 +1040,7 @@ function collectExecutionAttachmentRequirements(state, plan) {
       environments: snapshot.environments,
       globalAssets: snapshot.globalAssets ?? state.synced.globalAssets
     };
-    for (const slot of (0, import_core2.collectAttachmentSlots)(linkedSynced)) {
+    for (const slot of (0, import_core3.collectAttachmentSlots)(linkedSynced)) {
       const requiredBy = collectRequiredBy(linkedCollections.requests, slot.slotId);
       if (requiredBy.length === 0) continue;
       addRequirement(seen, {
@@ -930,7 +1093,7 @@ function bodyReferencesSlot(body, slotId) {
 }
 async function hasExpectedFile(localPath, sha256) {
   try {
-    const bytes = await import_node_fs6.promises.readFile(localPath);
+    const bytes = await import_node_fs7.promises.readFile(localPath);
     if (!sha256) return true;
     return sha256Hex(bytes) === sha256;
   } catch {
@@ -939,7 +1102,7 @@ async function hasExpectedFile(localPath, sha256) {
 }
 async function fileSize(localPath) {
   try {
-    return (await import_node_fs6.promises.stat(localPath)).size;
+    return (await import_node_fs7.promises.stat(localPath)).size;
   } catch {
     return 0;
   }
@@ -998,15 +1161,15 @@ function sourceLabel(requirement) {
 function requiredByLabel(requirement) {
   return requirement.requiredBy.map((item) => item.requestName).join(", ") || "a request";
 }
-var import_node_crypto, import_node_fs6, path6, import_core2, ATTACHMENTS_DIR;
+var import_node_crypto, import_node_fs7, path7, import_core3, ATTACHMENTS_DIR;
 var init_executionAttachments = __esm({
   "src/util/executionAttachments.ts"() {
     "use strict";
     import_node_crypto = require("crypto");
-    import_node_fs6 = require("fs");
-    path6 = __toESM(require("path"), 1);
-    import_core2 = require("@apicircle/core");
-    ATTACHMENTS_DIR = path6.join(".apicircle", "attachments");
+    import_node_fs7 = require("fs");
+    path7 = __toESM(require("path"), 1);
+    import_core3 = require("@apicircle/core");
+    ATTACHMENTS_DIR = path7.join(".apicircle", "attachments");
   }
 });
 
@@ -1029,7 +1192,7 @@ function registerRunCommand(program) {
       dir = resolved.dir;
       if (resolved.fromRegistry) {
         process.stderr.write(
-          `${import_kleur4.default.dim("workspace")}: ${import_kleur4.default.cyan(resolved.name ?? resolved.id ?? "")} ${import_kleur4.default.dim(`(${dir})`)}
+          `${import_kleur5.default.dim("workspace")}: ${import_kleur5.default.cyan(resolved.name ?? resolved.id ?? "")} ${import_kleur5.default.dim(`(${dir})`)}
 `
         );
       }
@@ -1050,7 +1213,7 @@ function registerRunCommand(program) {
       fail(`no workspace found at ${dir} (expected workspace.synced.json)`);
       return;
     }
-    const ref = (0, import_core3.resolvePlanRef)(state.synced, planRef);
+    const ref = (0, import_core4.resolvePlanRef)(state.synced, planRef);
     if (!ref.ok) {
       fail(ref.error);
       if (ref.available.length > 0) {
@@ -1095,7 +1258,7 @@ function registerRunCommand(program) {
     }
     let result;
     try {
-      result = await (0, import_core3.runPlan)(prepared.state, ref.id, {
+      result = await (0, import_core4.runPlan)(prepared.state, ref.id, {
         withAssertions,
         bail: opts.bail === true,
         env: opts.env,
@@ -1108,7 +1271,7 @@ function registerRunCommand(program) {
       });
     } catch (err) {
       process.off("SIGINT", onSigint);
-      if (err instanceof import_core3.PlanRunDeniedError) {
+      if (err instanceof import_core4.PlanRunDeniedError) {
         fail(err.message, 3, "denied");
         return;
       }
@@ -1147,7 +1310,7 @@ function resolveActor(local, override) {
     if (username) return { kind: "os", name: username };
   } catch {
   }
-  return import_core3.ANONYMOUS_ACTOR;
+  return import_core4.ANONYMOUS_ACTOR;
 }
 function checkRunPermission(_ctx) {
 }
@@ -1158,17 +1321,17 @@ function formatHeader(plan, actor, withAssertions, opts) {
     opts.bail ? "bail" : null,
     opts.env ? `env=${opts.env}` : null
   ].filter((f) => f !== null);
-  return `${import_kleur4.default.bold("Plan")} ${plan.name}  ${import_kleur4.default.dim(
+  return `${import_kleur5.default.bold("Plan")} ${plan.name}  ${import_kleur5.default.dim(
     `(${enabled}/${plan.steps.length} steps \xB7 ${flags.join(" \xB7 ")})`
   )}
-${import_kleur4.default.dim("Run by")} ${actor.name} ${import_kleur4.default.dim(`(${actor.kind})`)}
+${import_kleur5.default.dim("Run by")} ${actor.name} ${import_kleur5.default.dim(`(${actor.kind})`)}
 
 `;
 }
 function formatAttachmentPreparation(summary) {
   const status = `${summary.downloaded} downloaded, ${summary.alreadyPresent} already local`;
   const lines = [
-    `${import_kleur4.default.bold("Attachments")} ${summary.total} required ${import_kleur4.default.dim(
+    `${import_kleur5.default.bold("Attachments")} ${summary.total} required ${import_kleur5.default.dim(
       `(${status} - ${summary.cacheDir})`
     )}`
   ];
@@ -1176,7 +1339,7 @@ function formatAttachmentPreparation(summary) {
     const source = entry3.source === "linked-workspace" ? `linked:${entry3.linkedWorkspaceId ?? "unknown"}` : "workspace";
     const requiredBy = entry3.requiredBy.map((item) => item.requestName).join(", ");
     lines.push(
-      `  ${import_kleur4.default.dim("file")} ${entry3.filename} ${import_kleur4.default.dim(
+      `  ${import_kleur5.default.dim("file")} ${entry3.filename} ${import_kleur5.default.dim(
         `${source} - ${requiredBy} - ${entry3.localPath}`
       )}`
     );
@@ -1189,31 +1352,31 @@ function formatStepLine(step) {
   const n = `${step.stepIndex + 1}.`.padEnd(3);
   const method = (step.requestMethod || "\u2014").padEnd(7);
   if (step.skipped) {
-    return `  ${import_kleur4.default.dim("\u2013")} ${import_kleur4.default.dim(n)} ${import_kleur4.default.dim(method)} ${import_kleur4.default.dim(
+    return `  ${import_kleur5.default.dim("\u2013")} ${import_kleur5.default.dim(n)} ${import_kleur5.default.dim(method)} ${import_kleur5.default.dim(
       `${step.requestName}  skipped`
     )}
 `;
   }
-  const mark = step.passed ? import_kleur4.default.green("\u2713") : import_kleur4.default.red("\u2717");
+  const mark = step.passed ? import_kleur5.default.green("\u2713") : import_kleur5.default.red("\u2717");
   const status = step.result?.status != null ? String(step.result.status) : "\u2014";
   const duration = step.result ? `${step.result.durationMs}ms` : "";
   const name = step.requestName.padEnd(28);
-  let line = `  ${mark} ${n} ${method} ${name} ${status.padEnd(4)} ${import_kleur4.default.dim(duration)}`;
+  let line = `  ${mark} ${n} ${method} ${name} ${status.padEnd(4)} ${import_kleur5.default.dim(duration)}`;
   if (step.assertionResults.length > 0) {
     const passed = step.assertionResults.filter((a) => a.passed).length;
-    line += `  ${import_kleur4.default.dim(`${passed}/${step.assertionResults.length} assertions`)}`;
+    line += `  ${import_kleur5.default.dim(`${passed}/${step.assertionResults.length} assertions`)}`;
   }
   line += "\n";
   if (step.error) {
-    line += `      ${import_kleur4.default.red(step.error)}
+    line += `      ${import_kleur5.default.red(step.error)}
 `;
   }
   for (const a of step.assertionResults) {
-    if (!a.passed) line += `      ${import_kleur4.default.red("\u2717")} ${a.detail ?? `${a.kind} ${a.op}`}
+    if (!a.passed) line += `      ${import_kleur5.default.red("\u2717")} ${a.detail ?? `${a.kind} ${a.op}`}
 `;
   }
   if (step.missingVariables.length > 0) {
-    line += `      ${import_kleur4.default.yellow("\u26A0")} unresolved: ${step.missingVariables.map((v) => `{{${v}}}`).join(", ")}
+    line += `      ${import_kleur5.default.yellow("\u26A0")} unresolved: ${step.missingVariables.map((v) => `{{${v}}}`).join(", ")}
 `;
   }
   return line;
@@ -1232,24 +1395,24 @@ function tally(result) {
 function formatSummary(result, saved, aborted) {
   if (result.steps.length === 0) {
     return `
-${import_kleur4.default.yellow("Plan has no steps.")}
+${import_kleur5.default.yellow("Plan has no steps.")}
 `;
   }
   const { passed, failed, skipped } = tally(result);
   const parts = [
-    import_kleur4.default.green(`${passed} passed`),
-    failed > 0 ? import_kleur4.default.red(`${failed} failed`) : import_kleur4.default.dim(`${failed} failed`),
-    import_kleur4.default.dim(`${skipped} skipped`)
+    import_kleur5.default.green(`${passed} passed`),
+    failed > 0 ? import_kleur5.default.red(`${failed} failed`) : import_kleur5.default.dim(`${failed} failed`),
+    import_kleur5.default.dim(`${skipped} skipped`)
   ];
-  const verdict = result.passed && !aborted ? import_kleur4.default.green("PASS") : import_kleur4.default.red("FAIL");
+  const verdict = result.passed && !aborted ? import_kleur5.default.green("PASS") : import_kleur5.default.red("FAIL");
   let out = `
-${verdict}  ${parts.join(import_kleur4.default.dim(" \xB7 "))}  ${import_kleur4.default.dim(
+${verdict}  ${parts.join(import_kleur5.default.dim(" \xB7 "))}  ${import_kleur5.default.dim(
     `\xB7 ${result.planRun.durationMs}ms`
   )}
 `;
-  if (aborted) out += `${import_kleur4.default.yellow("Run aborted before every step finished.")}
+  if (aborted) out += `${import_kleur5.default.yellow("Run aborted before every step finished.")}
 `;
-  out += saved ? import_kleur4.default.dim("Plan run saved to workspace history.\n") : import_kleur4.default.dim("Plan run not saved (--no-save).\n");
+  out += saved ? import_kleur5.default.dim("Plan run saved to workspace history.\n") : import_kleur5.default.dim("Plan run not saved (--no-save).\n");
   return out;
 }
 function buildJsonReport(workspace, planId, plan, actor, result, saved, aborted, attachments) {
@@ -1325,17 +1488,17 @@ ${cases.join("\n")}
 `;
 }
 function fail(message, code = 2, kind = "error") {
-  process.stderr.write(`${import_kleur4.default.red(kind)}: ${message}
+  process.stderr.write(`${import_kleur5.default.red(kind)}: ${message}
 `);
   process.exitCode = code;
 }
-var os2, import_kleur4, import_core3, import_file_backed4, REPORTERS;
+var os2, import_kleur5, import_core4, import_file_backed4, REPORTERS;
 var init_run = __esm({
   "src/commands/run.ts"() {
     "use strict";
     os2 = __toESM(require("os"), 1);
-    import_kleur4 = __toESM(require("kleur"), 1);
-    import_core3 = require("@apicircle/core");
+    import_kleur5 = __toESM(require("kleur"), 1);
+    import_core4 = require("@apicircle/core");
     import_file_backed4 = require("@apicircle/core/workspace/file-backed");
     init_secrets();
     init_resolveWorkspace();
@@ -1355,15 +1518,15 @@ function registerWorkspacesCommand(program) {
     }
     if (registry.workspaces.length === 0) {
       process.stdout.write(
-        `${import_kleur5.default.dim("No workspaces registered yet at")} ${root}
-${import_kleur5.default.dim("Run")} ${import_kleur5.default.cyan("apicircle workspaces create <name>")} ${import_kleur5.default.dim(
+        `${import_kleur6.default.dim("No workspaces registered yet at")} ${root}
+${import_kleur6.default.dim("Run")} ${import_kleur6.default.cyan("apicircle workspaces create <name>")} ${import_kleur6.default.dim(
           "or open the desktop app to seed one."
         )}
 `
       );
       return;
     }
-    process.stdout.write(`${import_kleur5.default.dim("registry")}: ${root}
+    process.stdout.write(`${import_kleur6.default.dim("registry")}: ${root}
 
 `);
     const rows = [...registry.workspaces].sort(
@@ -1372,22 +1535,22 @@ ${import_kleur5.default.dim("Run")} ${import_kleur5.default.cyan("apicircle work
     const nameWidth = Math.max(4, ...rows.map((r) => r.name.length));
     const idWidth = Math.max(2, ...rows.map((r) => r.id.length));
     process.stdout.write(
-      import_kleur5.default.bold(
+      import_kleur6.default.bold(
         `  ${"".padEnd(1)} ${"NAME".padEnd(nameWidth)}  ${"ID".padEnd(idWidth)}  LAST OPENED
 `
       )
     );
     for (const w of rows) {
-      const mark = w.id === registry.activeWorkspaceId ? import_kleur5.default.green("\u25CF") : " ";
+      const mark = w.id === registry.activeWorkspaceId ? import_kleur6.default.green("\u25CF") : " ";
       process.stdout.write(
-        `  ${mark} ${w.name.padEnd(nameWidth)}  ${import_kleur5.default.dim(
+        `  ${mark} ${w.name.padEnd(nameWidth)}  ${import_kleur6.default.dim(
           w.id.padEnd(idWidth)
-        )}  ${import_kleur5.default.dim(w.lastOpenedAt)}
+        )}  ${import_kleur6.default.dim(w.lastOpenedAt)}
 `
       );
     }
     process.stdout.write(`
-${import_kleur5.default.dim("\u25CF = active")}
+${import_kleur6.default.dim("\u25CF = active")}
 `);
   });
   ws.command("create").description("Create a new workspace and add it to the registry").argument("<name>", "Human-readable label for the workspace").option("--sample", "Seed the workspace with one sample request", false).action(async (name, opts) => {
@@ -1397,17 +1560,17 @@ ${import_kleur5.default.dim("\u25CF = active")}
         sampleRequest: opts.sample ?? false
       });
       process.stdout.write(
-        `${import_kleur5.default.green("created")} workspace ${import_kleur5.default.cyan(entry3.name)} ${import_kleur5.default.dim(`(${entry3.id})`)}
+        `${import_kleur6.default.green("created")} workspace ${import_kleur6.default.cyan(entry3.name)} ${import_kleur6.default.dim(`(${entry3.id})`)}
   at ${dir}
 `
       );
       if (registry.activeWorkspaceId === entry3.id) {
-        process.stdout.write(`${import_kleur5.default.dim("marked as active")}
+        process.stdout.write(`${import_kleur6.default.dim("marked as active")}
 `);
       }
     } catch (err) {
       process.stderr.write(
-        `${import_kleur5.default.red("error")}: ${err instanceof Error ? err.message : String(err)}
+        `${import_kleur6.default.red("error")}: ${err instanceof Error ? err.message : String(err)}
 `
       );
       process.exit(2);
@@ -1418,8 +1581,8 @@ ${import_kleur5.default.dim("\u25CF = active")}
     const entry3 = (0, import_registry2.findWorkspaceEntry)(registry, selector);
     if (!entry3) {
       process.stderr.write(
-        `${import_kleur5.default.red("error")}: no workspace named "${selector}" in the registry at ${root}.
-${import_kleur5.default.dim("Run")} ${import_kleur5.default.cyan("apicircle workspaces list")} ${import_kleur5.default.dim("to see what is available.")}
+        `${import_kleur6.default.red("error")}: no workspace named "${selector}" in the registry at ${root}.
+${import_kleur6.default.dim("Run")} ${import_kleur6.default.cyan("apicircle workspaces list")} ${import_kleur6.default.dim("to see what is available.")}
 `
       );
       process.exit(2);
@@ -1428,7 +1591,7 @@ ${import_kleur5.default.dim("Run")} ${import_kleur5.default.cyan("apicircle work
     const next = await (0, import_registry2.setActiveWorkspace)(root, entry3.id);
     void next;
     process.stdout.write(
-      `${import_kleur5.default.green("active")} workspace is now ${import_kleur5.default.cyan(entry3.name)} ${import_kleur5.default.dim(`(${entry3.id})`)}
+      `${import_kleur6.default.green("active")} workspace is now ${import_kleur6.default.cyan(entry3.name)} ${import_kleur6.default.dim(`(${entry3.id})`)}
 `
     );
   });
@@ -1441,7 +1604,7 @@ ${import_kleur5.default.dim("Run")} ${import_kleur5.default.cyan("apicircle work
     const entry3 = (0, import_registry2.findWorkspaceEntry)(registry, selector);
     if (!entry3) {
       process.stderr.write(
-        `${import_kleur5.default.red("error")}: no workspace named "${selector}" in the registry at ${root}.
+        `${import_kleur6.default.red("error")}: no workspace named "${selector}" in the registry at ${root}.
 `
       );
       process.exit(2);
@@ -1452,11 +1615,11 @@ ${import_kleur5.default.dim("Run")} ${import_kleur5.default.cyan("apicircle work
     process.stdout.write(workspaceDirFor2(root, entry3.id) + "\n");
   });
 }
-var import_kleur5, import_registry2;
+var import_kleur6, import_registry2;
 var init_workspaces = __esm({
   "src/commands/workspaces.ts"() {
     "use strict";
-    import_kleur5 = __toESM(require("kleur"), 1);
+    import_kleur6 = __toESM(require("kleur"), 1);
     init_resolveWorkspace();
     import_registry2 = require("@apicircle/core/workspace/registry");
   }
@@ -1474,6 +1637,7 @@ function buildProgram() {
   registerMockCommand(program);
   registerMcpCommand(program);
   registerImportCommand(program);
+  registerExportCommand(program);
   registerRunCommand(program);
   registerWorkspacesCommand(program);
   return program;
@@ -1489,6 +1653,7 @@ var init_src = __esm({
     init_mock();
     init_mcp();
     init_import();
+    init_export();
     init_run();
     init_workspaces();
     init_packageVersion();