@mycadet/cli 0.0.1 → 0.12.6-dev.202610080043.b727a33

package/node_modules/@mycadet/local-mode/src/teleport-backup-policy.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  hasRecentBackup,
+  managedBackupIsReady,
+  readyManagedBackupCreatedAts,
+  RECENT_BACKUP_MAX_AGE_MS,
+} from "./teleport-backup-policy";
+
+const NOW = Date.parse("2026-09-15T12:00:00Z");
+
+function ago(ms: number): string {
+  return new Date(NOW - ms).toISOString();
+}
+
+describe("hasRecentBackup", () => {
+  test("true when a backup is within the max age", () => {
+    expect(hasRecentBackup([ago(5 * 60_000)], NOW)).toBe(true);
+    expect(hasRecentBackup([ago(RECENT_BACKUP_MAX_AGE_MS)], NOW)).toBe(true);
+  });
+
+  test("false when every backup is older than the max age", () => {
+    expect(hasRecentBackup([ago(RECENT_BACKUP_MAX_AGE_MS + 1)], NOW)).toBe(
+      false,
+    );
+    expect(hasRecentBackup([ago(2 * 24 * 60 * 60_000)], NOW)).toBe(false);
+  });
+
+  test("false with no backups", () => {
+    expect(hasRecentBackup([], NOW)).toBe(false);
+  });
+
+  test("ignores empty, missing, unparseable and future timestamps", () => {
+    expect(
+      hasRecentBackup(["", undefined, null, "garbage", ago(-60_000)], NOW),
+    ).toBe(false);
+    expect(hasRecentBackup(["", "garbage", ago(60_000)], NOW)).toBe(true);
+  });
+
+  test("finds a recent backup anywhere in the list", () => {
+    expect(
+      hasRecentBackup(
+        [ago(3 * RECENT_BACKUP_MAX_AGE_MS), ago(30 * 60_000)],
+        NOW,
+      ),
+    ).toBe(true);
+  });
+
+  test("honors a custom max age", () => {
+    expect(hasRecentBackup([ago(10 * 60_000)], NOW, 5 * 60_000)).toBe(false);
+    expect(hasRecentBackup([ago(10 * 60_000)], NOW, 15 * 60_000)).toBe(true);
+  });
+});
+
+describe("readyManagedBackupCreatedAts", () => {
+  test("keeps ready snapshots and drops pending ones", () => {
+    expect(
+      readyManagedBackupCreatedAts([
+        {
+          snapshot_name: "a",
+          created_at: "2026-09-15T11:00:00Z",
+          ready_to_use: true,
+        },
+        {
+          snapshot_name: "b",
+          created_at: "2026-09-15T11:30:00Z",
+          ready_to_use: false,
+        },
+        { snapshot_name: "c", created_at: "2026-09-15T10:00:00Z" },
+      ]),
+    ).toEqual(["2026-09-15T11:00:00Z", "2026-09-15T10:00:00Z"]);
+  });
+});
+
+describe("managedBackupIsReady", () => {
+  const backups = [
+    { snapshot_name: "ready", ready_to_use: true },
+    { snapshot_name: "pending", ready_to_use: false },
+    { snapshot_name: "unknown" },
+  ];
+
+  test("true only for a snapshot explicitly marked ready", () => {
+    expect(managedBackupIsReady(backups, "ready")).toBe(true);
+    expect(managedBackupIsReady(backups, "pending")).toBe(false);
+    expect(managedBackupIsReady(backups, "unknown")).toBe(false);
+    expect(managedBackupIsReady(backups, "missing")).toBe(false);
+  });
+});

package/node_modules/@mycadet/local-mode/src/teleport-backup-policy.ts

@@ -0,0 +1,74 @@
+/**
+ * Pre-teleport backup policy shared by every teleport surface (CLI and web).
+ *
+ * A teleport ends with the source assistant being retired, so each surface
+ * snapshots the source before any data leaves it. This module holds the
+ * decisions those surfaces must agree on: how fresh an existing backup has to
+ * be to stand in for a new one, and how a platform (PVC) snapshot is judged
+ * restorable. Transport lives with each client; nothing here touches the
+ * network or the filesystem.
+ */
+
+/** A backup at most this old satisfies the pre-teleport backup requirement. */
+export const RECENT_BACKUP_MAX_AGE_MS = 60 * 60 * 1000;
+
+/** How long to wait for a freshly cut platform snapshot to become restorable. */
+export const MANAGED_BACKUP_READY_TIMEOUT_MS = 10 * 60 * 1000;
+
+/** How often to re-list platform snapshots while waiting for readiness. */
+export const MANAGED_BACKUP_READY_POLL_INTERVAL_MS = 5_000;
+
+/**
+ * Whether any of `createdAts` (ISO-8601 timestamps; empty, missing and
+ * unparseable values are ignored) falls within `maxAgeMs` of `now`.
+ */
+export function hasRecentBackup(
+  createdAts: Iterable<string | null | undefined>,
+  now: number = Date.now(),
+  maxAgeMs: number = RECENT_BACKUP_MAX_AGE_MS,
+): boolean {
+  for (const createdAt of createdAts) {
+    if (!createdAt) {
+      continue;
+    }
+    const createdMs = Date.parse(createdAt);
+    if (Number.isNaN(createdMs)) {
+      continue;
+    }
+    const age = now - createdMs;
+    if (age >= 0 && age <= maxAgeMs) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** The fields of a platform backup listing entry the policy reads. */
+export interface ManagedBackupEntry {
+  snapshot_name?: string;
+  created_at?: string;
+  ready_to_use?: boolean;
+}
+
+/**
+ * `created_at` of every restorable platform snapshot. A snapshot still being
+ * cut (`ready_to_use: false`) never counts as a usable restore point.
+ */
+export function readyManagedBackupCreatedAts(
+  backups: readonly ManagedBackupEntry[],
+): Array<string | undefined> {
+  return backups
+    .filter((backup) => backup.ready_to_use !== false)
+    .map((backup) => backup.created_at);
+}
+
+/** Whether the listing shows `snapshotName` as restorable. */
+export function managedBackupIsReady(
+  backups: readonly ManagedBackupEntry[],
+  snapshotName: string,
+): boolean {
+  return backups.some(
+    (backup) =>
+      backup.snapshot_name === snapshotName && backup.ready_to_use === true,
+  );
+}

package/node_modules/@mycadet/local-mode/src/unpair.ts

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { guardianTokenPath } from "./config";
+import {
+  readRawLockfile,
+  writeRawLockfile,
+  type WriteResult,
+} from "./lockfile";
+import { resolveCloud } from "./lockfile-contract";
+import { withLockfileLock } from "./lockfile-lock";
+
+/**
+ * Forget a paired assistant on this machine: remove its lockfile entry and
+ * delete its stored guardian token. Client-side only, mirroring the CLI's
+ * `cadet unpair`: the remote assistant itself is never touched (host-side
+ * device revocation is `cadet devices`). Only pairing records
+ * (`cloud: "paired"`, created by `cadet connect import`) are forgettable this
+ * way; local and managed assistants go through retire.
+ */
+export function unpairAssistant(
+  lockfilePaths: string[],
+  configDir: string,
+  assistantId: string,
+): WriteResult {
+  // The whole transaction holds the shared write lock so a concurrent
+  // read-modify-write (e.g. a persona-name rename) cannot restore the entry
+  // after its credential is deleted.
+  const locked = withLockfileLock(lockfilePaths, (): WriteResult =>
+    unpairAssistantLocked(lockfilePaths, configDir, assistantId),
+  );
+  if (!locked.ok) {
+    return { ok: false, status: 423, error: locked.error };
+  }
+  return locked.value;
+}
+
+function unpairAssistantLocked(
+  lockfilePaths: string[],
+  configDir: string,
+  assistantId: string,
+): WriteResult {
+  const lockfile = readRawLockfile(lockfilePaths);
+  const assistants = Array.isArray(lockfile.assistants)
+    ? (lockfile.assistants as Array<Record<string, unknown>>)
+    : [];
+  const entry = assistants.find((a) => a?.assistantId === assistantId);
+  if (!entry) {
+    return { ok: false, status: 404, error: "No such assistant" };
+  }
+  if (resolveCloud(entry) !== "paired") {
+    return {
+      ok: false,
+      status: 400,
+      error:
+        "Only paired assistants can be unpaired. Use retire for local or managed assistants.",
+    };
+  }
+
+  // Delete the token BEFORE committing the lockfile removal. A failed delete
+  // aborts with the entry intact, so unpair stays retryable; the reverse order
+  // would strand the credential on disk forever (the retry 404s on the
+  // already-removed entry and never reaches cleanup). The token contents are
+  // kept in memory so a failed lockfile write below can restore them.
+  const tokenPath = guardianTokenPath(configDir, assistantId);
+  let savedToken: string | null = null;
+  try {
+    savedToken = fs.readFileSync(tokenPath, "utf-8");
+  } catch {
+    savedToken = null;
+  }
+  try {
+    fs.rmSync(tokenPath, { force: true });
+  } catch (err) {
+    return {
+      ok: false,
+      status: 500,
+      error: `Failed to delete the stored guardian token: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    };
+  }
+  try {
+    fs.rmdirSync(path.dirname(tokenPath));
+  } catch {
+    // Directory not empty or absent.
+  }
+
+  const remaining = assistants.filter((a) => a?.assistantId !== assistantId);
+  lockfile.assistants = remaining;
+  // Reassign the active assistant like the CLI's removeAssistantEntry does, so
+  // unpairing through the bridge and through `cadet unpair` leave the same
+  // active state. Skip tolerated malformed entries (no string assistantId):
+  // parseLockfile drops them from the returned lockfile, so pointing at one
+  // would report no active assistant while valid entries remain.
+  if (lockfile.activeAssistant === assistantId) {
+    const next = remaining.find(
+      (a) => typeof a?.assistantId === "string",
+    )?.assistantId;
+    if (typeof next === "string") {
+      lockfile.activeAssistant = next;
+    } else {
+      delete lockfile.activeAssistant;
+    }
+  }
+
+  const result = writeRawLockfile(lockfilePaths, lockfile);
+  if (!result.ok && savedToken !== null) {
+    // The entry is still listed, so put its credential back (best-effort;
+    // the write failure itself is what gets reported).
+    try {
+      fs.mkdirSync(path.dirname(tokenPath), { recursive: true, mode: 0o700 });
+      fs.writeFileSync(tokenPath, savedToken, { mode: 0o600 });
+    } catch {
+      // Restore failed; the reported write error already covers the outcome.
+    }
+  }
+  return result;
+}

package/node_modules/@mycadet/local-mode/src/upgrade.ts

@@ -0,0 +1,149 @@
+import { spawn } from "node:child_process";
+
+import type { CliInvocation } from "./util";
+
+const UPGRADE_TIMEOUT_MS = 20 * 60 * 1000;
+
+export type UpgradeResult =
+  | { ok: true; version?: string }
+  | { ok: false; status: number; error: string };
+
+export interface UpgradeOptions {
+  version?: string;
+  latest?: boolean;
+  force?: boolean;
+}
+
+// A trusted release version is the literal `latest` dist-tag, or a
+// version-shaped string: an optional `v`/`V` prefix, then a leading digit,
+// then any run of `[0-9A-Za-z.+-]`. This is intentionally lenient about the
+// *shape* of the version (2-, 3-, or 4-part, arbitrary pre-release/build
+// identifiers, uppercase `V`) so we never reject a legitimate release tag.
+//
+// Security does not depend on the shape — it depends on the CHARSET. The
+// allowed set excludes `/`, `\`, `:`, `@`, `#` and whitespace, so the value can
+// never be interpreted by `bun install` as a package-manager spec (npm alias,
+// tarball/git URL, `file:`/`github:` ref) — all of which require one of those
+// characters. The mandatory leading digit means the value can never be a bare
+// `.`/`..` path segment, and `..` is rejected outright, so the version is safe
+// to use as the runtime-install directory name.
+const RELEASE_VERSION_PATTERN = /^(?:latest|[vV]?\d[0-9A-Za-z.+-]*)$/;
+
+/**
+ * Whether `version` is a trusted release identifier: the literal `latest`, or a
+ * version-shaped tag like `v1.2.3` / `1.2.3` / `0.6.0-staging.5`. Rejects
+ * package-manager specifiers (npm aliases, tarball or git URLs) and any
+ * path-traversal-like input, while staying permissive about semver shape.
+ *
+ * Defined once here and reused by both the host-bridge boundary guard
+ * (`runUpgrade`, in the shared library backing the Electron host and the web
+ * dev-server middleware) and the CLI's runtime-install sink
+ * (`ensureLocalRuntime`), so the security boundary can never drift between the
+ * two call sites.
+ */
+export function isValidReleaseVersion(version: string): boolean {
+  return RELEASE_VERSION_PATTERN.test(version) && !version.includes("..");
+}
+
+function extractVersion(output: string): string | undefined {
+  const versionPattern = "(v?[0-9]+(?:\\.[0-9]+)*(?:[-+][\\w.-]+)?)";
+  const upgraded = output.match(
+    new RegExp(`\\bupgraded to\\s+${versionPattern}`, "i"),
+  )?.[1];
+  if (upgraded) return upgraded;
+
+  return output.match(new RegExp(`\\bAlready on\\s+${versionPattern}`, "i"))?.[1];
+}
+
+/**
+ * Upgrade a local assistant via the CLI. The CLI owns the full lifecycle
+ * (backup, process restart, health wait, rollback on failure); the host
+ * bridge only starts it and returns the structured result to the renderer.
+ */
+export function runUpgrade(
+  invocation: CliInvocation,
+  assistantId: string,
+  options?: UpgradeOptions,
+): Promise<UpgradeResult> {
+  return new Promise((resolve) => {
+    // Reject an untrusted `--version` at the host boundary before spawning the
+    // CLI. `latest` (or the `--latest` flag) is always allowed; an explicit
+    // version must be a release tag. Preserves the never-reject contract.
+    if (options?.version && !isValidReleaseVersion(options.version)) {
+      resolve({
+        ok: false,
+        status: 400,
+        error: `Invalid upgrade version '${options.version}': expected a release tag like v1.2.3 or 'latest'.`,
+      });
+      return;
+    }
+
+    const args = [...invocation.baseArgs, "upgrade", assistantId];
+    if (options?.latest) {
+      args.push("--latest");
+    } else if (options?.version) {
+      args.push("--version", options.version);
+    }
+    if (options?.force) {
+      args.push("--force");
+    }
+
+    const child = spawn(invocation.command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+
+    const finish = (result: UpgradeResult) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timeout);
+      resolve(result);
+    };
+
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish({
+        ok: false,
+        status: 500,
+        error: `Upgrade timed out after ${UPGRADE_TIMEOUT_MS / 1000} seconds`,
+      });
+    }, UPGRADE_TIMEOUT_MS);
+
+    child.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        const version = extractVersion(stdout);
+        finish(version ? { ok: true, version } : { ok: true });
+        return;
+      }
+
+      finish({
+        ok: false,
+        status: 500,
+        error:
+          stderr.trim() ||
+          stdout.trim() ||
+          `Upgrade failed: the CLI exited with code ${code ?? "unknown"} and produced no output.`,
+      });
+    });
+
+    child.on("error", (err) => {
+      finish({
+        ok: false,
+        status: 500,
+        error: `Failed to spawn CLI: ${err.message}`,
+      });
+    });
+  });
+}

package/node_modules/@mycadet/local-mode/src/util.ts

@@ -0,0 +1,170 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+import { SENSITIVE_KEYS } from "./lockfile-contract";
+
+const CLI_PACKAGE_NAME = "@mycadet/cli";
+
+/**
+ * How to invoke the Cadet CLI as a child process: a base command plus the
+ * leading arguments that precede the subcommand. Each host resolves its own
+ * invocation — the dev hosts run the CLI from source via `bun run <entry>`,
+ * a packaged host would point at its bundled runtime — and the shared
+ * lifecycle ops (`runHatch`, `runRetire`, guardian-token refresh) append
+ * their subcommand args to `baseArgs`.
+ */
+export interface CliInvocation {
+  command: string;
+  baseArgs: string[];
+}
+
+export function stripSensitiveFields(data: Record<string, unknown>): void {
+  const assistants = data.assistants;
+  if (!Array.isArray(assistants)) return;
+  for (const assistant of assistants) {
+    if (assistant && typeof assistant === "object") {
+      const entry = assistant as Record<string, unknown>;
+      for (const field of SENSITIVE_KEYS) {
+        delete entry[field];
+      }
+      const resources = entry.resources;
+      if (resources && typeof resources === "object") {
+        for (const field of SENSITIVE_KEYS) {
+          delete (resources as Record<string, unknown>)[field];
+        }
+      }
+    }
+  }
+}
+
+function isLoopbackHostname(hostname: string): boolean {
+  const normalized = hostname.toLowerCase();
+  return (
+    normalized === "localhost" ||
+    normalized === "[::1]" ||
+    normalized === "::1" ||
+    normalized === "0:0:0:0:0:0:0:1" ||
+    /^127(?:\.\d{1,3}){3}$/.test(normalized)
+  );
+}
+
+export function headerHostIsLoopback(hostHeader: string | undefined): boolean {
+  if (!hostHeader) return false;
+  try {
+    return isLoopbackHostname(new URL(`http://${hostHeader}`).hostname);
+  } catch {
+    return false;
+  }
+}
+
+export function originIsAllowed(originHeader: string | undefined): boolean {
+  if (!originHeader) return true;
+  try {
+    const origin = new URL(originHeader);
+    return (
+      (origin.protocol === "http:" || origin.protocol === "https:") &&
+      isLoopbackHostname(origin.hostname)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Require browser-controlled proof that a request came from the loopback HTTP
+ * origin named by its Host header. Conflicting Origin or Fetch Metadata values
+ * are rejected even when the other signal is valid.
+ */
+export function hasSameOriginCredentialProof(
+  hostHeader: string | undefined,
+  originHeader: string | undefined,
+  secFetchSiteHeader: string | undefined,
+): boolean {
+  if (!hostHeader || !headerHostIsLoopback(hostHeader)) {
+    return false;
+  }
+
+  let hasMatchingOrigin = false;
+  if (originHeader) {
+    try {
+      hasMatchingOrigin =
+        new URL(originHeader).origin === new URL(`http://${hostHeader}`).origin;
+    } catch {
+      return false;
+    }
+    if (!hasMatchingOrigin) {
+      return false;
+    }
+  }
+
+  if (secFetchSiteHeader && secFetchSiteHeader !== "same-origin") {
+    return false;
+  }
+
+  return hasMatchingOrigin || secFetchSiteHeader === "same-origin";
+}
+
+export function isLoopbackAddr(addr: string): boolean {
+  const v4Mapped = addr.match(/^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/i);
+  const normalized = v4Mapped ? v4Mapped[1]! : addr;
+  if (normalized.includes(".")) {
+    return normalized.startsWith("127.");
+  }
+  return normalized === "::1";
+}
+
+let _resolvedCliPath: string | undefined;
+
+/**
+ * Resolve the CLI entry point.
+ *
+ * 1. Source tree — `<baseDir>/cli/src/index.ts` (dev mode in monorepo).
+ * 2. Installed package — `require.resolve("@mycadet/cli/package.json")`.
+ */
+function resolveCliPath(baseDir: string, importMetaUrl?: string): string {
+  if (_resolvedCliPath) return _resolvedCliPath;
+
+  const sourceTreePath = path.join(baseDir, "cli", "src", "index.ts");
+  if (fs.existsSync(sourceTreePath)) {
+    _resolvedCliPath = sourceTreePath;
+    return _resolvedCliPath;
+  }
+
+  const _require = createRequire(importMetaUrl ?? `file://${baseDir}/`);
+  try {
+    const pkgPath = _require.resolve(`${CLI_PACKAGE_NAME}/package.json`);
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as {
+      bin?: Record<string, string>;
+    };
+    const binEntry = pkg.bin?.["cadet"];
+    if (binEntry) {
+      const entryPoint = path.resolve(path.dirname(pkgPath), binEntry);
+      if (fs.existsSync(entryPoint)) {
+        _resolvedCliPath = entryPoint;
+        return _resolvedCliPath;
+      }
+    }
+  } catch {
+    // Not found in node_modules
+  }
+
+  throw new Error(
+    `Cadet CLI not found. Looked for source tree at ${sourceTreePath} and npm package ${CLI_PACKAGE_NAME}.`,
+  );
+}
+
+/**
+ * Build the CLI invocation used by the dev hosts (CLI client server and the
+ * web dev-server middleware), which run the CLI from source via Bun:
+ * `bun run <cli-entry> <subcommand> …`.
+ */
+export function resolveDevCliInvocation(
+  baseDir: string,
+  importMetaUrl?: string,
+): CliInvocation {
+  return {
+    command: "bun",
+    baseArgs: ["run", resolveCliPath(baseDir, importMetaUrl)],
+  };
+}

package/node_modules/@mycadet/local-mode/src/wake.ts

@@ -0,0 +1,89 @@
+import { spawn } from "node:child_process";
+
+import type { CliInvocation } from "./util";
+
+// `wake` cold-starts a stopped assistant, so it can legitimately run far
+// longer than a teardown like `retire`: the CLI waits up to 60s for the daemon
+// to answer (plus another 60s if it falls back to a source daemon) and up to
+// 30s for the gateway. The wrapper timeout is a safety net for a truly hung
+// process, so it must sit above those documented readiness windows — otherwise
+// a slow-but-succeeding wake gets killed and misreported as a timeout.
+const WAKE_TIMEOUT_MS = 180_000;
+
+export type WakeResult =
+  | { ok: true }
+  | { ok: false; status: number; error: string };
+
+export interface WakeOptions {
+  /** Pass --repair-guardian to re-provision a missing/expired guardian token. Revokes the assistant's other device-bound tokens, so callers must gate this behind explicit user confirmation. */
+  repairGuardian?: boolean;
+}
+
+/**
+ * Start (or restart) a local assistant's daemon and gateway via the CLI's
+ * `wake`, which also re-seeds the guardian token from a sibling environment.
+ *
+ * This is the non-destructive repair primitive: it revives a stopped or
+ * mis-seeded local assistant in place without touching its data or identity,
+ * the same way the native client re-pairs on a failed connection. Mirrors
+ * {@link runRetire}'s never-reject contract so each host wires transport once
+ * and surfaces a structured failure rather than a thrown error.
+ */
+export function runWake(
+  invocation: CliInvocation,
+  assistantId: string,
+  options?: WakeOptions,
+): Promise<WakeResult> {
+  return new Promise((resolve) => {
+    const child = spawn(
+      invocation.command,
+      [
+        ...invocation.baseArgs,
+        "wake",
+        assistantId,
+        ...(options?.repairGuardian ? ["--repair-guardian"] : []),
+      ],
+      { stdio: ["ignore", "pipe", "pipe"], windowsHide: true },
+    );
+
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+
+    const finish = (result: WakeResult) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timeout);
+      resolve(result);
+    };
+
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish({
+        ok: false,
+        status: 500,
+        error: `Wake timed out after ${WAKE_TIMEOUT_MS / 1000} seconds`,
+      });
+    }, WAKE_TIMEOUT_MS);
+
+    child.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        finish({ ok: true });
+      } else {
+        finish({ ok: false, status: 500, error: stderr || stdout });
+      }
+    });
+
+    child.on("error", (err) => {
+      finish({ ok: false, status: 500, error: `Failed to spawn CLI: ${err.message}` });
+    });
+  });
+}