@cordfuse/crosstalk 7.0.0-alpha.9 → 7.0.0-beta.1

package/commands/server.js

@@ -0,0 +1,153 @@
+// crosstalk server — native engine lifecycle (v8-native).
+//
+// Replaces the v7 docker lifecycle (up/down/restart/pull/logs). The
+// engine runs as a detached host process; state lives under
+// `<base>/<name>/crosstalk-state/` (pid + log files).
+//
+// Subverbs:
+//   crosstalk server start    [--containername N]
+//   crosstalk server stop     [--containername N]
+//   crosstalk server restart  [--containername N]
+//   crosstalk server status   [--containername N] [--probe]
+//   crosstalk server logs     [--containername N] [-f|--follow]
+//
+// All honor CROSSTALK_USER_MODE=1 (boolean opt-in). Default is system
+// mode (paths under /var/lib/crosstalk/, runs as `crosstalk` service
+// user under the systemd unit shipped in deploy/crosstalk@.service).
+// CROSSTALK_USER_MODE=1 switches to user mode (paths under
+// ~/.local/share/crosstalk/ on Linux) — intended for solo dev or
+// operators who don't want a system service.
+
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { has } from '../lib/argv.js';
+import {
+  requireInitialized, storageMode,
+  DEFAULT_CONTAINER_NAME,
+} from '../lib/resolve.js';
+import { startEngine, stopEngine, engineStatus } from '../lib/nativeServer.js';
+
+/**
+ * In system mode the engine is supposed to run as the `crosstalk`
+ * service user under systemd, not as the operator who invoked the CLI.
+ * Spawning a detached child from the operator's shell would be the
+ * wrong lifecycle. Redirect to systemctl instead — clear hint + exit 2.
+ */
+function redirectToSystemctl(verb, name) {
+  const unit = `crosstalk@${name}`;
+  process.stderr.write(
+    `crosstalk server ${verb}: system mode is the default — the engine\n` +
+    `runs as the 'crosstalk' service user under systemd, not as a child\n` +
+    `of this CLI.\n\n` +
+    `  Use: sudo systemctl ${verb} ${unit}\n\n` +
+    `Or opt into user mode (spawn as yourself, no systemd):\n` +
+    `  CROSSTALK_USER_MODE=1 crosstalk server ${verb}${name === DEFAULT_CONTAINER_NAME ? '' : ' --containername ' + name}\n`,
+  );
+  return 2;
+}
+
+function nameSuffix(name) {
+  return name === DEFAULT_CONTAINER_NAME ? '' : ` --containername ${name}`;
+}
+
+function usage(exit = 0) {
+  const w = exit === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage: crosstalk server <subverb> [--containername <name>]
+
+Subverbs:
+  start                start the engine as a detached host process
+  stop                 SIGTERM the running engine; SIGKILL after 5s grace
+  restart              stop + start
+  status [--probe]     report pid + uptime; --probe also pings /healthz
+  logs [-f|--follow]   tail crosstalk-state/crosstalk.log
+
+Storage mode defaults to 'system'; set CROSSTALK_USER_MODE=1 for user mode.
+`);
+  process.exit(exit);
+}
+
+async function cmdStart(argv) {
+  const { name } = requireInitialized(argv);
+  if (storageMode() === 'system') return redirectToSystemctl('start', name);
+  const r = startEngine(name);
+  if (!r.ok) {
+    process.stderr.write(`crosstalk server start: ${r.error}\n`);
+    return 1;
+  }
+  process.stdout.write(
+    `'${name}' started (pid ${r.pid}, api 127.0.0.1:${r.port}).\n` +
+    `  logs: crosstalk server logs${nameSuffix(name)} -f\n`,
+  );
+  return 0;
+}
+
+function cmdStop(argv) {
+  const { name } = requireInitialized(argv);
+  if (storageMode() === 'system') return redirectToSystemctl('stop', name);
+  const r = stopEngine(name);
+  if (!r.wasRunning) {
+    process.stdout.write(`'${name}' was not running.\n`);
+    return 0;
+  }
+  if (r.killed) {
+    process.stdout.write(`'${name}' did not shut down within 5s — SIGKILL'd (pid ${r.pid}).\n`);
+  } else {
+    process.stdout.write(`'${name}' stopped (pid ${r.pid}).\n`);
+  }
+  return 0;
+}
+
+async function cmdRestart(argv) {
+  const { name } = requireInitialized(argv);
+  if (storageMode() === 'system') return redirectToSystemctl('restart', name);
+  cmdStop(argv);
+  return cmdStart(argv);
+}
+
+async function cmdStatus(argv) {
+  const { name } = requireInitialized(argv);
+  const probe = has(argv, '--probe');
+  const s = await engineStatus(name, { probeApi: probe });
+  if (!s.running) {
+    process.stdout.write(`'${name}' is not running.\n  Start it: crosstalk server start${nameSuffix(name)}\n`);
+    return 0;
+  }
+  const lines = [
+    `'${name}' is running.`,
+    `  pid    : ${s.pid}`,
+    `  api    : http://127.0.0.1:${s.port}`,
+  ];
+  if (s.uptimeSeconds !== undefined) lines.push(`  uptime : ${s.uptimeSeconds}s`);
+  if (probe) lines.push(`  /healthz : ${s.apiReachable ? 'ok' : 'unreachable'}`);
+  process.stdout.write(lines.join('\n') + '\n');
+  return 0;
+}
+
+function cmdLogs(argv) {
+  const { paths } = requireInitialized(argv);
+  if (!existsSync(paths.logFile)) {
+    process.stdout.write(`No log file yet at ${paths.logFile}.\n  (engine may not have been started)\n`);
+    return 0;
+  }
+  const follow = has(argv, '-f') || has(argv, '--follow');
+  const args = follow ? ['-n', '200', '-f', paths.logFile] : ['-n', '200', paths.logFile];
+  const r = spawn('tail', args, { stdio: 'inherit' });
+  return new Promise((resolve) => r.on('exit', (code) => resolve(code ?? 0)));
+}
+
+export async function run(argv) {
+  if (argv.length === 0 || has(argv, '-h') || has(argv, '--help')) usage(0);
+  const sub = argv[0];
+  const rest = argv.slice(1);
+  switch (sub) {
+    case 'start':   return cmdStart(rest);
+    case 'stop':    return cmdStop(rest);
+    case 'restart': return cmdRestart(rest);
+    case 'status':  return cmdStatus(rest);
+    case 'logs':    return cmdLogs(rest);
+    default:
+      process.stderr.write(`crosstalk server: unknown subverb '${sub}'\n\n`);
+      usage(1);
+  }
+}

package/commands/settings.js

@@ -0,0 +1,49 @@
+// crosstalk settings <show> — current engine settings snapshot.
+
+import { apiFor } from '../lib/api-client.js';
+import { reportAndExit } from '../lib/errors.js';
+import { has } from '../lib/argv.js';
+
+function usage(exit = 0) {
+  const w = exit === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage:
+  crosstalk settings show [--json]
+  crosstalk settings --help
+`,
+  );
+  process.exit(exit);
+}
+
+export async function run(argv) {
+  if (has(argv, '--help') || has(argv, '-h')) usage(0);
+  const sub = argv[0];
+  if (!sub) usage(1);
+  if (sub !== 'show') {
+    process.stderr.write(`crosstalk settings: unknown subcommand '${sub}'.\n`);
+    usage(1);
+  }
+
+  const api = apiFor(argv);
+  let r;
+  try {
+    r = await api.get('/api/settings');
+  } catch (err) {
+    reportAndExit(err, 'crosstalk settings show');
+  }
+
+  if (has(argv, '--json')) {
+    process.stdout.write(JSON.stringify(r, null, 2) + '\n');
+    return 0;
+  }
+
+  process.stdout.write(
+    `alias:         ${r.alias}\n` +
+    `version:       ${r.version}\n` +
+    `transportRoot: ${r.transportRoot}\n` +
+    `apiPort:       ${r.apiPort}\n` +
+    `claimedModels: ${(r.claimedModels || []).join(', ') || '(none)'}\n` +
+    (r.pollSeconds != null ? `pollSeconds:   ${r.pollSeconds}\n` : ''),
+  );
+  return 0;
+}

package/commands/status.js

@@ -1,4 +1,4 @@
-// crosstalk status — mirror of crosstalkd status output, fetched via API.
+// crosstalk status — transport-level snapshot from the engine, fetched via API.
 //
 // alpha.6: also prints the host path of the transport git repo as an
 // escape hatch for operators who want to poke around with raw git.
@@ -25,22 +25,46 @@ export async function run(argv) {
   process.stdout.write('\n');
 
   process.stdout.write(`Claimed models: ${s.claimed_models.length}\n`);
-  if (s.claimed_models.length === 0) {
-    let installed = null;
-    try {
-      const r = await api.get('/agents/installed');
-      installed = r.installed;
-    } catch { /* ignore — fall back to generic message */ }
-    if (installed && installed.length > 0) {
-      const verb = installed.length === 1 ? 'references it' : 'references them';
+  for (const m of s.claimed_models) process.stdout.write(`  - ${m}\n`);
+
+  // N1 (alpha.11): surface the install/claim diagnostic regardless of
+  // claimed_models count. Alpha.10 only rendered when claimed was zero,
+  // which missed the common mixed-state case — operator already had one
+  // agent running and installed a second one that's referenced in yaml
+  // but not yet claimed. Now the hint fires whenever there's a gap
+  // between installed CLIs and claimed CLIs.
+  let installed = null;
+  let yamlReferenced = null;
+  let claimedClis = null;
+  try {
+    const r = await api.get('/agents/installed');
+    installed = r.installed;
+    yamlReferenced = r.yaml_referenced;
+    claimedClis = r.claimed;
+  } catch { /* ignore — best-effort diagnostic */ }
+  if (installed) {
+    const claimedSet = new Set(claimedClis ?? []);
+    const referencedSet = new Set(yamlReferenced ?? []);
+    const installedReferencedUnclaimed = installed.filter(
+      (b) => referencedSet.has(b) && !claimedSet.has(b),
+    );
+    const installedNotReferenced = installed.filter((b) => !referencedSet.has(b));
+    if (installedReferencedUnclaimed.length > 0) {
+      const verb = installedReferencedUnclaimed.length === 1 ? 'is' : 'are';
       process.stdout.write(
-        `  (${installed.join(', ')} installed in the container but no data/crosstalk.yaml entry ${verb} — add one to claim)\n`,
+        `  (${installedReferencedUnclaimed.join(', ')} ${verb} installed and referenced in data/crosstalk.yaml ` +
+        `but not yet claimed — run 'crosstalk restart' to refresh the dispatcher's claim list)\n`,
       );
-    } else {
+    }
+    if (installedNotReferenced.length > 0) {
+      const verb = installedNotReferenced.length === 1 ? 'references it' : 'references them';
+      process.stdout.write(
+        `  (${installedNotReferenced.join(', ')} installed in the container but no data/crosstalk.yaml entry ${verb} — add one to claim)\n`,
+      );
+    }
+    if (s.claimed_models.length === 0 && installed.length === 0) {
       process.stdout.write('  (no model CLIs found inside the container — install one via `crosstalk chat --shell` and add an entry to data/crosstalk.yaml)\n');
     }
-  } else {
-    for (const m of s.claimed_models) process.stdout.write(`  - ${m}\n`);
   }
   process.stdout.write('\n');
 

package/commands/token.js

@@ -0,0 +1,136 @@
+// crosstalk token <list|create|revoke|rename> — manage bearer tokens.
+//
+// All endpoints scoped to the currently-authenticated user (the engine
+// enforces ownership; you cannot rename or revoke another user's
+// tokens via the CLI). Admin-only operations on other users' tokens
+// remain web-UI only.
+
+import { apiFor } from '../lib/api-client.js';
+import { positionals, has, flag } from '../lib/argv.js';
+import { reportAndExit } from '../lib/errors.js';
+
+function usage(exit = 0) {
+  const w = exit === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage:
+  crosstalk token list                              # list your tokens
+  crosstalk token create <name>                     # create a new token (prints secret once)
+  crosstalk token revoke <tokenId>                  # revoke a token by id
+  crosstalk token rename <tokenId> --name <label>   # rename a token's label
+  crosstalk token --help
+`,
+  );
+  process.exit(exit);
+}
+
+function fmtRel(iso) {
+  if (!iso) return '—';
+  const ms = Date.now() - new Date(iso).getTime();
+  if (Number.isNaN(ms)) return iso;
+  if (ms < 0) return 'in the future';
+  if (ms < 5_000) return 'just now';
+  if (ms < 60_000) return `${Math.floor(ms / 1000)}s ago`;
+  if (ms < 3_600_000) return `${Math.floor(ms / 60_000)}m ago`;
+  if (ms < 86_400_000) return `${Math.floor(ms / 3_600_000)}h ago`;
+  return `${Math.floor(ms / 86_400_000)}d ago`;
+}
+
+export async function run(argv) {
+  if (has(argv, '--help') || has(argv, '-h')) usage(0);
+  const pos = positionals(argv, ['--name', '--profile']);
+  const sub = pos[0];
+  if (!sub) usage(1);
+
+  const api = apiFor(argv);
+
+  if (sub === 'list') {
+    let r;
+    try {
+      r = await api.get('/api/tokens');
+    } catch (err) {
+      reportAndExit(err, 'crosstalk token list');
+    }
+    const tokens = r.tokens ?? [];
+    if (tokens.length === 0) {
+      process.stdout.write('(no tokens)\n');
+      return 0;
+    }
+    for (const t of tokens) {
+      const created = fmtRel(t.createdAt);
+      const used = t.lastUsedAt ? `last ${fmtRel(t.lastUsedAt)}` : 'never used';
+      const expires = t.expiresAt ? ` exp:${t.expiresAt}` : '';
+      process.stdout.write(`${t.tokenId}  ${(t.name || '').padEnd(24)}  created ${created}  ${used}${expires}\n`);
+    }
+    return 0;
+  }
+
+  if (sub === 'create') {
+    const name = pos[1];
+    if (!name) {
+      process.stderr.write('crosstalk token create: <name> required.\n');
+      return 1;
+    }
+    let r;
+    try {
+      r = await api.post('/api/tokens', { name });
+    } catch (err) {
+      reportAndExit(err, 'crosstalk token create');
+    }
+    if (!r || typeof r.plaintextSecret !== 'string') {
+      process.stderr.write('crosstalk token create: malformed response from engine.\n');
+      return 1;
+    }
+    process.stdout.write(
+      `tokenId: ${r.tokenId}\n` +
+      `secret:  ${r.plaintextSecret}\n` +
+      `\n` +
+      `Copy the secret now — it won't be shown again. To use it from\n` +
+      `another machine: send 'Authorization: Bearer <secret>' on each request.\n`,
+    );
+    return 0;
+  }
+
+  if (sub === 'revoke') {
+    const tokenId = pos[1];
+    if (!tokenId) {
+      process.stderr.write('crosstalk token revoke: <tokenId> required. Run `crosstalk token list` to see ids.\n');
+      return 1;
+    }
+    try {
+      await api.delete(`/api/tokens/${encodeURIComponent(tokenId)}`);
+    } catch (err) {
+      reportAndExit(err, 'crosstalk token revoke');
+    }
+    process.stdout.write(`revoked ${tokenId}\n`);
+    return 0;
+  }
+
+  if (sub === 'rename') {
+    const tokenId = pos[1];
+    if (!tokenId) {
+      process.stderr.write('crosstalk token rename: <tokenId> required. Run `crosstalk token list` to see ids.\n');
+      return 1;
+    }
+    const newName = flag(argv, '--name');
+    if (!newName) {
+      process.stderr.write('crosstalk token rename: --name <label> required.\n');
+      return 1;
+    }
+    let r;
+    try {
+      r = await api.patch(`/api/tokens/${encodeURIComponent(tokenId)}`, { name: newName });
+    } catch (err) {
+      reportAndExit(err, 'crosstalk token rename');
+    }
+    const updated = r && r.token;
+    if (updated) {
+      process.stdout.write(`renamed ${tokenId} → ${updated.name}\n`);
+    } else {
+      process.stdout.write(`renamed ${tokenId}\n`);
+    }
+    return 0;
+  }
+
+  process.stderr.write(`crosstalk token: unknown subcommand '${sub}'.\n`);
+  usage(1);
+}

package/commands/transport.js

@@ -0,0 +1,270 @@
+// crosstalk transport <init|rm> — scaffold or tear down a transport.
+//
+//   init [--containername <name>] [--remote <url>]
+//        Idempotent — re-running fills in missing markers without
+//        disturbing existing state. Engine scaffold runs via
+//        `crosstalk daemon init <path>` (the internal subcommand).
+//
+//   rm   [--containername <name>] [--force]
+//        Stops the engine (best-effort) then deletes <base>/<name>/.
+//        Confirmation prompt by default; --force to skip.
+//
+// Replaces v7's bare `crosstalk init` + `crosstalk rm` (both removed).
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'fs';
+import { spawnSync } from 'child_process';
+import { createInterface } from 'readline';
+import { join } from 'path';
+import { has, flag } from '../lib/argv.js';
+import {
+  parseContainerName,
+  storagePaths,
+  isInitialized,
+  pickFreePort,
+  DEFAULT_CONTAINER_NAME,
+} from '../lib/resolve.js';
+import { stopEngine, resolveSelfBin } from '../lib/nativeServer.js';
+
+function usage(exit = 0) {
+  const w = exit === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage:
+  crosstalk transport init [--containername <name>] [--remote <url>]
+  crosstalk transport rm   [--containername <name>] [--force]
+  crosstalk transport --help
+
+init  — scaffold a new transport (or repair an incomplete one).
+rm    — stop the engine and delete the entire <base>/<name>/ tree.
+
+Options:
+  --containername <name>   Transport name (default: 'crosstalk'). Must be
+                           lowercase alphanumeric + ._- (no leading . or -).
+  -c <name>                Shorthand for --containername.
+  --remote <url>           (init only) set git upstream. Errors if a
+                           different remote is already set.
+  --force, -f              (rm only) skip the confirmation prompt.
+
+Default is system mode (/var/lib/crosstalk/, runs as the 'crosstalk'
+service user via the bundled systemd unit). CROSSTALK_USER_MODE=1
+switches to user mode (paths under the operator's home).
+`,
+  );
+  process.exit(exit);
+}
+
+export async function run(argv) {
+  if (has(argv, '--help') || has(argv, '-h')) usage(0);
+  const sub = argv[0];
+  if (!sub) usage(1);
+  const rest = argv.slice(1);
+
+  if (sub === 'init') return await runInit(rest);
+  if (sub === 'rm')   return await runRm(rest);
+
+  process.stderr.write(`crosstalk transport: unknown subcommand '${sub}'.\n`);
+  usage(1);
+}
+
+async function runInit(argv) {
+  let name;
+  try {
+    name = parseContainerName(argv);
+  } catch (err) {
+    process.stderr.write(`crosstalk transport init: ${err.message}\n`);
+    return 1;
+  }
+
+  const remote = flag(argv, '--remote');
+  const paths = storagePaths(name);
+  const report = [];
+
+  // ── Phase 1: Storage layout ────────────────────────────────────────
+  try {
+    mkdirSync(paths.transportDir,   { recursive: true });
+    mkdirSync(paths.crosstalkRoot,  { recursive: true });
+    mkdirSync(paths.crosstalkState, { recursive: true });
+  } catch (err) {
+    process.stderr.write(
+      `crosstalk transport init: failed to create storage at ${paths.storageRoot} — ${err.message}\n`,
+    );
+    if (paths.mode === 'system') {
+      process.stderr.write(
+        `  System-mode storage requires write access to ${paths.base}.\n` +
+        `  Try: sudo mkdir -p ${paths.storageRoot} && sudo chown -R $USER ${paths.storageRoot}\n`,
+      );
+    }
+    return 1;
+  }
+
+  let port;
+  if (existsSync(paths.portFile)) {
+    const v = Number(readFileSync(paths.portFile, 'utf-8').trim());
+    if (Number.isInteger(v) && v > 0 && v < 65536) {
+      port = v;
+      report.push(`  api port:   ${port} (existing)`);
+    }
+  }
+  if (!port) {
+    try {
+      port = pickFreePort(name);
+      writeFileSync(paths.portFile, `${port}\n`);
+      report.push(`  api port:   ${port} (allocated)`);
+    } catch (err) {
+      process.stderr.write(`crosstalk transport init: port allocation failed — ${err.message}\n`);
+      return 1;
+    }
+  }
+
+  // ── Phase 2: Transport scaffold ────────────────────────────────────
+  const crosstalkVersionFile = join(paths.transportDir, 'CROSSTALK-VERSION');
+  if (!existsSync(crosstalkVersionFile)) {
+    // Scaffold via `crosstalk daemon init <path>` — the same self-bin
+    // call pattern startEngine() uses.
+    const selfBin = resolveSelfBin();
+    if (!existsSync(selfBin)) {
+      process.stderr.write(
+        `crosstalk transport init: CLI entry missing at ${selfBin} — package install looks broken.\n`,
+      );
+      return 1;
+    }
+    const initRun = spawnSync(
+      process.execPath,
+      [selfBin, 'daemon', 'init', paths.transportDir],
+      { stdio: 'pipe' },
+    );
+    if (initRun.status !== 0) {
+      const stderr = initRun.stderr?.toString() ?? '';
+      const stdout = initRun.stdout?.toString() ?? '';
+      process.stderr.write(`crosstalk transport init: 'daemon init' exited ${initRun.status}\n`);
+      if (stderr.trim()) process.stderr.write(`  stderr: ${stderr.trim()}\n`);
+      if (stdout.trim()) process.stderr.write(`  stdout: ${stdout.trim()}\n`);
+      return initRun.status ?? 1;
+    }
+    report.push(`  template:   scaffolded`);
+  } else {
+    report.push(`  template:   present (skipped scaffold)`);
+  }
+
+  // ── Phase 3: Git init + initial commit ─────────────────────────────
+  if (!existsSync(crosstalkVersionFile)) {
+    process.stderr.write(
+      `crosstalk transport init: transport template missing at ${paths.transportDir}\n` +
+      `  Engine init didn't write template files. Try 'crosstalk transport rm' then re-init.\n`,
+    );
+    return 1;
+  }
+
+  const gitSteps = [
+    ['init', '--quiet', '--initial-branch=main'],
+    ['add', '-A'],
+    ['commit', '--quiet', '-m', 'initial transport'],
+  ];
+  let gitOk = true;
+  for (const args of gitSteps) {
+    const gr = spawnSync('git', args, { cwd: paths.transportDir, stdio: 'pipe' });
+    if (gr.status !== 0) {
+      gitOk = false;
+      break;
+    }
+  }
+  report.push(gitOk ? `  git:        initialized + committed` : `  git:        already present (skipped)`);
+
+  // ── Phase 4: Remote setup ──────────────────────────────────────────
+  if (remote) {
+    const cur = spawnSync('git', ['remote', 'get-url', 'origin'], {
+      cwd: paths.transportDir,
+      stdio: 'pipe',
+    });
+    const currentUrl = cur.status === 0 ? cur.stdout.toString().trim() : null;
+    if (!currentUrl) {
+      const rr = spawnSync('git', ['remote', 'add', 'origin', remote], {
+        cwd: paths.transportDir,
+        stdio: 'pipe',
+      });
+      if (rr.status !== 0) {
+        process.stderr.write(
+          `crosstalk transport init: 'git remote add origin ${remote}' failed — ${rr.stderr?.toString().trim()}\n`,
+        );
+      } else {
+        report.push(`  remote:     ${remote} (added)`);
+      }
+    } else if (currentUrl === remote) {
+      report.push(`  remote:     ${remote} (already set)`);
+    } else {
+      process.stderr.write(
+        `crosstalk transport init: remote already set to '${currentUrl}'; refusing to overwrite with '${remote}'.\n`,
+      );
+      return 1;
+    }
+  }
+
+  // ── Phase 5: Summary ───────────────────────────────────────────────
+  process.stdout.write(
+    `\nTransport '${name}' ready:\n` +
+    `  storage:    ${paths.storageRoot}\n` +
+    `  transport:  ${paths.transportDir}\n` +
+    report.join('\n') + '\n' +
+    `\nNext: crosstalk server start${name === DEFAULT_CONTAINER_NAME ? '' : ` --containername ${name}`}\n`,
+  );
+  return 0;
+}
+
+function confirm(promptText) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(promptText, (ans) => {
+      rl.close();
+      const yes = /^y(es)?$/i.test(ans.trim());
+      resolve(yes);
+    });
+  });
+}
+
+async function runRm(argv) {
+  let name;
+  try {
+    name = parseContainerName(argv);
+  } catch (err) {
+    process.stderr.write(`crosstalk transport rm: ${err.message}\n`);
+    return 1;
+  }
+
+  const paths = storagePaths(name);
+  const haveStorage = isInitialized(name) || existsSync(paths.storageRoot);
+
+  if (!haveStorage) {
+    process.stderr.write(`crosstalk transport rm: transport '${name}' not found.\n`);
+    return 1;
+  }
+
+  if (!has(argv, '--force') && !has(argv, '-f')) {
+    process.stderr.write(
+      `Remove '${name}'?\n` +
+      `  This deletes:\n` +
+      `    - transport git repo at ${paths.transportDir}\n` +
+      `      (all message history, channels, replies)\n` +
+      `    - installed agent CLIs + auth tokens (claude, codex, ...)\n` +
+      `    - dispatcher state (cursor, heartbeat, errors.log)\n` +
+      `  Cannot undo.\n`,
+    );
+    const ok = await confirm('[y/N]: ');
+    if (!ok) {
+      process.stderr.write('crosstalk transport rm: cancelled.\n');
+      return 1;
+    }
+  }
+
+  stopEngine(name);
+
+  try {
+    rmSync(paths.storageRoot, { recursive: true, force: true });
+  } catch (err) {
+    process.stderr.write(
+      `crosstalk transport rm: failed to remove ${paths.storageRoot} — ${err.message}\n`,
+    );
+    return 1;
+  }
+
+  process.stdout.write(`Removed '${name}'.\n`);
+  return 0;
+}

package/commands/version.js

@@ -20,13 +20,13 @@ export async function run(argv) {
     // Skew detection happens passively in api-client.js via the
     // X-Crosstalk-Engine-Version response header — no duplication here.
     const v = await api.get('/version');
-    process.stdout.write(`crosstalkd engine: ${v.version} (alias: ${v.alias})\n`);
+    process.stdout.write(`crosstalk engine: ${v.version} (alias: ${v.alias})\n`);
   } catch (err) {
     if (err instanceof ConnectError) {
-      process.stdout.write(`crosstalkd engine: (unreachable on 127.0.0.1:${err.port})\n`);
+      process.stdout.write(`crosstalk engine: (unreachable on 127.0.0.1:${err.port})\n`);
       return 0;
     }
-    process.stdout.write(`crosstalkd engine: (error: ${err.message})\n`);
+    process.stdout.write(`crosstalk engine: (error: ${err.message})\n`);
     return 0;
   }
   return 0;