@cordfuse/crosstalk 7.0.0-alpha.3 → 7.0.0-alpha.5

package/README.md

@@ -36,7 +36,7 @@ crosstalk chat --shell
   exit
 crosstalk chat --agent claude --login
 #    Auth URL opens in your default browser via xdg-open / open / start.
-#    Operator never has to copy-paste it. Token saved in the /root
+#    Operator never has to copy-paste it. Token saved in the /crosstalk-root
 #    volume so subsequent dispatched workers reuse it.
 
 # 4. Send your first message.
@@ -73,7 +73,7 @@ crosstalk replies <relPath printed by step above>
 ## What lives where
 
 - **Host** — `crosstalk` binary on PATH, `~/path/to/mytransport/` (the operator's transport directory, bind-mounted).
-- **Container** (`crosstalk-server`, image `ghcr.io/cordfuse/crosstalk-server`) — `crosstalkd` daemon, dispatch state in named volume `crosstalk-state:/var/lib/crosstalkd-state`, operator-installed agent CLIs + auth tokens in named volume `crosstalk-root:/root`.
+- **Container** (`crosstalk-server`, image `ghcr.io/cordfuse/crosstalk-server`) — `crosstalkd` daemon, dispatch state bind-mounted at `<base>/<transport>/crosstalk-state:/var/lib/crosstalk-state`, operator-installed agent CLIs + auth tokens bind-mounted at `<base>/<transport>/crosstalk-root:/crosstalk-root`. `<base>` is per-OS (`$XDG_DATA_HOME/crosstalk` on Linux, `~/Library/Application Support/crosstalk` on macOS, `%LOCALAPPDATA%\crosstalk` on Windows); `CROSSTALK_STORAGE_MODE=system` switches to `/var/lib`-style paths instead.
 - **Engine HTTP API** — `127.0.0.1:7000` (compose `127.0.0.1:HOST:CONTAINER` port mapping is the actual security boundary; engine binds 0.0.0.0 inside the container).
 - **Transport bind-mount** — `$PWD:/var/lib/crosstalk-transport`. Operator git commands on the host are seen by the engine immediately.
 

package/commands/chat.js

@@ -28,10 +28,59 @@ import { api, ConnectError } from '../lib/api-client.js';
 import { flag, has } from '../lib/argv.js';
 
 const KNOWN_AGENTS = ['claude', 'codex', 'gemini', 'qwen', 'opencode', 'agy'];
-// Conservative URL regex: matches the leading https://...token boundary,
-// stops at whitespace/quote/angle. False positives are bounded to --login
-// mode where the first URL printed is almost certainly the auth URL.
-const URL_RE = /https?:\/\/[^\s<>"']+/;
+
+// 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 =
@@ -107,27 +156,29 @@ function runLogin(container, agent) {
   //
   // 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. Operator can pass
-  // --agent <name> to target a specific one.
+  // 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',
-        '--env', 'COLUMNS=1000', // fallback for browser-open failure
-        '--env', 'LINES=40',
-        container,
-        agent,
-      ],
+      ['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;
-      const match = chunk.toString().match(URL_RE);
-      if (!match) return;
-      const url = match[0];
+      buffer += chunk.toString();
+      const url = extractCompleteUrl(buffer);
+      if (!url) return;
       opened = true;
       const ok = openInBrowser(url);
       process.stdout.write(

package/commands/init.js

@@ -21,7 +21,7 @@ import { spawnSync } from 'child_process';
 import { has, positionals } from '../lib/argv.js';
 
 const DEFAULT_IMAGE = process.env.CROSSTALK_IMAGE
-  ?? 'ghcr.io/cordfuse/crosstalk-server:7.0.0-alpha.3';
+  ?? 'ghcr.io/cordfuse/crosstalk-server:7.0.0-alpha.5';
 
 function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;
@@ -34,9 +34,9 @@ function usage(exit = 0) {
 
   The image must be pullable (or already present locally). For local dev
   before the GHCR publish pipeline ships, build the image first:
-    docker build -t crosstalk-server:7.0.0-alpha.3 -f server/Dockerfile .
+    docker build -t crosstalk-server:7.0.0-alpha.5 -f server/Dockerfile .
   Then run:
-    CROSSTALK_IMAGE=crosstalk-server:7.0.0-alpha.3 crosstalk init mytransport
+    CROSSTALK_IMAGE=crosstalk-server:7.0.0-alpha.5 crosstalk init mytransport
 `,
   );
   process.exit(exit);

package/commands/status.js

@@ -18,7 +18,22 @@ export async function run(_argv) {
 
   process.stdout.write(`Claimed models: ${s.claimed_models.length}\n`);
   if (s.claimed_models.length === 0) {
-    process.stdout.write('  (no model CLIs found inside the container — install one or edit data/models.yaml)\n');
+    // Two failure shapes look the same in claimed_models=0: (a) no CLIs
+    // installed at all, (b) CLIs installed but data/models.yaml has no
+    // entries referencing them. Ask /agents/installed to distinguish so
+    // the operator gets a directly-actionable hint.
+    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) {
+      process.stdout.write(
+        `  (${installed.join(', ')} installed in the container but no data/models.yaml entry references them — 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');
+    }
   } else {
     for (const m of s.claimed_models) process.stdout.write(`  - ${m}\n`);
   }

package/commands/up.js

@@ -9,15 +9,17 @@
 //
 // Subsequent runs: just shell out to `docker compose up -d`.
 
-import { writeFileSync, existsSync, appendFileSync, readFileSync } from 'fs';
+import { writeFileSync, existsSync, mkdirSync, appendFileSync, readFileSync } from 'fs';
 import { spawnSync } from 'child_process';
 import { join } from 'path';
+import { homedir } from 'os';
 import { requireTransportRoot, transportName, composeFile } from '../lib/transport.js';
 import { has } from '../lib/argv.js';
 
 const DEFAULT_IMAGE = process.env.CROSSTALK_IMAGE
-  ?? 'ghcr.io/cordfuse/crosstalk-server:7.0.0-alpha.3';
+  ?? 'ghcr.io/cordfuse/crosstalk-server:7.0.0-alpha.5';
 const DEFAULT_API_PORT = Number(process.env.CROSSTALK_API_PORT) || 7000;
+const STORAGE_MODE = (process.env.CROSSTALK_STORAGE_MODE ?? 'user').toLowerCase();
 
 function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;
@@ -26,25 +28,94 @@ function usage(exit = 0) {
 
 Brings up the engine container for the transport in the current directory
 (or any ancestor containing CROSSTALK-VERSION). First-time use generates
-docker-compose.yml in the transport root. Override the image with
-CROSSTALK_IMAGE, the API port with CROSSTALK_API_PORT.
+docker-compose.yml in the transport root.
+
+Environment:
+  CROSSTALK_IMAGE         Image to pin (default: bundled GHCR tag)
+  CROSSTALK_API_PORT      Host port to map (default: 7000)
+  CROSSTALK_ALIAS         Dispatcher's machine identity in the bus
+  CROSSTALK_STORAGE_MODE  user (default) | system
+                          Where bind-mounted crosstalk-root +
+                          crosstalk-state live on the host. 'system'
+                          uses paths under /var/lib (Linux) / /Library
+                          (macOS) / C:\\ProgramData (Windows) — requires
+                          sudo/UAC and (on macOS) Docker Desktop file-
+                          sharing allowlist. 'user' uses paths under
+                          the operator's home directory with no
+                          escalation.
 `,
   );
   process.exit(exit);
 }
 
-function renderCompose({ name, image, apiPort, alias, uid, gid }) {
-  // Entrypoint runs as root for setup (apt-installed CLIs in /root,
-  // npm prefix, SSH key import). It then adjusts a 'crosstalkd' user
-  // to match CROSSTALK_UID/GID (operator's host UID), chowns the
-  // bind-mounted transport + state dir to that user, and drops via
-  // setpriv before exec'ing the dispatcher. Net effect: bind-mount
-  // files written by the engine are operator-owned on the host, so
-  // \`git remote add\` and friends work without sudo. /root stays
-  // root-owned for CLI installs.
+// Resolve the host directories that back the container's /crosstalk-root
+// (operator-installed CLIs + auth) and /var/lib/crosstalk-state
+// (dispatcher state) bind mounts.
+//
+// User-mode (default) keeps everything under the operator's home so no
+// sudo / UAC / Docker Desktop file-sharing allowlist gymnastics are
+// needed. System-mode is for headless production-style deployments
+// where multiple operators share a machine and a service user manages
+// the daemon.
+//
+// Host-side dir names use the same `crosstalk-` prefix as the container
+// paths so things stay identifiable wherever they surface (backup tools,
+// file managers, support-email screenshots).
+function resolveStoragePaths(transportName, mode) {
+  const platform = process.platform;
+  // Per-OS base directories.
+  const bases = (platform === 'darwin')
+    ? {
+        user:   join(homedir(), 'Library', 'Application Support', 'crosstalk'),
+        system: '/Library/Application Support/crosstalk',
+      }
+    : (platform === 'win32')
+    ? {
+        // %LOCALAPPDATA% should always be set on supported Win versions;
+        // fall back to ~/AppData/Local if it isn't.
+        user:   process.env['LOCALAPPDATA']
+                  ? join(process.env['LOCALAPPDATA'], 'crosstalk')
+                  : join(homedir(), 'AppData', 'Local', 'crosstalk'),
+        system: 'C:\\ProgramData\\crosstalk',
+      }
+    : /* linux + other unix */ {
+        // Honor XDG_DATA_HOME silently (no docs surface; the 99% of
+        // operators who haven't set it get ~/.local/share/crosstalk
+        // either way).
+        user:   join(process.env['XDG_DATA_HOME'] ?? join(homedir(), '.local', 'share'), 'crosstalk'),
+        system: '/var/lib/crosstalk',
+      };
+
+  if (mode !== 'user' && mode !== 'system') {
+    throw new Error(
+      `crosstalk up: CROSSTALK_STORAGE_MODE='${mode}' invalid — must be 'user' or 'system'.`,
+    );
+  }
+  const base = bases[mode];
+  const transportRoot = join(base, transportName);
+  return {
+    crosstalkRoot:  join(transportRoot, 'crosstalk-root'),
+    crosstalkState: join(transportRoot, 'crosstalk-state'),
+    mode,
+  };
+}
+
+function renderCompose({ name, image, apiPort, alias, uid, gid, crosstalkRootHost, crosstalkStateHost, storageMode }) {
+  // Entrypoint runs as root for setup (npm prefix, SSH key import). It
+  // then adjusts a 'crosstalkd' user to match CROSSTALK_UID/GID
+  // (operator's host UID), chowns the bind-mounted transport, state
+  // dir, AND /crosstalk-root to that user, then drops via setpriv before
+  // exec'ing the dispatcher. Net effect: bind-mount files written by
+  // the engine are operator-owned on the host, so \`git remote add\`
+  // and \`rm -rf\` from the host both work without sudo.
   return `# Generated by \`crosstalk up\`. Safe to edit; subsequent \`up\`s
 # only regenerate when this file is missing. Compose config is machine-
 # local — kept out of git via .gitignore by default.
+#
+# Storage mode: ${storageMode}
+# crosstalk-root  (container /crosstalk-root)              → ${crosstalkRootHost}
+# crosstalk-state (container /var/lib/crosstalk-state)     → ${crosstalkStateHost}
+# transport       (container /var/lib/crosstalk-transport) → \${PWD} (bind to this directory)
 
 services:
   crosstalkd:
@@ -58,11 +129,12 @@ services:
       # to the engine on the next tick. No clone-on-startup needed.
       - .:/var/lib/crosstalk-transport
       # Operator-installed agent CLIs (claude, codex, agy, ...) + auth
-      # state. Root-owned, dispatcher reads only.
-      - crosstalk-root:/root
-      # Dispatcher's machine-local state: cursor, heartbeat, errors.log.
-      # Operator-UID-owned (chowned by entrypoint to CROSSTALK_UID/GID).
-      - crosstalk-state:/var/lib/crosstalkd-state
+      # state. Chowned to operator UID at entrypoint so host-side
+      # \`rm -rf\` works without sudo.
+      - ${crosstalkRootHost}:/crosstalk-root
+      # Dispatcher's machine-local state: cursor, heartbeat, errors.log,
+      # pidfile, wake.signal. Operator-UID-owned (chowned by entrypoint).
+      - ${crosstalkStateHost}:/var/lib/crosstalk-state
     environment:
       CROSSTALK_ALIAS: ${alias}
       CROSSTALK_UID: "${uid}"
@@ -70,10 +142,6 @@ services:
       CROSSTALKD_API_PORT: "7000"
       DISPATCH_JSON: "true"
       DISPATCH_POLL_SECONDS: "30"
-
-volumes:
-  crosstalk-root:
-  crosstalk-state:
 `;
 }
 
@@ -101,6 +169,31 @@ export async function run(argv) {
     const alias = process.env.CROSSTALK_ALIAS ?? process.env.HOSTNAME ?? transportName(root);
     const uid = typeof process.getuid === 'function' ? process.getuid() : 1000;
     const gid = typeof process.getgid === 'function' ? process.getgid() : 1000;
+    let storage;
+    try {
+      storage = resolveStoragePaths(transportName(root), STORAGE_MODE);
+    } catch (err) {
+      process.stderr.write(`${err.message}\n`);
+      return 1;
+    }
+    // Pre-create the host bind-mount directories. Docker would auto-
+    // create them as root-owned otherwise, which would break the
+    // operator-UID chown step inside the container.
+    try {
+      mkdirSync(storage.crosstalkRoot,  { recursive: true });
+      mkdirSync(storage.crosstalkState, { recursive: true });
+    } catch (err) {
+      process.stderr.write(
+        `crosstalk up: failed to create storage directories — ${err.message}\n`,
+      );
+      if (storage.mode === 'system') {
+        process.stderr.write(
+          `  System-mode storage requires write access to ${storage.crosstalkRoot}'s parent.\n` +
+          `  Try: sudo mkdir -p ${storage.crosstalkRoot} ${storage.crosstalkState} && sudo chown -R \$USER ${storage.crosstalkRoot} ${storage.crosstalkState}\n`,
+        );
+      }
+      return 1;
+    }
     const content = renderCompose({
       name: transportName(root),
       image: DEFAULT_IMAGE,
@@ -108,10 +201,13 @@ export async function run(argv) {
       alias,
       uid,
       gid,
+      crosstalkRootHost:  storage.crosstalkRoot,
+      crosstalkStateHost: storage.crosstalkState,
+      storageMode: storage.mode,
     });
     writeFileSync(composeYml, content);
     ensureGitignored(root);
-    process.stdout.write(`Generated ${composeYml}\n`);
+    process.stdout.write(`Generated ${composeYml} (storage: ${storage.mode})\n`);
   }
 
   const r = spawnSync('docker', ['compose', '-f', composeYml, 'up', '-d'], {

package/package.json

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