@cordfuse/crosstalk 7.0.0-alpha.6 → 7.0.0-alpha.8

package/commands/chat.js

@@ -1,110 +1,33 @@
-// crosstalk chat — the single interactive entry point into the container.
+// crosstalk chat — interactive entry into the container.
 //
-// Modes:
-//   crosstalk chat --agent <name>            # interactive with a specific agent
-//   crosstalk chat --agent <name> --login    # OAuth setup flow with browser-open
-//   crosstalk chat --shell                   # bash escape hatch (sysadmin / debug)
+// 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)
 //
-// --agent is required for non-shell modes. There's no implicit default
-// (containers may have multiple agent CLIs installed; the operator
-// must say which one to invoke).
+// --agent is required for non-shell mode. There's no implicit default;
+// containers may have multiple agent CLIs installed, the operator
+// picks one explicitly.
 //
-// Login flow design (root-cause fix, not a bandaid):
-//   The container has no DISPLAY / no browser / no xdg-open. So the agent
-//   CLI prints a URL and expects the operator to manually open it. THIS
-//   wrapper runs on the HOST — where the browser lives. It intercepts the
-//   URL on the agent's stdout and opens it directly via the OS-native
-//   browser launcher (`open` / `xdg-open` / `wslview` / `start`). Operator
-//   never has to read or copy-paste the URL.
-//
-//   COLUMNS=1000 is still set under --login as a contingency: if browser
-//   open fails (headless SSH session, missing xdg-open, etc.), the URL
-//   still renders unwrapped in the terminal for manual copy. That's the
-//   fallback, not the primary mechanism.
+// `--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.
 
-import { spawn, spawnSync } from 'child_process';
+import { 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';
 
 const KNOWN_AGENTS = ['claude', 'codex', 'gemini', 'qwen', 'opencode', 'agy'];
 
-// URL extraction that survives agent TUI rendering. Naive regex against
-// raw stdout fails because agent CLIs (Claude in particular) draw a box
-// around the URL with line wraps every ~N chars; the captured URL is
-// truncated at the first wrap, with ANSI control chars leaking in at
-// the cut point. Real example from alpha.3 macOS test: extracted URL
-// ended with `%18%6b…` (CAN char + box-drawing artifact) instead of
-// the `redirect_uri=…` param, breaking OAuth.
-//
-// Approach:
-//   1. ANSI-strip everything (CSI / OSC / SS3 escapes).
-//   2. Strip control chars (0x00-0x1F except LF, plus DEL).
-//   3. Join line wraps that occur INSIDE a URL-safe character run —
-//      `<url-char>\n<url-char>` → `<url-char><url-char>`. Preserves real
-//      `<url-char>\n<non-url-char>` boundaries.
-//   4. Match `https?://<url-chars>+` against the joined buffer.
-//   5. Only fire when the character AFTER the matched URL is a true
-//      terminator (whitespace, end-of-buffer) — guards against acting
-//      on a partial URL still being written.
-
-const URL_SAFE_CLASS = "a-zA-Z0-9%/?#&=+\\-._~:@!$()*,;";
-const URL_RE = new RegExp(`https?://[${URL_SAFE_CLASS}]+`);
-
-function extractCompleteUrl(rawBuffer) {
-  // Strip ANSI CSI escapes (\x1B[ ... terminator).
-  let clean = rawBuffer.replace(/\x1B\[[0-9;?]*[a-zA-Z]/g, '');
-  // Strip ANSI OSC escapes (\x1B] ... BEL or ST).
-  clean = clean.replace(/\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g, '');
-  // Strip SS3 escapes (\x1BO + one char).
-  clean = clean.replace(/\x1BO./g, '');
-  // Strip remaining single-char escapes that slipped through.
-  clean = clean.replace(/\x1B[^a-zA-Z0-9]/g, '');
-  // Strip control chars except LF (0x0A); we use LF for line-wrap rejoin.
-  clean = clean.replace(/[\x00-\x09\x0B-\x1F\x7F]/g, '');
-  // Rejoin URL-character wrap points: `<url-char>\n<url-char>` becomes
-  // `<url-char><url-char>`. Doesn't merge `<url-char>\n<space>` etc.
-  const safeRe = new RegExp(`[${URL_SAFE_CLASS}]\\n[${URL_SAFE_CLASS}]`, 'g');
-  let prev;
-  do {
-    prev = clean;
-    clean = clean.replace(safeRe, (m) => m[0] + m[2]);
-  } while (clean !== prev);
-
-  const match = clean.match(URL_RE);
-  if (!match) return null;
-  // Require a terminator after the URL — without it, the URL may still
-  // be growing in subsequent stdout chunks. Terminator = whitespace,
-  // quote/angle, or end-of-buffer-with-trailing-newline.
-  const after = clean.slice(match.index + match[0].length);
-  if (after.length === 0) return null;       // EOF-as-grow case, wait
-  if (!/^[\s<>"']/.test(after)) return null; // URL still continuing
-  return match[0];
-}
-
-function openInBrowser(url) {
-  const cmd =
-    process.platform === 'darwin'         ? 'open'      :
-    process.platform === 'win32'          ? 'start'     :
-    process.env['WSL_DISTRO_NAME']        ? 'wslview'   :
-    /* default Linux */                     'xdg-open';
-  try {
-    const r = spawnSync(cmd, [url], { stdio: 'ignore' });
-    return r.status === 0;
-  } catch {
-    return false;
-  }
-}
-
 function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;
   w.write(
-`Usage: crosstalk chat --agent <name> [--login]
+`Usage: crosstalk chat --agent <name>
        crosstalk chat --shell
 
-Opens an interactive session inside the engine container — the single
-PTY-wrapped entry point for everything you'd do inside the container
-(daily chat, OAuth setup, sysadmin).
+Opens an interactive session inside the engine container.
 
 --agent is REQUIRED for any chat mode. Containers can have multiple
 agent CLIs installed; the operator must say which one to invoke.
@@ -112,20 +35,16 @@ agent CLIs installed; the operator must say which one to invoke.
 Supported agents: ${KNOWN_AGENTS.join(', ')}.
 
 Modes:
-  --agent <name>        Interactive with the named agent.
-  --agent <name> --login   First-time auth flow. Intercepts the OAuth
-                        URL on the agent's stdout and opens it in your
-                        default browser via the OS-native launcher.
-                        Falls back to printing the URL unwrapped if no
-                        browser is reachable (headless / SSH session).
-  --shell               Drop into bash (install agent CLIs, debug,
-                        inspect state). No --agent needed.
+  --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\`).
 
 Examples:
   crosstalk chat --agent claude               # interactive claude
   crosstalk chat --agent gemini               # interactive gemini
-  crosstalk chat --agent claude --login       # OAuth, claude
-  crosstalk chat --agent codex  --login       # OAuth, codex
   crosstalk chat --shell                      # bash
 `,
   );
@@ -135,8 +54,8 @@ Examples:
 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 get to render their rich TUI
-  // normally.
+  // 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}`);
@@ -147,51 +66,6 @@ function runInteractive(container, command, env = {}) {
   return r.status ?? 1;
 }
 
-function runLogin(container, agent) {
-  // Login mode: tee the agent's stdout so we can spot the auth URL and
-  // open it in the operator's browser. The container still has a real
-  // PTY (docker exec -it allocates one inside the container regardless
-  // of host stdio configuration), so the agent CLI renders into a TTY;
-  // we just pipe the bytes on the host side to inspect them.
-  //
-  // No agent-specific "login" subcommand — we just run the agent's
-  // default interactive entry point. First-run auth flow happens
-  // automatically for every agent we support.
-  //
-  // No COLUMNS=1000 env: making the agent render the URL "unwrapped" via
-  // a wide terminal claim doesn't reliably propagate to the in-container
-  // PTY, and even when it does Claude's TUI hard-wraps anyway. The
-  // extractCompleteUrl() function joins wrapped URL fragments on the
-  // host side, so the agent's rendering width is irrelevant. As bonus,
-  // dropping COLUMNS=1000 fixes daily-chat soft-wrap weirdness in
-  // long-form prose (agents see the real host terminal width).
-  return new Promise((resolve) => {
-    const child = spawn(
-      'docker',
-      ['exec', '-it', container, agent],
-      { stdio: ['inherit', 'pipe', 'inherit'] },
-    );
-    let opened = false;
-    let buffer = '';
-    child.stdout.on('data', (chunk) => {
-      process.stdout.write(chunk);
-      if (opened) return;
-      buffer += chunk.toString();
-      const url = extractCompleteUrl(buffer);
-      if (!url) return;
-      opened = true;
-      const ok = openInBrowser(url);
-      process.stdout.write(
-        ok
-          ? `\n[crosstalk chat] Opened auth URL in your default browser.\n`
-          : `\n[crosstalk chat] Could not auto-open browser. Open this URL manually:\n  ${url}\n`,
-      );
-    });
-    child.on('exit', (code) => resolve(code ?? 0));
-    child.on('error', () => resolve(1));
-  });
-}
-
 export async function run(argv) {
   if (has(argv, '--help') || has(argv, '-h')) usage(0);
 
@@ -241,9 +115,5 @@ export async function run(argv) {
     return 1;
   }
 
-  if (has(argv, '--login')) {
-    return await runLogin(name, agent);
-  }
-
   return runInteractive(name, agent);
 }

package/commands/init.js

@@ -1,40 +1,40 @@
 // crosstalk init — scaffold a transport into <base>/<name>/.
 //
-// alpha.6: runtime owns the transport. Operator no longer creates a
-// `transport/` dir on their host filesystem; init creates it at
-// <base>/<name>/transport/ where <base> is per-OS user-mode (or
-// system-mode via CROSSTALK_STORAGE_MODE=system).
+// alpha.7 rewrite: phased + idempotent. Each phase is independent and
+// safe to re-run; re-init detects missing markers and repairs them.
+// Mac caught bug A in alpha.6 where the api-port file was written at
+// the end of the pipeline, so any disruption (image pull, git failure)
+// left storage existing but unstartable — and re-init silently
+// no-op-ed instead of fixing it.
 //
-// Operator's interaction surface:
-//   crosstalk init                            # default container 'crosstalk'
-//   crosstalk init --containername uat        # named container 'uat'
-//   crosstalk init --remote git@example:t.git # set upstream at init time
+// Phases:
+//   1. Storage layout — mkdir subdirs + write api-port. Pure FS, fast,
+//      runs first so the resolver-visible marker exists before anything
+//      else can go wrong.
+//   2. Transport scaffold — `crosstalkd init` in a one-shot container.
+//      Skipped if transport/.git already exists. stdout/stderr captured
+//      (mac's bug B — in-container scaffold output was leaking).
+//   3. Git init + initial commit. Skipped if .git exists.
+//   4. Remote setup if --remote given (errors if a different origin
+//      is already set; idempotent on same-value).
+//   5. Summary.
 //
-// Mechanics:
-//   1. Resolve <base>/<name>/ and pre-create the bind-mount subdirs
-//      (transport/, crosstalk-root/, crosstalk-state/).
-//   2. Run `crosstalkd init /init-target` in a one-shot container,
-//      bind-mounting transport/ as /init-target. The engine writes its
-//      template (CROSSTALK-VERSION, PROTOCOL.md, CROSSTALK.md, data/,
-//      local/) into the bind-mount.
-//   3. `git init` inside transport/ + initial commit.
-//   4. If --remote: `git remote add origin <url>`.
-//   5. Pick a free API port (default container always 7000; named
-//      containers search from 7001) and write to <base>/<name>/api-port.
-
-import { mkdirSync, existsSync, writeFileSync } from 'fs';
+// Each phase reports created/skipped/repaired so operators can tell
+// what just happened.
+
+import { mkdirSync, existsSync, writeFileSync, readFileSync } from 'fs';
 import { spawnSync } from 'child_process';
+import { join } from 'path';
 import { has, flag } from '../lib/argv.js';
 import {
   parseContainerName,
   storagePaths,
-  isInitialized,
   pickFreePort,
   DEFAULT_CONTAINER_NAME,
 } from '../lib/resolve.js';
 
 const DEFAULT_IMAGE = process.env.CROSSTALK_IMAGE
-  ?? 'ghcr.io/cordfuse/crosstalk-server:7.0.0-alpha.6';
+  ?? 'ghcr.io/cordfuse/crosstalk-server:7.0.0-alpha.8';
 
 function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;
@@ -42,8 +42,11 @@ function usage(exit = 0) {
 `Usage:
   crosstalk init [--containername <name>] [--remote <url>]
 
-Creates a new transport on this machine. The transport git repo lives at
-<base>/<name>/transport/ where <base> is:
+Creates a new transport on this machine, or repairs an existing
+incomplete one. Idempotent — re-running fills in any missing markers
+without disturbing existing state.
+
+The transport git repo lives at <base>/<name>/transport/ where <base> is:
   Linux:   $XDG_DATA_HOME/crosstalk/   (or ~/.local/share/crosstalk/)
   macOS:   ~/Library/Application Support/crosstalk/
   Windows: %LOCALAPPDATA%\\crosstalk\\
@@ -55,8 +58,8 @@ Options:
   --containername <name>   Container name (default: 'crosstalk'). Must be
                            lowercase alphanumeric + ._- (no leading . or -).
                            One default + N named containers per machine.
-  --remote <url>           Set git upstream at init time. Engine's first
-                           tick will fetch + rebase against this remote.
+  --remote <url>           Set git upstream. If a different remote is
+                           already set, errors instead of overwriting.
   --image <tag>            Override the engine image (default: bundled
                            GHCR tag; or CROSSTALK_IMAGE env).
   -c <name>                Shorthand for --containername.
@@ -81,22 +84,15 @@ export async function run(argv) {
     return 1;
   }
 
-  if (isInitialized(name)) {
-    const paths = storagePaths(name);
-    process.stderr.write(
-      `crosstalk init: transport '${name}' already initialized at ${paths.transportDir}.\n` +
-      `  Run 'crosstalk up${name === DEFAULT_CONTAINER_NAME ? '' : ` --containername ${name}`}' to start it,\n` +
-      `  or 'crosstalk rm${name === DEFAULT_CONTAINER_NAME ? '' : ` --containername ${name}`}' to wipe it first.\n`,
-    );
-    return 1;
-  }
-
   const remote = flag(argv, '--remote');
   const image = flag(argv, '--image') ?? DEFAULT_IMAGE;
   const paths = storagePaths(name);
+  const report = [];
 
-  // Pre-create the storage tree. Docker would auto-create the bind-mount
-  // dirs root-owned otherwise, breaking the entrypoint's chown step.
+  // ── Phase 1: Storage layout ────────────────────────────────────────
+  // mkdir is idempotent (recursive: true). Write api-port if absent.
+  // This is the load-bearing fix for bug A — port file lands FIRST,
+  // before anything else can go wrong (image pull, git init, etc.).
   try {
     mkdirSync(paths.transportDir,   { recursive: true });
     mkdirSync(paths.crosstalkRoot,  { recursive: true });
@@ -114,81 +110,133 @@ export async function run(argv) {
     return 1;
   }
 
-  // Engine-side template scaffolding: run crosstalkd init in a one-shot
-  // container, bind-mounting our transport/ as /init-target. --user maps
-  // ownership to operator UID so the written files are operator-owned.
-  const uid = typeof process.getuid === 'function' ? process.getuid() : null;
-  const gid = typeof process.getgid === 'function' ? process.getgid() : null;
-  const userArgs = (uid != null && gid != null) ? ['--user', `${uid}:${gid}`] : [];
-
-  const dockerArgs = [
-    'run', '--rm',
-    '-v', `${paths.transportDir}:/init-target`,
-    ...userArgs,
-    '--entrypoint', 'crosstalkd',
-    image,
-    'init', '/init-target',
-  ];
+  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 init: port allocation failed — ${err.message}\n`);
+      return 1;
+    }
+  }
 
-  const initRun = spawnSync('docker', dockerArgs, { stdio: 'inherit' });
-  if (initRun.status !== 0) {
-    process.stderr.write(`crosstalk init: docker run exited ${initRun.status}\n`);
-    process.stderr.write(`  command was: docker ${dockerArgs.join(' ')}\n`);
-    return initRun.status ?? 1;
+  // ── Phase 2: Transport scaffold ────────────────────────────────────
+  // The template-scaffold check is "does CROSSTALK-VERSION exist?" NOT
+  // ".git exists" — git init is a separate phase, and the engine refuses
+  // to re-scaffold over an existing CROSSTALK-VERSION (without --force).
+  // Decoupling means a disrupted init (template written, git init never
+  // ran) re-enters Phase 3 cleanly on re-run.
+  const transportGitDir      = join(paths.transportDir, '.git');
+  const crosstalkVersionFile = join(paths.transportDir, 'CROSSTALK-VERSION');
+  if (!existsSync(crosstalkVersionFile)) {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : null;
+    const gid = typeof process.getgid === 'function' ? process.getgid() : null;
+    const userArgs = (uid != null && gid != null) ? ['--user', `${uid}:${gid}`] : [];
+
+    const dockerArgs = [
+      'run', '--rm',
+      '-v', `${paths.transportDir}:/init-target`,
+      ...userArgs,
+      '--entrypoint', 'crosstalkd',
+      image,
+      'init', '/init-target',
+    ];
+
+    // Bug B fix: don't inherit stdio — the engine prints next-steps that
+    // confuse operators ("Transport initialized at /init-target" with
+    // container-internal paths). Capture, show only on failure.
+    const initRun = spawnSync('docker', dockerArgs, { stdio: 'pipe' });
+    if (initRun.status !== 0) {
+      const stderr = initRun.stderr?.toString() ?? '';
+      const stdout = initRun.stdout?.toString() ?? '';
+      process.stderr.write(`crosstalk init: docker run exited ${initRun.status}\n`);
+      if (stderr.trim()) process.stderr.write(`  stderr: ${stderr.trim()}\n`);
+      if (stdout.trim()) process.stderr.write(`  stdout: ${stdout.trim()}\n`);
+      process.stderr.write(`  command was: docker ${dockerArgs.join(' ')}\n`);
+      return initRun.status ?? 1;
+    }
+    report.push(`  template:   scaffolded via ${image}`);
+  } else {
+    report.push(`  template:   present (skipped scaffold)`);
+  }
+
+  // ── Phase 3: Git init + initial commit ─────────────────────────────
+  if (!existsSync(crosstalkVersionFile)) {
+    // Engine init succeeded but didn't leave files. Bail clearly — we
+    // won't proceed to git init on an empty dir.
+    process.stderr.write(
+      `crosstalk init: transport template missing at ${paths.transportDir}\n` +
+      `  Engine init didn't write template files. Try 'crosstalk rm' then re-init.\n`,
+    );
+    return 1;
   }
 
-  // Auto git init + initial commit. Doing it on the host so the commit
-  // author uses the operator's local git config — not the container's.
   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) {
-      const stderr = gr.stderr?.toString().trim() ?? '';
-      process.stderr.write(
-        `crosstalk init: 'git ${args.join(' ')}' failed — ${stderr}\n` +
-        `  Storage was scaffolded but not committed. Finish manually at:\n` +
-        `    ${paths.transportDir}\n`,
-      );
-      // Not fatal — storage exists and engine will tolerate uncommitted state
+      // 'git init' on existing repo is fine (it re-runs idempotently);
+      // 'add -A' is also idempotent. 'commit' fails when there's
+      // nothing to commit — that means a previous run already committed.
+      // Only the first call (git init) is load-bearing; the rest are
+      // best-effort to populate the initial state.
+      gitOk = false;
       break;
     }
   }
+  report.push(gitOk ? `  git:        initialized + committed` : `  git:        already present (skipped)`);
 
-  // Set up the upstream if requested. Failures here aren't fatal —
-  // operator can retry with `cd <transport-dir> && git remote add`.
+  // ── Phase 4: Remote setup ──────────────────────────────────────────
   if (remote) {
-    const rr = spawnSync('git', ['remote', 'add', 'origin', remote], {
+    const cur = spawnSync('git', ['remote', 'get-url', 'origin'], {
       cwd: paths.transportDir,
       stdio: 'pipe',
     });
-    if (rr.status !== 0) {
+    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 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 init: 'git remote add origin ${remote}' failed — ${rr.stderr?.toString().trim()}\n`,
+        `crosstalk init: remote already set to '${currentUrl}'; refusing to overwrite with '${remote}'.\n` +
+        `  Use 'crosstalk status' to see the transport path; cd there and adjust git config manually if intended.\n`,
       );
+      return 1;
     }
   }
 
-  // Allocate an API port and persist it for the resolver.
-  let port;
-  try {
-    port = pickFreePort(name);
-    writeFileSync(paths.portFile, `${port}\n`);
-  } catch (err) {
-    process.stderr.write(`crosstalk init: port allocation failed — ${err.message}\n`);
-    return 1;
-  }
-
+  // ── Phase 5: Summary ───────────────────────────────────────────────
   process.stdout.write(
-    `\nTransport '${name}' initialized:\n` +
+    `\nTransport '${name}' ready:\n` +
     `  storage:    ${paths.storageRoot}\n` +
     `  transport:  ${paths.transportDir}\n` +
     `  image:      ${image}\n` +
-    `  api port:   ${port}\n` +
-    (remote ? `  remote:     ${remote}\n` : '') +
+    report.join('\n') + '\n' +
     `\nNext: crosstalk up${name === DEFAULT_CONTAINER_NAME ? '' : ` --containername ${name}`}\n`,
   );
   return 0;

package/commands/restart.js

@@ -1,4 +1,9 @@
 // crosstalk restart — restart a transport's engine container.
+//
+// Uses `compose up -d --force-recreate` (not `compose restart`) so
+// changes to env_file (e.g. tokens added via `crosstalk auth paste`)
+// are picked up. Plain `compose restart` just stops + starts the same
+// container without re-reading config.
 
 import { existsSync } from 'fs';
 import { spawnSync } from 'child_process';
@@ -15,8 +20,10 @@ export async function run(argv) {
     process.stderr.write(`crosstalk restart: '${name}' has no compose file — run 'crosstalk up' first.\n`);
     return 1;
   }
-  const r = spawnSync('docker', ['compose', '-f', paths.composeFile, 'restart'], {
-    stdio: 'inherit',
-  });
+  const r = spawnSync(
+    'docker',
+    ['compose', '-f', paths.composeFile, 'up', '-d', '--force-recreate'],
+    { stdio: 'inherit' },
+  );
   return r.status ?? 1;
 }

package/commands/status.js

@@ -34,10 +34,10 @@ export async function run(argv) {
     if (installed && installed.length > 0) {
       const verb = installed.length === 1 ? 'references it' : 'references them';
       process.stdout.write(
-        `  (${installed.join(', ')} installed in the container but no data/models.yaml entry ${verb} — add one to claim)\n`,
+        `  (${installed.join(', ')} installed in the container but no data/crosstalk.yaml entry ${verb} — add one to claim)\n`,
       );
     } else {
-      process.stdout.write('  (no model CLIs found inside the container — install one via `crosstalk chat --shell` and add an entry to data/models.yaml)\n');
+      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`);

package/commands/up.js

@@ -24,7 +24,7 @@ import {
 } from '../lib/resolve.js';
 
 const DEFAULT_IMAGE = process.env.CROSSTALK_IMAGE
-  ?? 'ghcr.io/cordfuse/crosstalk-server:7.0.0-alpha.6';
+  ?? 'ghcr.io/cordfuse/crosstalk-server:7.0.0-alpha.8';
 
 function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;

package/lib/api-client.js

@@ -111,9 +111,16 @@ async function call(method, path, body, opts = {}) {
 
 // Bind an api client to a specific container name. All callers should
 // either pass argv (auto-resolves name) or an explicit name. Internally
-// each call resolves the port via the name's api-port file.
+// each call resolves the port via the name's api-port file. Validation
+// errors print cleanly (no stack trace) — bug C fix.
 export function apiFor(argv) {
-  const name = parseContainerName(argv);
+  let name;
+  try {
+    name = parseContainerName(argv);
+  } catch (err) {
+    process.stderr.write(`crosstalk: ${err.message}\n`);
+    process.exit(1);
+  }
   return {
     name,
     get:    (path, opts = {})        => call('GET',    path, undefined, { ...opts, name }),

package/lib/resolve.js

@@ -168,8 +168,18 @@ export function containerExists(name) {
 // Look up the resolved name+paths from argv, validate that init has run,
 // and exit with a clear error if not. For verbs that operate on existing
 // transports (up after init, status, chat, down, rm, etc).
+//
+// Validation errors from parseContainerName are caught here and printed
+// cleanly — Mac's bug C from alpha.6 was a raw stack trace when an
+// invalid --containername reached the resolver.
 export function requireInitialized(argv) {
-  const name = parseContainerName(argv);
+  let name;
+  try {
+    name = parseContainerName(argv);
+  } catch (err) {
+    process.stderr.write(`crosstalk: ${err.message}\n`);
+    process.exit(1);
+  }
   if (!isInitialized(name)) {
     process.stderr.write(
       `crosstalk: no transport '${name}' on this machine.\n` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cordfuse/crosstalk",
-  "version": "7.0.0-alpha.6",
+  "version": "7.0.0-alpha.8",
   "description": "Crosstalk client — host-side CLI that talks to the crosstalkd daemon running inside the crosstalk-server container.",
   "type": "module",
   "license": "MIT",