@apicircle/cli 1.0.3 → 1.0.5

package/dist/bin/cli.cjs

@@ -0,0 +1,1560 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@apicircle/cli",
+      version: "1.0.5",
+      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.",
+      license: "SEE LICENSE IN LICENSE",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/apicircle/studio.git",
+        directory: "packages/cli"
+      },
+      homepage: "https://github.com/apicircle/studio#readme",
+      bugs: "https://github.com/apicircle/studio/issues",
+      engines: {
+        node: ">=20"
+      },
+      main: "./src/index.ts",
+      types: "./src/index.ts",
+      bin: {
+        apicircle: "./dist/bin/cli.cjs"
+      },
+      exports: {
+        ".": "./src/index.ts"
+      },
+      files: [
+        "dist"
+      ],
+      publishConfig: {
+        main: "./dist/index.cjs",
+        module: "./dist/index.js",
+        types: "./dist/index.d.cts",
+        exports: {
+          ".": {
+            import: {
+              types: "./dist/index.d.ts",
+              default: "./dist/index.js"
+            },
+            require: {
+              types: "./dist/index.d.cts",
+              default: "./dist/index.cjs"
+            }
+          }
+        }
+      },
+      scripts: {
+        build: "tsup",
+        check: "tsc --noEmit",
+        test: "vitest run",
+        clean: "rm -rf dist node_modules"
+      },
+      dependencies: {
+        "@apicircle/core": "workspace:*",
+        "@apicircle/mcp-server": "workspace:*",
+        "@apicircle/mock-server-core": "workspace:*",
+        "@apicircle/shared": "workspace:*",
+        commander: "^12.0.0",
+        kleur: "^4.1.5"
+      },
+      devDependencies: {
+        "@types/node": "^20.0.0",
+        tsup: "^8.3.0",
+        typescript: "^5.4.0",
+        vitest: "^2.0.0"
+      }
+    };
+  }
+});
+
+// src/packageVersion.ts
+function readPackageVersion() {
+  const version = package_default.version;
+  if (typeof version !== "string" || version.length === 0) {
+    throw new Error("Unable to read @apicircle/cli package version");
+  }
+  return version;
+}
+var CLI_PACKAGE_VERSION;
+var init_packageVersion = __esm({
+  "src/packageVersion.ts"() {
+    "use strict";
+    init_package();
+    CLI_PACKAGE_VERSION = readPackageVersion();
+  }
+});
+
+// src/commands/mock.ts
+function registerMockCommand(program) {
+  program.command("mock").description("Run a mock server from an OpenAPI / Postman / Insomnia file").argument("<spec>", "Path to the spec file").option("-p, --port <number>", "TCP port to bind (defaults to a free port)").option("-h, --host <host>", "Hostname to bind", "127.0.0.1").option("-t, --type <type>", "Source type: openapi | postman | insomnia | auto", "auto").option("-f, --format <format>", "OpenAPI format: json | yaml | auto", "auto").option("--cors", "Enable permissive CORS", true).action(async (spec, opts) => {
+    const absolute = path.resolve(spec);
+    const raw = await import_node_fs.promises.readFile(absolute, "utf-8");
+    const type = inferType(absolute, opts.type ?? "auto");
+    const format = type === "openapi" ? inferFormat(absolute, opts.format ?? "auto") : "json";
+    const source = makeSource(type, format, raw);
+    const parsed = await (0, import_mock_server_core.parseSourceToEndpoints)(source);
+    const mock = {
+      id: (0, import_shared.generateId)(),
+      name: path.basename(absolute),
+      source,
+      endpoints: parsed.endpoints,
+      defaultPort: opts.port ? Number(opts.port) : null,
+      cors: { enabled: opts.cors !== false, origins: ["*"] },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const handle = await (0, import_mock_server_core.startMockServer)(mock, {
+      port: opts.port ? Number(opts.port) : void 0,
+      host: opts.host
+    });
+    process.stdout.write(
+      `${import_kleur.default.green("Mock server")} listening on ${import_kleur.default.cyan(`http://${opts.host}:${handle.port}`)} with ${parsed.endpoints.length} endpoints (type=${type}). Press Ctrl-C to stop.
+`
+    );
+    if (parsed.warnings.length) {
+      for (const w of parsed.warnings) {
+        process.stderr.write(`${import_kleur.default.yellow("warn")}: ${w}
+`);
+      }
+    }
+    installShutdown(handle);
+  });
+}
+function inferType(filePath, hint) {
+  if (hint && hint !== "auto") return hint;
+  const lower = filePath.toLowerCase();
+  if (lower.includes("postman")) return "postman";
+  if (lower.includes("insomnia")) return "insomnia";
+  return "openapi";
+}
+function inferFormat(filePath, hint) {
+  if (hint && hint !== "auto") return hint;
+  const lower = filePath.toLowerCase();
+  return lower.endsWith(".yaml") || lower.endsWith(".yml") ? "yaml" : "json";
+}
+function makeSource(type, format, raw) {
+  switch (type) {
+    case "openapi":
+      return { kind: "openapi", spec: raw, format };
+    case "postman":
+      return { kind: "postman", collection: raw };
+    case "insomnia":
+      return { kind: "insomnia", export: raw };
+  }
+}
+function installShutdown(handle) {
+  let closing = false;
+  const shutdown = async () => {
+    if (closing) return;
+    closing = true;
+    await handle.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+}
+var import_node_fs, path, import_kleur, import_mock_server_core, import_shared;
+var init_mock = __esm({
+  "src/commands/mock.ts"() {
+    "use strict";
+    import_node_fs = require("fs");
+    path = __toESM(require("path"), 1);
+    import_kleur = __toESM(require("kleur"), 1);
+    import_mock_server_core = require("@apicircle/mock-server-core");
+    import_shared = require("@apicircle/shared");
+  }
+});
+
+// src/util/loadWorkspace.ts
+async function ensureWorkspace(dir) {
+  const resolved = path2.resolve(dir);
+  await import_node_fs2.promises.mkdir(resolved, { recursive: true });
+  const existing = await (0, import_file_backed.loadFromFile)(resolved, { allowMissing: true });
+  if (existing) return existing;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const workspaceId = (0, import_shared2.generateId)();
+  const fresh = {
+    synced: {
+      schemaVersion: 1,
+      workspaceId,
+      collections: {
+        tree: { id: (0, import_shared2.generateId)(), type: "root", children: [] },
+        requests: {},
+        folders: {}
+      },
+      environments: { items: {}, activeName: null, priorityOrder: [] },
+      linkedWorkspaces: {},
+      linkedOverrides: { requests: {}, environmentVars: {} },
+      releases: { self: null, perLink: {} },
+      globalAssets: { schemas: {}, graphql: {}, files: {} },
+      mockServers: {},
+      meta: { createdAt: now, updatedAt: now, appVersion: "1.0.0" }
+    },
+    local: {
+      schemaVersion: 1,
+      workspaceId,
+      executionPlans: {},
+      history: { requestRuns: [], planRuns: [] },
+      secretIndex: { entries: {} },
+      sessions: { github: { workspace: null, links: {} } },
+      connectedRepo: null,
+      workingBranch: null,
+      seededWorkspaceSha: null,
+      retiredBranch: null,
+      sync: { lastPulledSnapshot: null, lastPulledSha: null, lastPulledAt: null, dirtyKeys: [] },
+      linkedCollections: {},
+      attachmentCache: {},
+      globalContext: {},
+      mockRuntime: { active: {} },
+      ui: {
+        activeRequestId: null,
+        sidebarExpandedSections: [],
+        themeId: "command-center",
+        fontId: "cascadia-code",
+        fontSizePercent: import_shared2.FONT_SIZE_PERCENT_DEFAULT
+      },
+      settings: { validateOnSend: true, monacoConsumesWheel: false },
+      snapshots: { entries: [], maxBytes: 50 * 1024 * 1024 }
+    }
+  };
+  await (0, import_file_backed.saveToFile)(resolved, fresh);
+  return fresh;
+}
+var path2, import_node_fs2, import_file_backed, import_shared2;
+var init_loadWorkspace = __esm({
+  "src/util/loadWorkspace.ts"() {
+    "use strict";
+    path2 = __toESM(require("path"), 1);
+    import_node_fs2 = require("fs");
+    import_file_backed = require("@apicircle/core/workspace/file-backed");
+    import_shared2 = require("@apicircle/shared");
+  }
+});
+
+// src/util/resolveWorkspace.ts
+function defaultWorkspacesRoot() {
+  const override = process.env.APICIRCLE_WORKSPACES_ROOT;
+  if (override && override.length > 0) return path3.resolve(override);
+  return path3.join(electronUserDataDir(), WORKSPACES_DIRNAME);
+}
+function electronUserDataDir() {
+  const home = os.homedir();
+  switch (process.platform) {
+    case "win32": {
+      const appdata = process.env.APPDATA ?? path3.join(home, "AppData", "Roaming");
+      return path3.join(appdata, APP_NAME, APP_SUBDIR);
+    }
+    case "darwin":
+      return path3.join(home, "Library", "Application Support", APP_NAME, APP_SUBDIR);
+    default:
+      return path3.join(
+        process.env.XDG_CONFIG_HOME ?? path3.join(home, ".config"),
+        APP_NAME,
+        APP_SUBDIR
+      );
+  }
+}
+async function resolveWorkspace(opts = {}) {
+  const root = opts.workspacesRoot ?? defaultWorkspacesRoot();
+  const nameSelector = opts.name?.trim();
+  const pathSelector = opts.path?.trim();
+  const expectExists = opts.expectExists ?? true;
+  if (nameSelector && pathSelector) {
+    throw new WorkspaceResolutionError(
+      "--workspace-name and --workspace-path are mutually exclusive. Pass one or neither.",
+      "both-flags"
+    );
+  }
+  if (pathSelector) {
+    const expanded = expandTilde(pathSelector);
+    const dir = path3.resolve(expanded);
+    if (expectExists && !await dirExists(dir)) {
+      throw new WorkspaceResolutionError(`Workspace directory not found: ${dir}`, "path-missing");
+    }
+    return { dir, id: null, name: null, fromRegistry: false, registryRoot: null };
+  }
+  const registry = await (0, import_registry.loadRegistry)(root);
+  if (nameSelector) {
+    if (!registry) {
+      throw new WorkspaceResolutionError(
+        `No workspaces are registered at ${root}. Open the desktop app once to seed the registry, or pass --workspace-path <dir> to point at a workspace directory directly.`,
+        "no-registry"
+      );
+    }
+    const entry3 = (0, import_registry.findWorkspaceEntry)(registry, nameSelector);
+    if (!entry3) {
+      throw new WorkspaceResolutionError(
+        `No workspace named "${nameSelector}" in the registry at ${root}. Run \`apicircle workspaces list\` to see what's available.`,
+        "not-found"
+      );
+    }
+    return {
+      dir: (0, import_registry.workspaceDirFor)(root, entry3.id),
+      id: entry3.id,
+      name: entry3.name,
+      fromRegistry: true,
+      registryRoot: root
+    };
+  }
+  if (registry && registry.activeWorkspaceId) {
+    const active = registry.workspaces.find((w) => w.id === registry.activeWorkspaceId);
+    if (active) {
+      return {
+        dir: (0, import_registry.workspaceDirFor)(root, active.id),
+        id: active.id,
+        name: active.name,
+        fromRegistry: true,
+        registryRoot: root
+      };
+    }
+  }
+  return {
+    dir: path3.resolve(process.cwd()),
+    id: null,
+    name: null,
+    fromRegistry: false,
+    registryRoot: null
+  };
+}
+async function createWorkspaceOnDisk(args) {
+  const root = args.workspacesRoot ?? defaultWorkspacesRoot();
+  const trimmed = args.name.trim();
+  if (!trimmed) throw new Error("Workspace name is required");
+  const existing = await (0, import_registry.loadRegistry)(root);
+  if (existing && existing.workspaces.some((w) => w.name.toLowerCase() === trimmed.toLowerCase())) {
+    throw new Error(`A workspace named "${trimmed}" already exists`);
+  }
+  const workspaceId = (0, import_shared3.generateId)();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const state = buildEmptyState(workspaceId, now, args.sampleRequest ?? false);
+  const dir = (0, import_registry.workspaceDirFor)(root, workspaceId);
+  await (0, import_file_backed2.saveToFile)(dir, state);
+  const entry3 = {
+    id: workspaceId,
+    name: trimmed,
+    createdAt: now,
+    lastOpenedAt: now
+  };
+  const registry = await (0, import_registry.registerWorkspace)(root, entry3);
+  return { registry, entry: entry3, state, dir };
+}
+async function listWorkspacesOnDisk(args = {}) {
+  const root = args.workspacesRoot ?? defaultWorkspacesRoot();
+  const registry = await (0, import_registry.loadRegistry)(root) ?? {
+    schemaVersion: 1,
+    activeWorkspaceId: null,
+    workspaces: []
+  };
+  return { registry, root };
+}
+async function saveRegistryToDisk(registry, workspacesRoot) {
+  await (0, import_registry.saveRegistry)(workspacesRoot ?? defaultWorkspacesRoot(), registry);
+}
+function expandTilde(value) {
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path3.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
+async function dirExists(p) {
+  try {
+    const st = await import_node_fs3.promises.stat(p);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function buildEmptyState(workspaceId, now, withSample) {
+  const sample = withSample ? {
+    id: (0, import_shared3.generateId)(),
+    name: "Sample: GET /anything",
+    folderId: null,
+    method: "GET",
+    url: "https://httpbin.org/anything",
+    headers: [{ key: "Accept", value: "application/json", enabled: true }],
+    query: [],
+    body: { type: "none", content: "" },
+    auth: { type: "inherit" },
+    contextVars: [],
+    extractions: [],
+    assertions: [],
+    createdAt: now,
+    updatedAt: now
+  } : null;
+  const folders = {};
+  const requests = sample ? { [sample.id]: sample } : {};
+  return {
+    synced: {
+      schemaVersion: 1,
+      workspaceId,
+      collections: {
+        tree: {
+          id: (0, import_shared3.generateId)(),
+          type: "root",
+          children: sample ? [{ kind: "request", id: sample.id }] : []
+        },
+        requests,
+        folders
+      },
+      environments: { items: {}, activeName: null, priorityOrder: [] },
+      linkedWorkspaces: {},
+      linkedOverrides: { requests: {}, environmentVars: {} },
+      releases: { self: null, perLink: {} },
+      globalAssets: { schemas: {}, graphql: {}, files: {} },
+      mockServers: {},
+      meta: { createdAt: now, updatedAt: now, appVersion: "1.0.0" }
+    },
+    local: {
+      schemaVersion: 1,
+      workspaceId,
+      executionPlans: {},
+      history: { requestRuns: [], planRuns: [] },
+      secretIndex: { entries: {} },
+      sessions: { github: { workspace: null, links: {} } },
+      connectedRepo: null,
+      workingBranch: null,
+      seededWorkspaceSha: null,
+      retiredBranch: null,
+      sync: { lastPulledSnapshot: null, lastPulledSha: null, lastPulledAt: null, dirtyKeys: [] },
+      linkedCollections: {},
+      attachmentCache: {},
+      globalContext: {},
+      mockRuntime: { active: {} },
+      ui: {
+        activeRequestId: sample?.id ?? null,
+        sidebarExpandedSections: [],
+        themeId: "command-center",
+        fontId: "cascadia-code",
+        fontSizePercent: 100
+      },
+      settings: { validateOnSend: true, monacoConsumesWheel: false },
+      snapshots: { entries: [], maxBytes: 50 * 1024 * 1024 }
+    }
+  };
+}
+var os, path3, import_node_fs3, import_registry, import_file_backed2, import_shared3, APP_NAME, APP_SUBDIR, WORKSPACES_DIRNAME, WorkspaceResolutionError;
+var init_resolveWorkspace = __esm({
+  "src/util/resolveWorkspace.ts"() {
+    "use strict";
+    os = __toESM(require("os"), 1);
+    path3 = __toESM(require("path"), 1);
+    import_node_fs3 = require("fs");
+    import_registry = require("@apicircle/core/workspace/registry");
+    import_file_backed2 = require("@apicircle/core/workspace/file-backed");
+    import_shared3 = require("@apicircle/shared");
+    APP_NAME = "@apicircle";
+    APP_SUBDIR = "desktop";
+    WORKSPACES_DIRNAME = "workspaces";
+    WorkspaceResolutionError = class extends Error {
+      code;
+      constructor(message, code) {
+        super(message);
+        this.name = "WorkspaceResolutionError";
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/commands/mcp.ts
+function registerMcpCommand(program) {
+  program.command("mcp").description("Run the API Circle MCP server (stdio transport)").option(
+    "--workspace-name <name-or-id>",
+    "Registry workspace name (case-insensitive) or id. Defaults to the active workspace."
+  ).option(
+    "--workspace-path <dir>",
+    "Filesystem directory containing workspace.synced.json (skips the registry)."
+  ).action(async (opts) => {
+    let dir;
+    let label;
+    try {
+      const resolved = await resolveWorkspace({
+        name: opts.workspaceName,
+        path: opts.workspacePath,
+        expectExists: false
+      });
+      dir = resolved.dir;
+      label = resolved.fromRegistry ? `${resolved.name ?? resolved.id} (${dir})` : dir;
+    } catch (err) {
+      if (err instanceof WorkspaceResolutionError) {
+        process.stderr.write(`${import_kleur2.default.red("error")}: ${err.message}
+`);
+        process.exit(2);
+      }
+      throw err;
+    }
+    try {
+      await ensureWorkspace(dir);
+    } catch (err) {
+      process.stderr.write(
+        `${import_kleur2.default.red("failed to initialise workspace")} at ${dir}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exit(1);
+    }
+    const workspace = new import_mcp_server.FileBackedWorkspaceProvider(dir);
+    const mock = new import_mcp_server.InProcessMockController();
+    const host = (0, import_mcp_server.createMcpServer)({ workspace, mock });
+    process.stderr.write(`${import_kleur2.default.green("apicircle-mcp")} ready \xB7 workspace=${label}
+`);
+    await host.connect();
+  });
+}
+var import_kleur2, import_mcp_server;
+var init_mcp = __esm({
+  "src/commands/mcp.ts"() {
+    "use strict";
+    import_kleur2 = __toESM(require("kleur"), 1);
+    import_mcp_server = require("@apicircle/mcp-server");
+    init_loadWorkspace();
+    init_resolveWorkspace();
+  }
+});
+
+// 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(
+    "--workspace-name <name-or-id>",
+    "Registry workspace name (case-insensitive) or id. Defaults to the active workspace."
+  ).option(
+    "--workspace-path <dir>",
+    "Filesystem directory containing workspace.synced.json (skips the registry)."
+  ).option("-f, --format <format>", "OpenAPI format: json | yaml", "json").action(async (type, input, opts) => {
+    let dir;
+    try {
+      const resolved = await resolveWorkspace({
+        name: opts.workspaceName,
+        path: opts.workspacePath,
+        expectExists: false
+      });
+      dir = resolved.dir;
+      if (resolved.fromRegistry) {
+        process.stderr.write(
+          `${import_kleur3.default.dim("workspace")}: ${import_kleur3.default.cyan(resolved.name ?? resolved.id ?? "")} ${import_kleur3.default.dim(`(${dir})`)}
+`
+        );
+      }
+    } catch (err) {
+      if (err instanceof WorkspaceResolutionError) {
+        process.stderr.write(`${import_kleur3.default.red("error")}: ${err.message}
+`);
+        process.exit(2);
+      }
+      throw err;
+    }
+    const raw = await readInput(input);
+    const state = await ensureWorkspace(dir);
+    let nextSynced = state.synced;
+    let nextLocal = state.local;
+    const created = [];
+    const append = (req) => {
+      const out = (0, import_core.applyMutation)(
+        { synced: nextSynced, local: nextLocal },
+        { kind: "request.create", request: req }
+      );
+      nextSynced = out.next.synced;
+      nextLocal = out.next.local;
+      created.push(req.id);
+    };
+    if (type === "curl") {
+      const { parseCurl } = await import("@apicircle/core");
+      const parsed = parseCurl(raw);
+      append(
+        blankRequest({
+          name: `cURL ${parsed.method} ${parsed.url}`.slice(0, 80),
+          method: parsed.method,
+          url: parsed.url,
+          headers: parsed.headers,
+          query: parsed.query,
+          body: parsed.body,
+          auth: parsed.auth
+        })
+      );
+    } else if (type === "openapi") {
+      const parsed = await (0, import_mock_server_core2.parseOpenApiToEndpoints)(raw, opts.format ?? "json");
+      for (const ep of parsed.endpoints) {
+        append(
+          blankRequest({
+            name: ep.example ?? `${ep.method} ${ep.pathPattern}`,
+            method: ep.method,
+            url: ep.pathPattern
+          })
+        );
+      }
+    } else if (type === "postman") {
+      const parsed = (0, import_mock_server_core2.parsePostmanToEndpoints)(raw);
+      for (const ep of parsed.endpoints) {
+        append(
+          blankRequest({
+            name: ep.example ?? `${ep.method} ${ep.pathPattern}`,
+            method: ep.method,
+            url: ep.pathPattern
+          })
+        );
+      }
+    } else if (type === "insomnia") {
+      const parsed = (0, import_mock_server_core2.parseInsomniaToEndpoints)(raw);
+      for (const ep of parsed.endpoints) {
+        append(
+          blankRequest({
+            name: ep.example ?? `${ep.method} ${ep.pathPattern}`,
+            method: ep.method,
+            url: ep.pathPattern
+          })
+        );
+      }
+    } else {
+      process.stderr.write(`${import_kleur3.default.red("error")}: unknown type '${String(type)}'
+`);
+      process.exit(2);
+    }
+    await (0, import_file_backed3.saveToFile)(dir, { synced: nextSynced, local: nextLocal });
+    process.stdout.write(
+      `${import_kleur3.default.green("imported")} ${created.length} request${created.length === 1 ? "" : "s"} into ${dir}
+`
+    );
+  });
+}
+async function readInput(p) {
+  if (p === "-") {
+    return new Promise((resolve7, 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("error", reject);
+    });
+  }
+  return import_node_fs4.promises.readFile(path4.resolve(p), "utf-8");
+}
+function blankRequest(partial) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: (0, import_shared4.generateId)(),
+    folderId: null,
+    headers: [],
+    query: [],
+    body: { type: "none", content: "" },
+    auth: { type: "none" },
+    contextVars: [],
+    extractions: [],
+    assertions: [],
+    createdAt: now,
+    updatedAt: now,
+    ...partial
+  };
+}
+var import_node_fs4, path4, import_kleur3, import_core, import_file_backed3, import_mock_server_core2, import_shared4;
+var init_import = __esm({
+  "src/commands/import.ts"() {
+    "use strict";
+    import_node_fs4 = require("fs");
+    path4 = __toESM(require("path"), 1);
+    import_kleur3 = __toESM(require("kleur"), 1);
+    import_core = require("@apicircle/core");
+    import_file_backed3 = require("@apicircle/core/workspace/file-backed");
+    import_mock_server_core2 = require("@apicircle/mock-server-core");
+    import_shared4 = require("@apicircle/shared");
+    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 parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(
+        `--secrets ${options.secretsFile}: expected an object mapping secretKeyId \u2192 value`
+      );
+    }
+    for (const [id, value] of Object.entries(parsed)) {
+      if (typeof value !== "string") {
+        throw new Error(`--secrets ${options.secretsFile}: value for "${id}" must be a string`);
+      }
+      byId[id] = value;
+    }
+  }
+  for (const [name, value] of Object.entries(env)) {
+    if (!name.startsWith(prefix) || typeof value !== "string") continue;
+    const id = name.slice(prefix.length);
+    if (id) byId[id] = value;
+  }
+  return { byId };
+}
+var path5, import_node_fs5, DEFAULT_PREFIX;
+var init_secrets = __esm({
+  "src/util/secrets.ts"() {
+    "use strict";
+    path5 = __toESM(require("path"), 1);
+    import_node_fs5 = require("fs");
+    DEFAULT_PREFIX = "APICIRCLE_SECRET_";
+  }
+});
+
+// src/util/executionAttachments.ts
+async function prepareExecutionAttachments(workspaceDir, state, plan) {
+  const cacheDir = path6.resolve(workspaceDir, ATTACHMENTS_DIR);
+  const requirements = collectExecutionAttachmentRequirements(state, plan);
+  await import_node_fs6.promises.mkdir(cacheDir, { recursive: true });
+  let downloaded = 0;
+  let alreadyPresent = 0;
+  let failed = 0;
+  const cache = {
+    ...state.local.attachmentCache ?? {}
+  };
+  const entries = [];
+  for (const requirement of requirements) {
+    const localPath = path6.join(cacheDir, encodeURIComponent(requirement.slotId));
+    const present = await hasExpectedFile(localPath, requirement.sha256);
+    if (present) {
+      alreadyPresent++;
+    } else {
+      try {
+        const bytes = await downloadAttachment(requirement);
+        if (!bytes) {
+          throw new Error(
+            `Attachment ${attachmentLabel(requirement)} was not found in ${sourceLabel(requirement)}.`
+          );
+        }
+        if (requirement.sha256 && sha256Hex(bytes) !== requirement.sha256) {
+          throw new Error(
+            `Attachment ${attachmentLabel(requirement)} failed checksum verification.`
+          );
+        }
+        await import_node_fs6.promises.writeFile(localPath, bytes, { mode: 384 });
+        downloaded++;
+      } catch (err) {
+        failed++;
+        throw new Error(
+          `Attachment ${attachmentLabel(requirement)} is required by ${requiredByLabel(
+            requirement
+          )} but could not be downloaded from ${sourceLabel(requirement)}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    cache[requirement.slotId] = {
+      slotId: requirement.slotId,
+      filename: requirement.filename ?? requirement.slotId,
+      mimeType: requirement.mimeType ?? "application/octet-stream",
+      size: requirement.size ?? await fileSize(localPath),
+      sha256: requirement.sha256,
+      localPath,
+      storage: "filesystem",
+      source: requirement.source,
+      ...requirement.linkedWorkspaceId ? { linkedWorkspaceId: requirement.linkedWorkspaceId } : {},
+      requiredBy: requirement.requiredBy,
+      downloadedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    entries.push({
+      slotId: requirement.slotId,
+      filename: requirement.filename ?? requirement.slotId,
+      localPath,
+      source: requirement.source,
+      ...requirement.linkedWorkspaceId ? { linkedWorkspaceId: requirement.linkedWorkspaceId } : {},
+      requiredBy: requirement.requiredBy
+    });
+  }
+  const nextState = {
+    ...state,
+    local: {
+      ...state.local,
+      attachmentCache: cache
+    }
+  };
+  return {
+    state: nextState,
+    resolveAttachment: createFileAttachmentResolver(nextState),
+    summary: {
+      total: requirements.length,
+      downloaded,
+      alreadyPresent,
+      failed,
+      cacheDir,
+      entries
+    }
+  };
+}
+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 view = new Uint8Array(bytes);
+    const body = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+    return {
+      blob: new Blob([body], { type: meta.mimeType }),
+      filename: meta.filename
+    };
+  };
+}
+function collectExecutionAttachmentRequirements(state, plan) {
+  const seen = /* @__PURE__ */ new Map();
+  const localRequestFilter = requestFilterForPlan(plan, null);
+  const localCollections = localRequestFilter ? {
+    ...state.synced.collections,
+    requests: Object.fromEntries(
+      Object.entries(state.synced.collections.requests).filter(
+        ([id]) => localRequestFilter.has(id)
+      )
+    )
+  } : state.synced.collections;
+  const workspaceSlots = (0, import_core2.collectAttachmentSlots)({ ...state.synced, collections: localCollections });
+  for (const slot of workspaceSlots) {
+    const requiredBy = collectRequiredBy(localCollections.requests, slot.slotId);
+    if (requiredBy.length === 0) continue;
+    addRequirement(seen, {
+      ...slot,
+      source: "workspace",
+      repoFullName: state.local.connectedRepo?.fullName ?? void 0,
+      branch: state.local.workingBranch?.name ?? void 0,
+      publicRepo: state.local.connectedRepo ? !state.local.connectedRepo.isPrivate : false,
+      requiredBy
+    });
+  }
+  for (const [linkedWorkspaceId, snapshot] of Object.entries(state.local.linkedCollections)) {
+    const link = state.synced.linkedWorkspaces[linkedWorkspaceId];
+    if (!link) continue;
+    const linkedRequestFilter = requestFilterForPlan(plan, linkedWorkspaceId);
+    if (plan && linkedRequestFilter && linkedRequestFilter.size === 0) continue;
+    const linkedCollections = linkedRequestFilter ? {
+      ...snapshot.collections,
+      requests: Object.fromEntries(
+        Object.entries(snapshot.collections.requests).filter(
+          ([id]) => linkedRequestFilter.has(id)
+        )
+      )
+    } : snapshot.collections;
+    const linkedSynced = {
+      ...state.synced,
+      collections: linkedCollections,
+      environments: snapshot.environments,
+      globalAssets: snapshot.globalAssets ?? state.synced.globalAssets
+    };
+    for (const slot of (0, import_core2.collectAttachmentSlots)(linkedSynced)) {
+      const requiredBy = collectRequiredBy(linkedCollections.requests, slot.slotId);
+      if (requiredBy.length === 0) continue;
+      addRequirement(seen, {
+        ...slot,
+        source: "linked-workspace",
+        linkedWorkspaceId,
+        repoFullName: link.source.repoFullName,
+        branch: link.source.branch,
+        publicRepo: link.kind === "public",
+        requiredBy
+      });
+    }
+  }
+  return [...seen.values()];
+}
+function requestFilterForPlan(plan, linkedWorkspaceId) {
+  if (!plan) return null;
+  const ids = /* @__PURE__ */ new Set();
+  for (const step of plan.steps) {
+    if (step.enabled === false) continue;
+    if ((step.linkedWorkspaceId ?? null) === linkedWorkspaceId) ids.add(step.requestId);
+  }
+  return ids;
+}
+function addRequirement(seen, requirement) {
+  const existing = seen.get(requirement.slotId);
+  if (!existing) {
+    seen.set(requirement.slotId, requirement);
+    return;
+  }
+  for (const usage of requirement.requiredBy) {
+    if (!existing.requiredBy.some((item) => item.requestId === usage.requestId)) {
+      existing.requiredBy.push(usage);
+    }
+  }
+}
+function collectRequiredBy(requests, slotId) {
+  const requiredBy = [];
+  for (const request of Object.values(requests)) {
+    if (bodyReferencesSlot(request.body, slotId)) {
+      requiredBy.push({ requestId: request.id, requestName: request.name });
+    }
+  }
+  return requiredBy;
+}
+function bodyReferencesSlot(body, slotId) {
+  if (body.type === "binary") return body.attachment?.slotId === slotId;
+  if (body.type !== "form-data") return false;
+  return (body.formRows ?? []).some((row) => row.kind === "file" && row.slotId === slotId);
+}
+async function hasExpectedFile(localPath, sha256) {
+  try {
+    const bytes = await import_node_fs6.promises.readFile(localPath);
+    if (!sha256) return true;
+    return sha256Hex(bytes) === sha256;
+  } catch {
+    return false;
+  }
+}
+async function fileSize(localPath) {
+  try {
+    return (await import_node_fs6.promises.stat(localPath)).size;
+  } catch {
+    return 0;
+  }
+}
+async function downloadAttachment(requirement) {
+  if (!requirement.repoFullName || !requirement.branch) return null;
+  const [owner, repo] = requirement.repoFullName.split("/", 2);
+  if (!owner || !repo) return null;
+  const token = resolveGitHubToken(requirement);
+  if (!token && !requirement.publicRepo) {
+    throw new Error(
+      "private linked attachments need a GitHub token (set APICIRCLE_GITHUB_TOKEN or GITHUB_TOKEN)"
+    );
+  }
+  const apiPath = [".apicircle", "attachments", requirement.slotId].map(encodeURIComponent).join("/");
+  const url = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(
+    repo
+  )}/contents/${apiPath}?ref=${encodeURIComponent(requirement.branch)}`;
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "User-Agent": "apicircle-cli",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(url, { headers, cache: "no-store" });
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    throw new Error(`GitHub returned ${res.status}: ${await res.text()}`);
+  }
+  const json = await res.json();
+  if (json.type !== "file" || typeof json.content !== "string") {
+    throw new Error("GitHub response was not a file");
+  }
+  if (json.encoding !== "base64") {
+    throw new Error(`GitHub response used unsupported encoding ${json.encoding ?? "(missing)"}`);
+  }
+  return new Uint8Array(Buffer.from(json.content.replace(/\n/g, ""), "base64"));
+}
+function resolveGitHubToken(requirement) {
+  if (requirement.source === "linked-workspace") {
+    return process.env.APICIRCLE_E2E_BOT_PAT_LINK_DEDICATED ?? process.env.APICIRCLE_GITHUB_TOKEN ?? process.env.GITHUB_TOKEN ?? process.env.APICIRCLE_E2E_GITHUB_PAT ?? process.env.APICIRCLE_E2E_BOT_PAT ?? "";
+  }
+  return process.env.APICIRCLE_GITHUB_TOKEN ?? process.env.GITHUB_TOKEN ?? process.env.APICIRCLE_E2E_GITHUB_PAT ?? process.env.APICIRCLE_E2E_BOT_PAT ?? "";
+}
+function sha256Hex(bytes) {
+  return (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+}
+function attachmentLabel(requirement) {
+  return `${requirement.filename ?? requirement.slotId} (${requirement.slotId})`;
+}
+function sourceLabel(requirement) {
+  const repo = requirement.repoFullName ?? "local workspace";
+  const branch = requirement.branch ? `@${requirement.branch}` : "";
+  return `${repo}${branch}`;
+}
+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 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");
+  }
+});
+
+// src/commands/run.ts
+function registerRunCommand(program) {
+  program.command("run").description("Run a saved execution plan from a workspace and report the result").argument("<plan>", "Plan name or id to run").option(
+    "--workspace-name <name-or-id>",
+    "Registry workspace name (case-insensitive) or id. Defaults to the active workspace."
+  ).option(
+    "--workspace-path <dir>",
+    "Filesystem directory containing workspace.synced.json (skips the registry)."
+  ).option("--no-assertions", "Run requests without evaluating their assertions").option("-s, --secrets <file>", "JSON file mapping secretKeyId \u2192 plaintext value").option("--no-save", "Do not write the plan run to workspace history").option("--reporter <format>", "Report format: text | json | junit", "text").option("--bail", "Stop the run at the first failed step").option("-e, --env <name>", "Layer a local environment on top of the run").option("--as <actor>", "Override the recorded runner identity").action(async (planRef, opts) => {
+    let dir;
+    try {
+      const resolved = await resolveWorkspace({
+        name: opts.workspaceName,
+        path: opts.workspacePath,
+        expectExists: false
+      });
+      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})`)}
+`
+        );
+      }
+    } catch (err) {
+      if (err instanceof WorkspaceResolutionError) {
+        fail(err.message);
+        return;
+      }
+      throw err;
+    }
+    const reporter = opts.reporter ?? "text";
+    if (!isReporter(reporter)) {
+      fail(`unknown --reporter "${reporter}" (expected: ${REPORTERS.join(", ")})`);
+      return;
+    }
+    const state = await (0, import_file_backed4.loadFromFile)(dir, { allowMissing: true });
+    if (!state) {
+      fail(`no workspace found at ${dir} (expected workspace.synced.json)`);
+      return;
+    }
+    const ref = (0, import_core3.resolvePlanRef)(state.synced, planRef);
+    if (!ref.ok) {
+      fail(ref.error);
+      if (ref.available.length > 0) {
+        process.stderr.write(`Available plans: ${ref.available.join(", ")}
+`);
+      }
+      return;
+    }
+    if (opts.env && !state.synced.environments.items[opts.env]) {
+      const names = Object.keys(state.synced.environments.items);
+      fail(`no environment named "${opts.env}" in this workspace`);
+      if (names.length > 0) {
+        process.stderr.write(`Available environments: ${names.join(", ")}
+`);
+      }
+      return;
+    }
+    let secretsById;
+    try {
+      secretsById = (await buildSecretsFromCli({ secretsFile: opts.secrets })).byId;
+    } catch (err) {
+      fail(err instanceof Error ? err.message : String(err));
+      return;
+    }
+    const actor = resolveActor(state.local, opts.as);
+    const withAssertions = opts.assertions !== false;
+    const text = reporter === "text";
+    const controller = new AbortController();
+    const onSigint = () => controller.abort(new Error("aborted by SIGINT"));
+    process.on("SIGINT", onSigint);
+    if (text) process.stdout.write(formatHeader(ref.plan, actor, withAssertions, opts));
+    let prepared;
+    try {
+      prepared = await prepareExecutionAttachments(dir, state, ref.plan);
+    } catch (err) {
+      process.off("SIGINT", onSigint);
+      fail(err instanceof Error ? err.message : String(err), 1, "attachment");
+      return;
+    }
+    if (text && prepared.summary.total > 0) {
+      process.stdout.write(formatAttachmentPreparation(prepared.summary));
+    }
+    let result;
+    try {
+      result = await (0, import_core3.runPlan)(prepared.state, ref.id, {
+        withAssertions,
+        bail: opts.bail === true,
+        env: opts.env,
+        secretsById,
+        actor,
+        signal: controller.signal,
+        resolveAttachment: prepared.resolveAttachment,
+        authorize: checkRunPermission,
+        onStep: text ? (step) => process.stdout.write(formatStepLine(step)) : void 0
+      });
+    } catch (err) {
+      process.off("SIGINT", onSigint);
+      if (err instanceof import_core3.PlanRunDeniedError) {
+        fail(err.message, 3, "denied");
+        return;
+      }
+      throw err;
+    }
+    process.off("SIGINT", onSigint);
+    const aborted = controller.signal.aborted;
+    const saved = opts.save !== false;
+    if (saved) await (0, import_file_backed4.saveToFile)(dir, result.nextState);
+    if (reporter === "json") {
+      process.stdout.write(
+        JSON.stringify(
+          buildJsonReport(dir, ref.id, ref.plan, actor, result, saved, aborted, prepared.summary),
+          null,
+          2
+        ) + "\n"
+      );
+    } else if (reporter === "junit") {
+      process.stdout.write(buildJunitReport(ref.plan, result));
+    } else {
+      process.stdout.write(formatSummary(result, saved, aborted));
+    }
+    process.exitCode = result.passed && !aborted ? 0 : 1;
+  });
+}
+function isReporter(value) {
+  return REPORTERS.includes(value);
+}
+function resolveActor(local, override) {
+  const explicit = override?.trim();
+  if (explicit) return { kind: "unknown", name: explicit };
+  const login = local.sessions.github.workspace?.accountLogin;
+  if (login) return { kind: "github", name: login };
+  try {
+    const username = os2.userInfo().username;
+    if (username) return { kind: "os", name: username };
+  } catch {
+  }
+  return import_core3.ANONYMOUS_ACTOR;
+}
+function checkRunPermission(_ctx) {
+}
+function formatHeader(plan, actor, withAssertions, opts) {
+  const enabled = plan.steps.filter((s) => s.enabled !== false).length;
+  const flags = [
+    withAssertions ? "assertions on" : "assertions off",
+    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(
+    `(${enabled}/${plan.steps.length} steps \xB7 ${flags.join(" \xB7 ")})`
+  )}
+${import_kleur4.default.dim("Run by")} ${actor.name} ${import_kleur4.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(
+      `(${status} - ${summary.cacheDir})`
+    )}`
+  ];
+  for (const entry3 of summary.entries) {
+    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(
+        `${source} - ${requiredBy} - ${entry3.localPath}`
+      )}`
+    );
+  }
+  return `${lines.join("\n")}
+
+`;
+}
+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(
+      `${step.requestName}  skipped`
+    )}
+`;
+  }
+  const mark = step.passed ? import_kleur4.default.green("\u2713") : import_kleur4.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)}`;
+  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 += "\n";
+  if (step.error) {
+    line += `      ${import_kleur4.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 (step.missingVariables.length > 0) {
+    line += `      ${import_kleur4.default.yellow("\u26A0")} unresolved: ${step.missingVariables.map((v) => `{{${v}}}`).join(", ")}
+`;
+  }
+  return line;
+}
+function tally(result) {
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const s of result.steps) {
+    if (s.skipped) skipped++;
+    else if (s.passed) passed++;
+    else failed++;
+  }
+  return { passed, failed, skipped };
+}
+function formatSummary(result, saved, aborted) {
+  if (result.steps.length === 0) {
+    return `
+${import_kleur4.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`)
+  ];
+  const verdict = result.passed && !aborted ? import_kleur4.default.green("PASS") : import_kleur4.default.red("FAIL");
+  let out = `
+${verdict}  ${parts.join(import_kleur4.default.dim(" \xB7 "))}  ${import_kleur4.default.dim(
+    `\xB7 ${result.planRun.durationMs}ms`
+  )}
+`;
+  if (aborted) out += `${import_kleur4.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");
+  return out;
+}
+function buildJsonReport(workspace, planId, plan, actor, result, saved, aborted, attachments) {
+  return {
+    workspace,
+    plan: { id: planId, name: plan.name },
+    actor,
+    withAssertions: result.planRun.withAssertions,
+    passed: result.passed && !aborted,
+    aborted,
+    durationMs: result.planRun.durationMs,
+    saved,
+    attachments,
+    counts: tally(result),
+    steps: result.steps.map((s) => ({
+      step: s.stepIndex + 1,
+      request: s.requestName,
+      method: s.requestMethod,
+      skipped: s.skipped,
+      status: s.result?.status ?? null,
+      ok: s.result?.ok ?? false,
+      durationMs: s.result?.durationMs ?? 0,
+      passed: s.passed,
+      error: s.error ?? null,
+      missingVariables: s.missingVariables,
+      assertions: s.assertionResults.map((a) => ({
+        kind: a.kind,
+        op: a.op,
+        target: a.target,
+        expected: a.expected,
+        passed: a.passed,
+        detail: a.detail
+      }))
+    }))
+  };
+}
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildJunitReport(plan, result) {
+  const { failed, skipped } = tally(result);
+  const total = result.steps.length;
+  const suite = xmlEscape(plan.name);
+  const suiteTime = (result.planRun.durationMs / 1e3).toFixed(3);
+  const cases = result.steps.map((s) => {
+    const name = xmlEscape(`${s.stepIndex + 1}. ${s.requestName}`);
+    const time = ((s.result?.durationMs ?? 0) / 1e3).toFixed(3);
+    const open = `    <testcase name="${name}" classname="${suite}" time="${time}"`;
+    if (s.skipped) return `${open}>
+      <skipped/>
+    </testcase>`;
+    if (s.passed) return `${open}/>`;
+    const reasons = [];
+    if (s.error) reasons.push(s.error);
+    for (const a of s.assertionResults) {
+      if (!a.passed) reasons.push(a.detail ?? `assertion ${a.kind} ${a.op} failed`);
+    }
+    if (s.result && !s.result.ok && s.result.status != null) {
+      reasons.push(`HTTP ${s.result.status}`);
+    }
+    const detail = xmlEscape(reasons.join("\n") || "step failed");
+    const summary = detail.split("\n")[0];
+    return `${open}>
+      <failure message="${summary}">${detail}</failure>
+    </testcase>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="${suite}" tests="${total}" failures="${failed}" skipped="${skipped}" time="${suiteTime}">
+  <testsuite name="${suite}" tests="${total}" failures="${failed}" skipped="${skipped}" time="${suiteTime}">
+${cases.join("\n")}
+  </testsuite>
+</testsuites>
+`;
+}
+function fail(message, code = 2, kind = "error") {
+  process.stderr.write(`${import_kleur4.default.red(kind)}: ${message}
+`);
+  process.exitCode = code;
+}
+var os2, import_kleur4, import_core3, 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_file_backed4 = require("@apicircle/core/workspace/file-backed");
+    init_secrets();
+    init_resolveWorkspace();
+    init_executionAttachments();
+    REPORTERS = ["text", "json", "junit"];
+  }
+});
+
+// src/commands/workspaces.ts
+function registerWorkspacesCommand(program) {
+  const ws = program.command("workspaces").description("List, create, or switch the active workspace");
+  ws.command("list").description("List every workspace registered on this machine").option("--json", "Emit JSON instead of a formatted table").action(async (opts) => {
+    const { registry, root } = await listWorkspacesOnDisk();
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({ root, registry }, null, 2) + "\n");
+      return;
+    }
+    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(
+          "or open the desktop app to seed one."
+        )}
+`
+      );
+      return;
+    }
+    process.stdout.write(`${import_kleur5.default.dim("registry")}: ${root}
+
+`);
+    const rows = [...registry.workspaces].sort(
+      (a, b) => b.lastOpenedAt.localeCompare(a.lastOpenedAt)
+    );
+    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(
+        `  ${"".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") : " ";
+      process.stdout.write(
+        `  ${mark} ${w.name.padEnd(nameWidth)}  ${import_kleur5.default.dim(
+          w.id.padEnd(idWidth)
+        )}  ${import_kleur5.default.dim(w.lastOpenedAt)}
+`
+      );
+    }
+    process.stdout.write(`
+${import_kleur5.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) => {
+    try {
+      const { entry: entry3, dir, registry } = await createWorkspaceOnDisk({
+        name,
+        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})`)}
+  at ${dir}
+`
+      );
+      if (registry.activeWorkspaceId === entry3.id) {
+        process.stdout.write(`${import_kleur5.default.dim("marked as active")}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(
+        `${import_kleur5.default.red("error")}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exit(2);
+    }
+  });
+  ws.command("use").description("Set the active workspace by id or name").argument("<selector>", "Workspace id or name").action(async (selector) => {
+    const { registry, root } = await listWorkspacesOnDisk();
+    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.")}
+`
+      );
+      process.exit(2);
+      return;
+    }
+    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})`)}
+`
+    );
+  });
+  ws.command("path").description("Print the on-disk path for a workspace (or the workspaces root)").argument("[selector]", "Optional workspace id or name; prints the root when omitted").action(async (selector) => {
+    if (!selector) {
+      process.stdout.write(defaultWorkspacesRoot() + "\n");
+      return;
+    }
+    const { registry, root } = await listWorkspacesOnDisk();
+    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}.
+`
+      );
+      process.exit(2);
+      return;
+    }
+    void saveRegistryToDisk;
+    const { workspaceDirFor: workspaceDirFor2 } = await import("@apicircle/core/workspace/registry");
+    process.stdout.write(workspaceDirFor2(root, entry3.id) + "\n");
+  });
+}
+var import_kleur5, import_registry2;
+var init_workspaces = __esm({
+  "src/commands/workspaces.ts"() {
+    "use strict";
+    import_kleur5 = __toESM(require("kleur"), 1);
+    init_resolveWorkspace();
+    import_registry2 = require("@apicircle/core/workspace/registry");
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  buildProgram: () => buildProgram,
+  runCli: () => runCli
+});
+function buildProgram() {
+  const program = new import_commander.Command();
+  program.name("apicircle").description("Command-line companion to API Circle Studio.").version(CLI_PACKAGE_VERSION);
+  registerMockCommand(program);
+  registerMcpCommand(program);
+  registerImportCommand(program);
+  registerRunCommand(program);
+  registerWorkspacesCommand(program);
+  return program;
+}
+async function runCli(argv = process.argv) {
+  await buildProgram().parseAsync(argv);
+}
+var import_commander, entry;
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    import_commander = require("commander");
+    init_mock();
+    init_mcp();
+    init_import();
+    init_run();
+    init_workspaces();
+    init_packageVersion();
+    entry = process.argv[1] ?? "";
+    if (entry.endsWith("apicircle") || entry.endsWith("index.cjs") || entry.endsWith("index.ts")) {
+      void runCli();
+    }
+  }
+});
+
+// src/bin/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  runBin: () => runBin
+});
+module.exports = __toCommonJS(cli_exports);
+init_packageVersion();
+
+// src/bin/args.ts
+function hasRootVersionFlag(args) {
+  return args.length === 1 && ["--version", "-v", "-V"].includes(args[0] ?? "");
+}
+function hasRootHelpFlag(args) {
+  return args.length === 1 && ["--help", "-h", "help"].includes(args[0] ?? "");
+}
+function formatRootHelp() {
+  return `Usage: apicircle [options] [command]
+
+Command-line companion to API Circle Studio.
+
+Options:
+  -v, -V, --version  Print the version number.
+  -h, --help         Show help.
+
+Commands:
+  mock [options] <workspace>        Start a local mock server.
+  mcp [options] [workspace]         Start the MCP stdio server.
+  import <source> <workspace>       Import OpenAPI, Postman, Insomnia, or curl.
+  run [options] <plan-id>           Run an execution plan.
+  workspaces                        Manage local workspace registries.
+
+Run "apicircle <command> --help" for command-specific help.
+`;
+}
+
+// src/bin/cli.ts
+async function runBin(argv = process.argv) {
+  const args = argv.slice(2);
+  if (hasRootVersionFlag(args)) {
+    process.stdout.write(`${CLI_PACKAGE_VERSION}
+`);
+    return;
+  }
+  if (hasRootHelpFlag(args)) {
+    process.stdout.write(formatRootHelp());
+    return;
+  }
+  const { runCli: runCli2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  await runCli2(argv);
+}
+var entry2 = process.argv[1] ?? "";
+if (entry2.endsWith("apicircle") || entry2.endsWith("cli.cjs") || entry2.endsWith("cli.ts")) {
+  void runBin();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBin
+});
+//# sourceMappingURL=cli.cjs.map