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

package/commands/server.js

@@ -0,0 +1,185 @@
+// 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 { join, resolve } from 'path';
+import { has, flag } from '../lib/argv.js';
+import {
+  requireInitialized, storageMode, parseContainerName,
+  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 [--path <dir>] start the engine; --path runs it on a transport at an
+                       arbitrary directory (e.g. a mounted share), state stays
+                       machine-local (user mode only)
+  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) {
+  // --path <dir>: run the engine on a transport at an arbitrary directory
+  // (e.g. a mounted SMB/NFS share) instead of the managed storage layout.
+  // State (cursor/heartbeat/pid/port) stays machine-local, keyed by name.
+  const transportPath = flag(argv, '--path');
+  if (transportPath) {
+    if (storageMode() === 'system') {
+      process.stderr.write(`crosstalk server start: --path is user-mode only (set CROSSTALK_USER_MODE=1).\n`);
+      return 1;
+    }
+    if (!existsSync(join(transportPath, 'CROSSTALK-VERSION'))) {
+      process.stderr.write(
+        `crosstalk server start: '${transportPath}' is not a crosstalk transport (no CROSSTALK-VERSION).\n` +
+        `  Scaffold it first:  crosstalk daemon init ${transportPath}\n`,
+      );
+      return 1;
+    }
+    const name = parseContainerName(argv);
+    const r = startEngine(name, { transportPath });
+    if (!r.ok) {
+      process.stderr.write(`crosstalk server start: ${r.error}\n`);
+      return 1;
+    }
+    process.stdout.write(
+      `'${name}' started on ${resolve(transportPath)} (pid ${r.pid}, api 127.0.0.1:${r.port}).\n` +
+      `  state stays machine-local; logs: crosstalk server logs${nameSuffix(name)} -f\n`,
+    );
+    return 0;
+  }
+
+  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);
+}