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

package/commands/chat.js

@@ -1,110 +1,147 @@
-// crosstalk chat — interactive entry into the container.
+// crosstalk chat — interactive agent session on the host (v8-native).
 //
-// Modes (alpha.8):
-//   crosstalk chat --agent <name>     # interactive session with an agent CLI
-//   crosstalk chat --shell            # bash escape hatch (debug, install CLIs, run setup commands)
+// Modes:
+//   crosstalk chat <agent> [--cwd <path>]   # interactive session with an agent CLI
+//   crosstalk chat --shell                  # bash escape hatch
 //
-// --agent is required for non-shell mode. There's no implicit default;
-// containers may have multiple agent CLIs installed, the operator
-// picks one explicitly.
+// alpha.18: positional `<agent>` replaces the v7 `--agent <name>` flag
+// form. No backwards-compat alias.
 //
-// `--login` was removed in alpha.8. Per-agent auth is now handled via
-// `data/crosstalk.yaml`'s per-provider `env_file:` (env-injected at
-// agent spawn time inside the engine) plus operator-run setup commands
-// for agents whose auth is a stateful CLI act (e.g. codex). Recipes are
-// documented in transport/auth/README.md.
+// v8-native has no container — the agent CLIs are installed in the
+// operator's own $HOME (user mode) or the `crosstalk` service user's
+// home (system mode). We just spawn the agent process directly with
+// stdio inherited.
+//
+// Lifecycle: agent runs as a foreground child of `crosstalk chat`. When
+// the operator exits the agent (Ctrl-D / quit / agent finishes), the
+// child exits and we exit with the same status code. SIGINT/SIGTERM
+// received by the parent are forwarded so the agent gets a chance to
+// shut down cleanly before we exit. There's no "session persists after
+// detach" — crosstalk is async-by-design, no live attach model.
+//
+// `<agent>` is required for non-shell mode. The host may have multiple
+// agent CLIs installed; the operator picks one explicitly.
 
-import { spawnSync } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
 import { requireInitialized } from '../lib/resolve.js';
-import { apiFor, ConnectError } from '../lib/api-client.js';
-import { flag, has } from '../lib/argv.js';
+import { flag, has, positionals } from '../lib/argv.js';
 
 const KNOWN_AGENTS = ['claude', 'codex', 'gemini', 'qwen', 'opencode', 'agy'];
 
 function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;
   w.write(
-`Usage: crosstalk chat --agent <name>
+`Usage: crosstalk chat <agent> [--cwd <path>]
        crosstalk chat --shell
 
-Opens an interactive session inside the engine container.
+Opens an interactive session with an agent CLI on the host. The agent
+process is a foreground child of this command — when you exit the
+agent, the process is reaped and 'crosstalk chat' returns.
 
---agent is REQUIRED for any chat mode. Containers can have multiple
-agent CLIs installed; the operator must say which one to invoke.
+The agent name is REQUIRED for any chat mode (except --shell). The host
+may have multiple agent CLIs installed; the operator must say which one
+to invoke.
 
 Supported agents: ${KNOWN_AGENTS.join(', ')}.
 
 Modes:
-  --agent <name>   Interactive with the named agent CLI. Use the
-                   agent's own keys/commands for first-time setup
-                   (see transport/auth/README.md for recipes).
-  --shell          Drop into bash (install agent CLIs, debug, run
-                   one-time auth setup commands like
-                   \`codex login --with-api-key\`).
+  <agent>          Interactive with the named agent CLI. First-run OAuth
+                   happens through the agent's own flow.
+  --cwd <path>     Change directory before spawning the agent (handy for
+                   pinning the session to a specific project root).
+  --shell          Drop into bash. Useful for installing agent CLIs
+                   (\`npm i -g @anthropic-ai/claude-code\`) or running
+                   one-time setup commands.
 
 Examples:
-  crosstalk chat --agent claude               # interactive claude
-  crosstalk chat --agent gemini               # interactive gemini
-  crosstalk chat --shell                      # bash
+  crosstalk chat claude
+  crosstalk chat codex --cwd ~/Repos/myproject
+  crosstalk chat --shell
 `,
   );
   process.exit(exit);
 }
 
-function runInteractive(container, command, env = {}) {
-  // Full TTY passthrough — docker exec -it gives the container a real
-  // PTY, and stdio: 'inherit' forwards stdin/stdout/stderr from the
-  // operator's terminal. Agent CLIs render their rich TUI normally and
-  // SIGWINCH propagates from the host's tty to the container's PTY.
-  const envFlags = [];
-  for (const [k, v] of Object.entries(env)) {
-    envFlags.push('--env', `${k}=${v}`);
+/**
+ * Spawn an interactive process attached to the operator's TTY. The
+ * child OWNS stdin/stdout/stderr for the duration; when it exits, we
+ * exit with the same code. SIGINT/SIGTERM forwarded for clean shutdown.
+ */
+function runInteractive(command, args = [], opts = {}) {
+  // Pre-flight: is the binary actually present on PATH? Catching this
+  // here gives a clearer error than the child's "command not found"
+  // hitting the operator's TTY.
+  const which = spawnSync('which', [command], { encoding: 'utf-8' });
+  if (which.status !== 0) {
+    process.stderr.write(
+      `crosstalk chat: '${command}' not found on PATH.\n` +
+      `  Install it first (e.g., npm install -g @anthropic-ai/claude-code for claude).\n`,
+    );
+    return 127;
   }
-  const r = spawnSync('docker', ['exec', '-it', ...envFlags, container, command], {
-    stdio: 'inherit',
+
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      stdio: 'inherit',
+      ...(opts.cwd ? { cwd: opts.cwd } : {}),
+    });
+
+    const forward = (sig) => {
+      try { child.kill(sig); } catch { /* already gone */ }
+    };
+    process.on('SIGINT', () => forward('SIGINT'));
+    process.on('SIGTERM', () => forward('SIGTERM'));
+
+    child.on('exit', (code, signal) => {
+      // Belt-and-suspenders: if the child reported clean exit but is
+      // somehow still alive (rare; some agent CLIs fork sub-processes
+      // that hold the PID), SIGKILL to be sure. The async-by-design
+      // contract says no live agent persists past chat exit.
+      if (child.pid) {
+        try { process.kill(child.pid, 0); process.kill(child.pid, 'SIGKILL'); }
+        catch { /* expected: process is gone */ }
+      }
+      if (signal) {
+        // Re-raise the signal so the operator's shell sees the same exit semantics.
+        process.exit(128 + (signalToNumber(signal) ?? 1));
+      }
+      resolve(code ?? 0);
+    });
+    child.on('error', (err) => {
+      process.stderr.write(`crosstalk chat: spawn failed: ${err.message}\n`);
+      resolve(1);
+    });
   });
-  return r.status ?? 1;
+}
+
+function signalToNumber(sig) {
+  // Minimal map — we only forward INT/TERM, so only those need to round-trip.
+  return { SIGINT: 2, SIGTERM: 15, SIGHUP: 1, SIGKILL: 9 }[sig];
 }
 
 export async function run(argv) {
   if (has(argv, '--help') || has(argv, '-h')) usage(0);
 
-  const { name } = requireInitialized(argv);
-  const api = apiFor(argv);
+  // requireInitialized ensures we're being run against a known transport;
+  // its return value isn't used here (chat doesn't address the engine API)
+  // but the existence check fails fast with a clear error if the operator
+  // hasn't run `crosstalk transport init` for this --containername yet.
+  requireInitialized(argv);
+
+  const cwdFlag = flag(argv, '--cwd');
 
   if (has(argv, '--shell')) {
-    return runInteractive(name, 'bash');
+    const shell = process.env.SHELL ?? 'bash';
+    return runInteractive(shell, [], { cwd: cwdFlag });
   }
 
-  const agent = flag(argv, '--agent');
+  const pos = positionals(argv, [
+    '--cwd', '--containername', '-c', '--profile', '--server',
+  ]);
+  const agent = pos[0];
   if (!agent) {
-    // Query the engine for what's actually installed (vs the theoretical
-    // supported set). Gives a smarter error than "supported: claude,
-    // codex, gemini, qwen, opencode, agy" when only 1-2 are actually
-    // present in the container.
-    let installed = null;
-    try {
-      const r = await api.get('/agents/installed');
-      installed = r.installed;
-    } catch (err) {
-      if (!(err instanceof ConnectError)) {
-        // engine unreachable — fall through with no introspection
-      }
-    }
-    if (installed && installed.length === 0) {
-      process.stderr.write(
-        `crosstalk chat: no agent CLIs installed in this container.\n` +
-        `  Install one first:\n` +
-        `    crosstalk chat --shell\n` +
-        `    npm install -g @anthropic-ai/claude-code   # or your agent's installer\n`,
-      );
-      return 1;
-    }
-    const list = installed && installed.length > 0
-      ? `Installed in this container: ${installed.join(', ')}.`
-      : `Supported agents: ${KNOWN_AGENTS.join(', ')}.`;
     process.stderr.write(
-      `crosstalk chat: --agent <name> is required.\n  ${list}\n`,
+      `crosstalk chat: <agent> required.\n  Supported: ${KNOWN_AGENTS.join(', ')}\n`,
     );
     return 1;
   }
@@ -114,6 +151,5 @@ export async function run(argv) {
     );
     return 1;
   }
-
-  return runInteractive(name, agent);
+  return runInteractive(agent, [], { cwd: cwdFlag });
 }

package/commands/daemon.js

@@ -0,0 +1,120 @@
+// crosstalk daemon <verb> — internal: runs the engine subprocess.
+//
+// This is what `crosstalk server start` spawns under the hood, and
+// what the systemd unit's ExecStart points at. Operators don't normally
+// type `crosstalk daemon` directly; `server start/stop/restart`
+// + `transport init` are the user-facing wrappers.
+//
+// The engine TypeScript source lives at ./src/*.ts and is executed via tsx.
+
+import { spawn, spawnSync } from 'child_process';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync, statSync } from 'fs';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+const SUBCOMMANDS = ['dispatch', 'init', 'stop'];
+const STANDALONE_SUBCOMMANDS = new Set(['init']);
+
+const thisDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(thisDir, '..');
+
+function findTransportRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(dir, 'CROSSTALK-VERSION')) && statSync(join(dir, 'CROSSTALK-VERSION')).isFile()) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function usage(exitCode = 0) {
+  const w = exitCode === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage: crosstalk daemon <subcommand> [args...]
+
+Subcommands (operator normally doesn't invoke these directly):
+${SUBCOMMANDS.map((s) => `  ${s}`).join('\n')}
+
+  dispatch  Run the engine main loop (HTTP API + dispatch tick).
+            This is what 'crosstalk server start' spawns.
+  init      Scaffold a new transport (called by 'crosstalk transport init').
+  stop      Signal SIGTERM to the running engine via pidfile.
+
+Most subcommands require you to be inside a Crosstalk transport (a
+directory containing CROSSTALK-VERSION). 'init' can run from anywhere
+to scaffold a new transport.
+`,
+  );
+  process.exit(exitCode);
+}
+
+export async function run(argv) {
+  if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') usage(argv.length === 0 ? 1 : 0);
+
+  const sub = argv[0];
+  if (!SUBCOMMANDS.includes(sub)) {
+    process.stderr.write(`crosstalk daemon: unknown subcommand '${sub}'\n\n`);
+    usage(1);
+  }
+
+  // 'init' is allowed to run outside a transport (it scaffolds one).
+  // Every other subcommand walks up from cwd to find a CROSSTALK-VERSION
+  // marker and chdir's into the transport root.
+  if (!STANDALONE_SUBCOMMANDS.has(sub)) {
+    const transportRoot = findTransportRoot(process.cwd());
+    if (!transportRoot) {
+      process.stderr.write(
+        `crosstalk daemon ${sub}: not inside a Crosstalk transport ` +
+        `(no CROSSTALK-VERSION found from ${process.cwd()} upward).\n`,
+      );
+      process.exit(1);
+    }
+    process.chdir(transportRoot);
+  }
+
+  // Resolve src/<sub>.ts (engine TypeScript). tsx is a runtime dep of
+  // the merged package; resolve its CLI from node_modules.
+  const srcFile = join(repoRoot, 'src', `${sub}.ts`);
+  if (!existsSync(srcFile)) {
+    process.stderr.write(`crosstalk daemon ${sub}: source file missing — ${srcFile}\n`);
+    process.exit(2);
+  }
+
+  const tsxCli = (() => {
+    try { return require.resolve('tsx/cli', { paths: [repoRoot] }); }
+    catch { return join(repoRoot, 'node_modules', 'tsx', 'dist', 'cli.mjs'); }
+  })();
+
+  // For 'dispatch' (long-running engine main loop), spawn as a child
+  // so we can forward signals + exit codes faithfully. For 'init' /
+  // 'stop' (one-shots), spawnSync is fine and faster.
+  const args = [tsxCli, srcFile, ...argv.slice(1)];
+
+  if (sub === 'dispatch') {
+    const child = spawn(process.execPath, args, {
+      stdio: 'inherit',
+      env: process.env,
+    });
+    const forward = (sig) => child.kill(sig);
+    process.on('SIGINT', forward);
+    process.on('SIGTERM', forward);
+    process.on('SIGHUP', forward);
+    return new Promise((res) => {
+      child.on('exit', (code, sig) => {
+        if (sig) process.kill(process.pid, sig);
+        else res(code ?? 0);
+      });
+    });
+  }
+
+  // Stop / init — one-shot, sync.
+  const r = spawnSync(process.execPath, args, { stdio: 'inherit', env: process.env });
+  return r.status ?? 0;
+}
+

package/commands/logs.js

@@ -1,37 +1,126 @@
-// crosstalk logs — tail a transport's engine logs.
+// crosstalk logs <list|tail> — view engine logs.
+//
+//   list [--limit N] [--json]  Snapshot of recent entries.
+//   tail [--since <iso>]        Live SSE stream — Ctrl-C to stop.
+//
+// Mirrors llmux's logs noun.
 
-import { existsSync } from 'fs';
-import { spawnSync } from 'child_process';
-import { has } from '../lib/argv.js';
-import { requireInitialized } from '../lib/resolve.js';
+import { apiFor } from '../lib/api-client.js';
+import { ConnectError } from '../lib/api-client.js';
+import { reportAndExit } from '../lib/errors.js';
+import { flag, has } from '../lib/argv.js';
+import { getActiveProfile } from '../lib/credentials.js';
+import { DEFAULT_API_PORT } from '../lib/api-client.js';
 
 function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;
   w.write(
-`Usage: crosstalk logs [--containername <name>] [-f|--follow] [-n <lines>]
-
-Streams the engine container's stdout/stderr. -f to follow (Ctrl-C to stop).
+`Usage:
+  crosstalk logs list [--limit N] [--json]
+  crosstalk logs tail [--since <iso>]
+  crosstalk logs --help
 `,
   );
   process.exit(exit);
 }
 
+function fmtEntry(e) {
+  const ts = e.ts || e.timestamp || '';
+  const lvl = (e.level || 'info').toUpperCase().padEnd(5);
+  const msg = e.event || e.message || JSON.stringify(e);
+  const fields = e.fields && Object.keys(e.fields).length > 0
+    ? ' ' + Object.entries(e.fields).map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`).join(' ')
+    : '';
+  return `${ts}  ${lvl}  ${msg}${fields}`;
+}
+
 export async function run(argv) {
   if (has(argv, '--help') || has(argv, '-h')) usage(0);
+  const sub = argv[0];
+  if (!sub) usage(1);
 
-  const { name, paths } = requireInitialized(argv);
-  if (!existsSync(paths.composeFile)) {
-    process.stderr.write(`crosstalk logs: '${name}' has no compose file — run 'crosstalk up' first.\n`);
+  if (sub === 'list')  return await runList(argv.slice(1));
+  if (sub === 'tail')  return await runTail(argv.slice(1));
+
+  process.stderr.write(`crosstalk logs: unknown subcommand '${sub}'.\n`);
+  usage(1);
+}
+
+async function runList(argv) {
+  const api = apiFor(argv);
+  let r;
+  try {
+    r = await api.get('/api/logs');
+  } catch (err) {
+    reportAndExit(err, 'crosstalk logs list');
+  }
+  let entries = r.entries || [];
+  const limitStr = flag(argv, '--limit');
+  if (limitStr) {
+    const n = parseInt(limitStr, 10);
+    if (Number.isFinite(n) && n > 0) entries = entries.slice(-n);
+  }
+  if (has(argv, '--json')) {
+    process.stdout.write(JSON.stringify({ entries, currentSeq: r.currentSeq }, null, 2) + '\n');
+    return 0;
+  }
+  if (entries.length === 0) {
+    process.stdout.write('(no log entries)\n');
+    return 0;
+  }
+  for (const e of entries) process.stdout.write(fmtEntry(e) + '\n');
+  return 0;
+}
+
+async function runTail(argv) {
+  // SSE streaming via fetch — manual parse since our api-client wrapper
+  // assumes JSON response bodies. Token + server URL are read from the
+  // active credentials profile, matching the rest of the CLI.
+  const profile = getActiveProfile(argv);
+  const server = (profile && profile.server) || `http://127.0.0.1:${DEFAULT_API_PORT}`;
+  const since = flag(argv, '--since');
+  const url = `${server.replace(/\/+$/, '')}/api/logs/stream${since ? `?since=${encodeURIComponent(since)}` : ''}`;
+
+  const headers = {};
+  if (profile && profile.token) headers['Authorization'] = `Bearer ${profile.token}`;
+
+  let res;
+  try {
+    res = await fetch(url, { headers });
+  } catch (err) {
+    throw new ConnectError(server, err.message || String(err));
+  }
+  if (!res.ok || !res.body) {
+    process.stderr.write(`crosstalk logs tail: stream open failed (HTTP ${res.status}).\n`);
     return 1;
   }
-  const args = ['compose', '-f', paths.composeFile, 'logs'];
-  if (has(argv, '-f') || has(argv, '--follow')) args.push('--follow');
-  for (let i = 0; i < argv.length; i++) {
-    if (argv[i] === '-n' || argv[i] === '--tail') {
-      args.push('--tail', argv[i + 1] ?? '100');
-      i++;
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = '';
+  const onSig = () => process.exit(0);
+  process.on('SIGINT', onSig);
+  process.on('SIGTERM', onSig);
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    // SSE frames are separated by \n\n; each `data:` line is JSON.
+    let nl;
+    while ((nl = buf.indexOf('\n\n')) !== -1) {
+      const frame = buf.slice(0, nl);
+      buf = buf.slice(nl + 2);
+      const dataLine = frame.split('\n').find((l) => l.startsWith('data:'));
+      if (!dataLine) continue;
+      const payload = dataLine.slice(5).trimStart();
+      try {
+        const entry = JSON.parse(payload);
+        process.stdout.write(fmtEntry(entry) + '\n');
+      } catch {
+        process.stdout.write(payload + '\n');
+      }
     }
   }
-  const r = spawnSync('docker', args, { stdio: 'inherit' });
-  return r.status ?? 1;
+  return 0;
 }

package/commands/message.js

@@ -0,0 +1,125 @@
+// crosstalk message <send|replies> — dispatch + poll primitive messages.
+//
+// Replaces v7's `crosstalk run --type primitive` (now `message send`)
+// and the top-level `crosstalk replies` (now `message replies`).
+// Workflows live under the `workflow` noun (compose|run|status).
+
+import { readFileSync, existsSync, statSync } from 'fs';
+import { apiFor } from '../lib/api-client.js';
+import { reportAndExit } from '../lib/errors.js';
+import { flag, has, positionals } from '../lib/argv.js';
+
+const SEND_FLAGS_WITH_VALUE = new Set([
+  '--to', '--as', '--fanout', '--channel', '--from',
+  '--containername', '-c', '--profile', '--server',
+]);
+
+function usage(exit = 0) {
+  const w = exit === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage:
+  crosstalk message send --to <model>[@<machine>] \\
+                          [--as <persona>] [--fanout <n>] \\
+                          [--channel <name|uuid>] [--from <name>] \\
+                          <body|file|->
+
+  crosstalk message replies <relPath> [<relPath>...]
+`,
+  );
+  process.exit(exit);
+}
+
+function readStdin() {
+  try { return readFileSync(0, 'utf-8'); } catch { return ''; }
+}
+
+function resolveBody(arg) {
+  if (arg == null) return null;
+  if (arg === '-') return readStdin();
+  if (existsSync(arg)) {
+    try {
+      if (statSync(arg).isFile()) return readFileSync(arg, 'utf-8');
+    } catch { /* fall through to inline */ }
+  }
+  return arg;
+}
+
+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 === 'send') return await runSend(rest);
+  if (sub === 'replies') return await runReplies(rest);
+
+  process.stderr.write(`crosstalk message: unknown subcommand '${sub}'.\n`);
+  usage(1);
+}
+
+async function runSend(argv) {
+  const api = apiFor(argv);
+
+  const to = flag(argv, '--to');
+  if (!to) {
+    process.stderr.write('crosstalk message send: --to <model>[@<machine>] is required\n');
+    return 1;
+  }
+
+  // Body is the last positional. positionals() skips flag values so the
+  // body resolves regardless of flag order — `--containername a8 hello`
+  // and `hello --containername a8` both work.
+  const pos = positionals(argv, [...SEND_FLAGS_WITH_VALUE]);
+  const bodyArg = pos[pos.length - 1];
+  const body = resolveBody(bodyArg);
+  if (body == null || body.length === 0) {
+    process.stderr.write('crosstalk message send: missing body (file path, inline string, or `-` for stdin)\n');
+    return 1;
+  }
+
+  const fanoutRaw = flag(argv, '--fanout');
+  const fanout = fanoutRaw ? Math.max(1, parseInt(fanoutRaw, 10)) : 1;
+  const payload = {
+    type: 'primitive',
+    to,
+    as: flag(argv, '--as'),
+    channel: flag(argv, '--channel'),
+    from: flag(argv, '--from') ?? process.env.USER ?? 'operator',
+    fanout,
+    body,
+  };
+
+  let resp;
+  try {
+    resp = await api.post('/messages', payload);
+  } catch (err) {
+    reportAndExit(err, 'crosstalk message send');
+  }
+  for (const p of (resp.relPaths || [])) process.stdout.write(`Sent: ${p}\n`);
+  return 0;
+}
+
+async function runReplies(argv) {
+  const api = apiFor(argv);
+  const targets = positionals(argv, ['--containername', '-c', '--profile', '--server']);
+  if (targets.length === 0) usage(1);
+
+  let resp;
+  try {
+    resp = await api.get(`/replies?relPaths=${encodeURIComponent(targets.join(','))}`);
+  } catch (err) {
+    reportAndExit(err, 'crosstalk message replies');
+  }
+
+  let pending = 0;
+  for (const r of (resp.replies || [])) {
+    if (r.status === 'PENDING') {
+      process.stdout.write(`PENDING  ${r.target}\n`);
+      pending++;
+    } else {
+      const tag = r.status === 'FAILED' ? 'FAILED  ' : 'REPLIED ';
+      process.stdout.write(`${tag} ${r.target}  <- ${r.from} (${r.replyRelPath})\n`);
+    }
+  }
+  return pending > 0 ? 2 : 0;
+}