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

package/lib/api-client.js

@@ -1,27 +1,32 @@
-// api-client.js — HTTP client over loopback to crosstalkd's local API.
+// api-client.js — HTTP client to a crosstalk engine.
 //
-// All operator commands route through this. The engine binds 127.0.0.1
-// inside the container; docker-compose maps that to the host loopback.
-// The host port differs per container — default container 'crosstalk'
-// gets 7000; named containers pick a free port at init time, recorded in
-// `<base>/<name>/api-port`. apiPortFor() resolves name → port.
+// Two routing modes:
+//   1. **Local (default)** — engine binds 127.0.0.1 on the host. Port
+//      is per-transport (default 'crosstalk' transport gets 7000; named
+//      transports record their port in `<base>/<name>/api-port`).
+//   2. **Remote** — active credentials profile carries a non-loopback
+//      `server` URL (e.g. https://crosstalk.cordfuse.io). When set, the
+//      profile server overrides loopback routing for this invocation.
 //
-// Port resolution order:
+// Port resolution order (local mode only):
 //   1. opts.port (explicit override from caller)
 //   2. CROSSTALK_API_PORT env var (test/dev override)
 //   3. apiPortFor(name) — reads `<base>/<name>/api-port` file
 //   4. DEFAULT_API_PORT (7000) as last resort
 //
-// No auth: engine binds 127.0.0.1 only, no token. Same model as ollama.
+// Auth: bearer token from the active credentials profile, sent on every
+// authenticated call. opts.skipAuth=true suppresses (used by login).
 //
 // Version skew: engine sets X-Crosstalk-Engine-Version on every response.
 // We compare to client version on each call, emit one warning per process
 // if mismatched. Pre-1.0 client and engine ship in lockstep.
 
-import { readFileSync } from 'fs';
+import { readFileSync, existsSync } from 'fs';
 import { dirname, join } from 'path';
+import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { apiPortFor, DEFAULT_API_PORT, parseContainerName } from './resolve.js';
+import { readToken, getActiveProfile } from './credentials.js';
 
 const CLIENT_VERSION = (() => {
   try {
@@ -59,6 +64,12 @@ function apiUrl(path, port) {
   return `http://127.0.0.1:${port}${path}`;
 }
 
+function remoteApiUrl(server, path) {
+  // Trim any trailing slash so we don't end up with double-slashes.
+  const base = server.replace(/\/+$/, '');
+  return `${base}${path}`;
+}
+
 async function parseJsonOrThrow(res) {
   let body;
   try {
@@ -82,28 +93,64 @@ export class ApiError extends Error {
 }
 
 export class ConnectError extends Error {
-  constructor(port, cause) {
+  constructor(target, cause) {
+    const isUrl = typeof target === 'string' && /^https?:/.test(target);
     super(
-      `cannot reach crosstalkd on 127.0.0.1:${port} — is the container running? ` +
-      `Try 'crosstalk up' to start it. (underlying: ${cause})`,
+      isUrl
+        ? `cannot reach crosstalk engine at ${target}. (underlying: ${cause})`
+        : `cannot reach crosstalk engine on 127.0.0.1:${target} — is the daemon running? ` +
+          `Try 'crosstalk server start' to start it. (underlying: ${cause})`,
     );
     this.name = 'ConnectError';
-    this.port = port;
+    this.target = target;
+    this.port = isUrl ? null : target;
   }
 }
 
 async function call(method, path, body, opts = {}) {
-  const port = resolvePort(opts);
+  // Resolve the target server, in priority order:
+  //   1. opts.serverOverride — explicit per-call URL. Used by `auth login`
+  //      so a new --server flag doesn't get shadowed by an existing profile.
+  //   2. active credentials profile's `server` field — the steady-state
+  //      path: the profile chosen at login carries the engine URL.
+  //   3. resolvePort(opts) — fallback for pre-login state (`crosstalk
+  //      version` from a fresh install).
+  const profile = getActiveProfile(opts.argv || []);
+
+  let target, url;
+  if (opts.serverOverride) {
+    target = opts.serverOverride;
+    url = remoteApiUrl(opts.serverOverride, path);
+  } else if (profile && profile.server) {
+    target = profile.server;
+    url = remoteApiUrl(profile.server, path);
+  } else {
+    const port = resolvePort(opts);
+    target = port;
+    url = apiUrl(path, port);
+  }
+
+  // v8 uniform-auth: read the CLI's bearer token from the active
+  // credentials profile and send it on every call. If missing, the
+  // engine will 401 with a hint pointing at `crosstalk auth login`.
+  // Callers can pass opts.skipAuth=true to suppress this (used by the
+  // login command itself, which doesn't yet have a token).
+  const headers = {};
+  if (body) headers['Content-Type'] = 'application/json';
+  if (!opts.skipAuth) {
+    const token = readToken(opts.argv || []);
+    if (token) headers['Authorization'] = `Bearer ${token}`;
+  }
   const init = {
     method,
-    headers: body ? { 'Content-Type': 'application/json' } : undefined,
+    headers: Object.keys(headers).length > 0 ? headers : undefined,
     body: body ? JSON.stringify(body) : undefined,
   };
   let res;
   try {
-    res = await fetch(apiUrl(path, port), init);
+    res = await fetch(url, init);
   } catch (err) {
-    throw new ConnectError(port, err.message || String(err));
+    throw new ConnectError(target, err.message || String(err));
   }
   checkSkew(res.headers.get('x-crosstalk-engine-version'));
   return parseJsonOrThrow(res);
@@ -113,7 +160,7 @@ async function call(method, path, body, opts = {}) {
 // either pass argv (auto-resolves name) or an explicit name. Internally
 // 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) {
+export function apiFor(argv, baseOpts = {}) {
   let name;
   try {
     name = parseContainerName(argv);
@@ -121,12 +168,20 @@ export function apiFor(argv) {
     process.stderr.write(`crosstalk: ${err.message}\n`);
     process.exit(1);
   }
+  // argv is threaded into every call so the profile resolver can
+  // honour `--profile <name>` overrides per-invocation. baseOpts is
+  // merged into every call — used by `auth login` to pass
+  // serverOverride when the profile/argv would otherwise route to the
+  // wrong engine.
   return {
     name,
-    get:    (path, opts = {})        => call('GET',    path, undefined, { ...opts, name }),
-    post:   (path, body, opts = {})  => call('POST',   path, body,      { ...opts, name }),
-    patch:  (path, body, opts = {})  => call('PATCH',  path, body,      { ...opts, name }),
-    delete: (path, opts = {})        => call('DELETE', path, undefined, { ...opts, name }),
+    get:    (path, opts = {})        => call('GET',    path, undefined, { ...baseOpts, ...opts, name, argv }),
+    post:   (path, body, opts = {})  => call('POST',   path, body,      { ...baseOpts, ...opts, name, argv }),
+    patch:  (path, body, opts = {})  => call('PATCH',  path, body,      { ...baseOpts, ...opts, name, argv }),
+    delete: (path, opts = {})        => call('DELETE', path, undefined, { ...baseOpts, ...opts, name, argv }),
+    // Unauthenticated variants used by `crosstalk auth login` — it
+    // doesn't have a token yet when calling POST /api/auth/login.
+    postNoAuth: (path, body, opts = {}) => call('POST', path, body, { ...baseOpts, ...opts, name, argv, skipAuth: true }),
   };
 }
 

package/lib/credentials.js

@@ -0,0 +1,207 @@
+// credentials.js — CLI-side persisted credentials (multi-profile).
+//
+// Replaces v7's `auth-token.js` (single-token at cli-token). Stores
+// the active profile + all known profiles in a single JSON file. Each
+// profile carries its own server URL + bearer token, so the same CLI
+// can talk to multiple crosstalk engines (e.g. local loopback +
+// hosted prod).
+//
+// Path: $XDG_CONFIG_HOME/crosstalk/credentials.json, falling back to
+// $HOME/.config/crosstalk/credentials.json. File mode 0600.
+//
+// Shape:
+//   {
+//     "activeProfile": "default",
+//     "profiles": {
+//       "default": {
+//         "server":    "http://127.0.0.1:7000",
+//         "username":  "stevekrisjanovs",
+//         "token":     "sas_<id>.<secret>",
+//         "tokenId":   "<id>",
+//         "createdAt": "2026-06-22T16:54:00Z"
+//       }
+//     }
+//   }
+//
+// Legacy migration: on first read, if a v7-era `cli-token` file exists
+// and `credentials.json` does not, the single token is ingested as the
+// `default` profile (server = loopback default) and the legacy file is
+// removed. Migration is best-effort; if it fails the engine just
+// 401s and the operator re-runs `auth login`.
+
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  unlinkSync,
+  mkdirSync,
+  chmodSync,
+} from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const DEFAULT_LOOPBACK_SERVER = 'http://127.0.0.1:7000';
+
+function configDir() {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+  return join(base, 'crosstalk');
+}
+
+function credentialsPath() {
+  return join(configDir(), 'credentials.json');
+}
+
+function legacyTokenPath() {
+  return join(configDir(), 'cli-token');
+}
+
+function emptyCredentials() {
+  return { activeProfile: null, profiles: {} };
+}
+
+function readJsonOrEmpty(path) {
+  try {
+    const raw = readFileSync(path, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') return emptyCredentials();
+    if (!parsed.profiles || typeof parsed.profiles !== 'object') parsed.profiles = {};
+    return parsed;
+  } catch {
+    return emptyCredentials();
+  }
+}
+
+let migrationAttempted = false;
+function maybeMigrate() {
+  if (migrationAttempted) return;
+  migrationAttempted = true;
+  const credPath = credentialsPath();
+  const legacyPath = legacyTokenPath();
+  if (existsSync(credPath)) return;
+  if (!existsSync(legacyPath)) return;
+  let token;
+  try {
+    token = readFileSync(legacyPath, 'utf-8').trim();
+  } catch {
+    return;
+  }
+  if (!token) return;
+  const cred = emptyCredentials();
+  cred.activeProfile = 'default';
+  cred.profiles.default = {
+    server: DEFAULT_LOOPBACK_SERVER,
+    username: null,
+    token,
+    tokenId: null,
+    createdAt: new Date().toISOString(),
+  };
+  writeCredentials(cred);
+  try { unlinkSync(legacyPath); } catch { /* best-effort */ }
+}
+
+export function readCredentials() {
+  maybeMigrate();
+  return readJsonOrEmpty(credentialsPath());
+}
+
+export function writeCredentials(cred) {
+  const dir = configDir();
+  mkdirSync(dir, { recursive: true });
+  const path = credentialsPath();
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, JSON.stringify(cred, null, 2) + '\n', { mode: 0o600 });
+  try { chmodSync(tmp, 0o600); } catch { /* best-effort */ }
+  renameSync(tmp, path);
+  return path;
+}
+
+export function credentialsFilePath() {
+  return credentialsPath();
+}
+
+function profileNameOverride(argv) {
+  if (!Array.isArray(argv)) return null;
+  for (let i = 0; i < argv.length - 1; i++) {
+    if (argv[i] === '--profile') return argv[i + 1];
+  }
+  return null;
+}
+
+export function getActiveProfileName(argv = []) {
+  const override = profileNameOverride(argv);
+  if (override) return override;
+  const cred = readCredentials();
+  return cred.activeProfile || null;
+}
+
+export function getActiveProfile(argv = []) {
+  const name = getActiveProfileName(argv);
+  if (!name) return null;
+  const cred = readCredentials();
+  return cred.profiles[name] || null;
+}
+
+export function listProfiles() {
+  const cred = readCredentials();
+  return Object.entries(cred.profiles).map(([name, p]) => ({
+    name,
+    server: p.server,
+    username: p.username,
+    tokenId: p.tokenId,
+    active: cred.activeProfile === name,
+  }));
+}
+
+export function setActiveProfile(name) {
+  const cred = readCredentials();
+  if (!cred.profiles[name]) {
+    throw new Error(`profile '${name}' not found`);
+  }
+  cred.activeProfile = name;
+  writeCredentials(cred);
+}
+
+export function saveProfile(name, data) {
+  const cred = readCredentials();
+  cred.profiles[name] = {
+    server: data.server || DEFAULT_LOOPBACK_SERVER,
+    username: data.username ?? null,
+    token: data.token,
+    tokenId: data.tokenId ?? null,
+    createdAt: data.createdAt || new Date().toISOString(),
+  };
+  if (!cred.activeProfile) cred.activeProfile = name;
+  writeCredentials(cred);
+}
+
+export function deleteProfile(name) {
+  const cred = readCredentials();
+  if (!cred.profiles[name]) return false;
+  delete cred.profiles[name];
+  if (cred.activeProfile === name) {
+    const remaining = Object.keys(cred.profiles);
+    cred.activeProfile = remaining.length > 0 ? remaining[0] : null;
+  }
+  writeCredentials(cred);
+  return true;
+}
+
+export function deleteActiveProfile() {
+  const cred = readCredentials();
+  const name = cred.activeProfile;
+  if (!name) return null;
+  delete cred.profiles[name];
+  const remaining = Object.keys(cred.profiles);
+  cred.activeProfile = remaining.length > 0 ? remaining[0] : null;
+  writeCredentials(cred);
+  return name;
+}
+
+// Back-compat wrapper preserved so `lib/api-client.js` can keep its
+// readToken()-shaped call site without knowing about profiles. The
+// active profile drives the token; absent active profile → null.
+export function readToken(argv = []) {
+  const p = getActiveProfile(argv);
+  return p ? p.token : null;
+}

package/lib/nativeServer.js

@@ -0,0 +1,182 @@
+// nativeServer.js — host-process control for the crosstalk engine.
+//
+// v8-native replaces the docker lifecycle. The engine main loop is
+// `crosstalk daemon dispatch …`, spawned as a detached child of the
+// operator's host shell. PID is recorded in crosstalk-state/crosstalk.pid
+// and stdio is redirected to crosstalk-state/crosstalk.log.
+//
+// The daemon is an internal subcommand of the `crosstalk` CLI;
+// startEngine() spawns `process.execPath bin/crosstalk.js daemon dispatch …`
+// against the package's own bin script, resolved relative to this file.
+//
+// Trust + isolation notes:
+//   - User mode (default): engine inherits the operator's $HOME, so
+//     agent CLI OAuth tokens land in ~/.claude, ~/.codex, etc. — the
+//     same places the operator's interactive sessions use. Simpler and
+//     less surprising than the v7 container's CROSSTALK_HOME isolation.
+//   - System mode: engine runs as the `crosstalk` system user (per
+//     systemd unit), with $HOME set to /var/lib/crosstalk so agents
+//     write their state under the service user, not /home/*.
+
+import { spawn } from 'child_process';
+import { openSync, existsSync, writeFileSync, mkdirSync, statSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { storagePaths, apiPortFor, runningPid } from './resolve.js';
+
+const _thisDir = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Resolve the path to this package's own `crosstalk` CLI entrypoint.
+ * The daemon is now `crosstalk daemon dispatch …`, so startEngine
+ * re-invokes the very script that called it — using process.execPath
+ * (the running Node) + this bin path.
+ */
+export function resolveSelfBin() {
+  return resolve(_thisDir, '..', 'bin', 'crosstalk.js');
+}
+
+/**
+ * Start the crosstalk engine (`crosstalk daemon dispatch`) as a detached host process for the given transport.
+ * Returns { ok: true, pid } on success, { ok: false, error } otherwise.
+ *
+ * Behavior:
+ *   - Refuses if already running (use stop/restart instead).
+ *   - Creates the state dir if missing.
+ *   - Opens the log file in append mode; stdin/stdout/stderr all go there.
+ *   - Spawns detached so the parent can exit and the engine keeps running.
+ *   - Verifies the PID is alive after a short delay (~150ms) before returning.
+ */
+export function startEngine(name, opts = {}) {
+  const paths = storagePaths(name);
+  if (runningPid(name)) {
+    return { ok: false, error: `'${name}' is already running (pid ${runningPid(name)})` };
+  }
+
+  const selfBin = resolveSelfBin();
+  if (!existsSync(selfBin)) {
+    return {
+      ok: false,
+      error: `crosstalk CLI entry missing at ${selfBin} — package install looks broken`,
+    };
+  }
+
+  mkdirSync(paths.crosstalkState, { recursive: true });
+
+  const alias = opts.alias ?? process.env.CROSSTALK_ALIAS ?? name;
+  const poll = String(opts.pollSeconds ?? process.env.DISPATCH_POLL_SECONDS ?? 30);
+  const port = String(apiPortFor(name));
+
+  // --path: the transport lives at an arbitrary directory (e.g. a mounted
+  // share). Point the engine there via CROSSTALK_TRANSPORT_PATH, and pin
+  // state machine-local (by name) so cursor/heartbeat never land on the
+  // share — each machine sharing the dir keeps its own local state.
+  const transportDir = opts.transportPath ? resolve(opts.transportPath) : paths.transportDir;
+  const env = {
+    ...process.env,
+    CROSSTALK_API_PORT: port,
+    TRANSPORT_DIR: transportDir,
+  };
+  if (opts.transportPath) {
+    env.CROSSTALK_TRANSPORT_PATH = transportDir;
+    env.CROSSTALK_STATE_DIR = paths.crosstalkState;
+  }
+
+  const logFd = openSync(paths.logFile, 'a');
+  const child = spawn(
+    process.execPath,
+    [selfBin, 'daemon', 'dispatch', '--alias', alias, '--poll', poll, '--json'],
+    {
+      cwd: transportDir,
+      env,
+      stdio: ['ignore', logFd, logFd],
+      detached: true,
+    },
+  );
+  if (!child.pid) {
+    return { ok: false, error: 'spawn failed to allocate a pid' };
+  }
+  writeFileSync(paths.pidFile, String(child.pid) + '\n');
+  child.unref(); // let parent exit without waiting on the child
+
+  // Brief verify the child didn't die immediately (missing transport
+  // dir, broken tsx resolution, etc.). 150ms is enough to catch
+  // immediate ENOENT-class failures without making `server start`
+  // feel sluggish.
+  const start = Date.now();
+  while (Date.now() - start < 150) {
+    try { process.kill(child.pid, 0); } catch {
+      return { ok: false, error: 'engine exited immediately — check logs at ' + paths.logFile };
+    }
+  }
+  return { ok: true, pid: child.pid, logFile: paths.logFile, port: Number(port) };
+}
+
+/**
+ * Stop a running crosstalk engine. SIGTERM first, then SIGKILL after a grace
+ * period (default 5s). Returns { ok, wasRunning, killed? }.
+ *
+ * `killed: true` indicates SIGKILL was required (clean shutdown failed).
+ */
+export function stopEngine(name, opts = {}) {
+  const paths = storagePaths(name);
+  const pid = runningPid(name);
+  if (!pid) {
+    // No running engine; mop up any stale pid file and report idempotent success.
+    if (existsSync(paths.pidFile)) {
+      try { writeFileSync(paths.pidFile, ''); } catch { /* best effort */ }
+    }
+    return { ok: true, wasRunning: false };
+  }
+
+  const graceMs = (opts.graceSeconds ?? 5) * 1000;
+  try { process.kill(pid, 'SIGTERM'); } catch { /* already gone */ }
+
+  const deadline = Date.now() + graceMs;
+  let killed = false;
+  while (Date.now() < deadline) {
+    try { process.kill(pid, 0); } catch {
+      // Process is gone — clean exit.
+      try { writeFileSync(paths.pidFile, ''); } catch {}
+      return { ok: true, wasRunning: true, pid };
+    }
+    // Tight spin — 50ms granularity is fine for a 5s window.
+    const until = Date.now() + 50;
+    while (Date.now() < until) { /* idle */ }
+  }
+  // Timed out. Hard-kill.
+  try { process.kill(pid, 'SIGKILL'); killed = true; } catch { /* race: gone */ }
+  try { writeFileSync(paths.pidFile, ''); } catch {}
+  return { ok: true, wasRunning: true, pid, killed };
+}
+
+/**
+ * Snapshot the engine's status for the given transport. Returns
+ * { running, pid?, port?, uptimeSeconds?, apiReachable? }.
+ *
+ * apiReachable requires an HTTP probe; pass { probeApi: true } to opt in.
+ */
+export async function engineStatus(name, opts = {}) {
+  const paths = storagePaths(name);
+  const pid = runningPid(name);
+  if (!pid) return { running: false };
+
+  let uptimeSeconds;
+  try {
+    const stat = statSync(`/proc/${pid}/stat`);
+    uptimeSeconds = Math.round((Date.now() - stat.ctimeMs) / 1000);
+  } catch { /* /proc not available on macOS — leave undefined */ }
+
+  const port = apiPortFor(name);
+  const out = { running: true, pid, port, ...(uptimeSeconds !== undefined ? { uptimeSeconds } : {}) };
+
+  if (opts.probeApi) {
+    try {
+      const resp = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: AbortSignal.timeout(2000) });
+      out.apiReachable = resp.ok;
+    } catch {
+      out.apiReachable = false;
+    }
+  }
+  return out;
+}