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

package/commands/workflow.js

@@ -0,0 +1,234 @@
+// crosstalk workflow <compose|run|status> — multi-step workflow ops.
+//
+//   compose <prompt>  Interactive: engine compiles the prompt into a
+//                     workflow plan, prints the YAML for review, then
+//                     submits it. Operator can edit before submit.
+//   run <file>        Submit an already-authored workflow YAML file
+//                     (replaces v7's `crosstalk run --type workflow`).
+//   status [--id <id>] Snapshot in-flight workflows (parent channel,
+//                     phase, fanout state, completion). Without --id
+//                     lists every workflow on the transport.
+
+import { readFileSync, writeFileSync, existsSync, mkdtempSync, unlinkSync } from 'fs';
+import { spawnSync } from 'child_process';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { apiFor } from '../lib/api-client.js';
+import { reportAndExit } from '../lib/errors.js';
+import { flag, has, positionals } from '../lib/argv.js';
+
+function usage(exit = 0) {
+  const w = exit === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage:
+  crosstalk workflow compose <prompt>   [--channel <name|uuid>] [--compiler <model>]
+  crosstalk workflow run <file>         [--channel <name|uuid>] [--from <name>]
+  crosstalk workflow status [--id <childUuid>]
+`,
+  );
+  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);
+  const rest = argv.slice(1);
+
+  if (sub === 'compose') return await runCompose(rest);
+  if (sub === 'run')     return await runRun(rest);
+  if (sub === 'status')  return await runStatus(rest);
+
+  process.stderr.write(`crosstalk workflow: unknown subcommand '${sub}'.\n`);
+  usage(1);
+}
+
+function promptLine(label) {
+  return new Promise((resolve) => {
+    process.stdout.write(label);
+    const stdin = process.stdin;
+    stdin.setEncoding('utf-8');
+    stdin.resume();
+    let buf = '';
+    const onData = (chunk) => {
+      buf += chunk;
+      const nl = buf.indexOf('\n');
+      if (nl !== -1) {
+        stdin.removeListener('data', onData);
+        stdin.pause();
+        resolve(buf.slice(0, nl).replace(/\r$/, ''));
+      }
+    };
+    stdin.on('data', onData);
+  });
+}
+
+function editInEditor(initial) {
+  // Resolve editor: $VISUAL → $EDITOR → vi (POSIX default). Returns the
+  // edited contents, or null if the operator quit without saving.
+  const editor = process.env.VISUAL || process.env.EDITOR || 'vi';
+  const tmp = join(mkdtempSync(join(tmpdir(), 'crosstalk-wf-')), 'workflow.yaml');
+  writeFileSync(tmp, initial);
+  const r = spawnSync(editor, [tmp], { stdio: 'inherit' });
+  if (r.status !== 0) {
+    try { unlinkSync(tmp); } catch { /* best-effort */ }
+    return null;
+  }
+  let edited;
+  try { edited = readFileSync(tmp, 'utf-8'); } catch { edited = null; }
+  try { unlinkSync(tmp); } catch { /* best-effort */ }
+  return edited;
+}
+
+async function runCompose(argv) {
+  const pos = positionals(argv, [
+    '--channel', '--compiler', '--containername', '-c',
+    '--profile', '--server',
+  ]);
+  const prompt = pos.join(' ').trim();
+  if (!prompt) {
+    process.stderr.write('crosstalk workflow compose: <prompt> required.\n');
+    return 1;
+  }
+
+  const api = apiFor(argv);
+  const compilerAgent = flag(argv, '--compiler');
+  const channel = flag(argv, '--channel');
+
+  process.stderr.write('compiling workflow plan...\n');
+  let composed;
+  try {
+    composed = await api.post('/api/workflows/compose', {
+      prompt,
+      ...(compilerAgent ? { compilerAgent } : {}),
+    });
+  } catch (err) {
+    reportAndExit(err, 'crosstalk workflow compose');
+  }
+
+  let yaml = composed.yaml;
+  process.stdout.write(`\n--- compiled plan (via ${composed.compiler}) ---\n${yaml}\n--- end plan ---\n\n`);
+
+  while (true) {
+    const choice = (await promptLine('Submit? [y]es / [e]dit / [n]o: ')).trim().toLowerCase() || 'n';
+    if (choice === 'n' || choice === 'no') {
+      process.stdout.write('aborted.\n');
+      return 0;
+    }
+    if (choice === 'e' || choice === 'edit') {
+      const edited = editInEditor(yaml);
+      if (edited == null) {
+        process.stderr.write('editor exited non-zero; keeping original yaml.\n');
+        continue;
+      }
+      yaml = edited;
+      process.stdout.write(`\n--- edited plan ---\n${yaml}\n--- end plan ---\n\n`);
+      continue;
+    }
+    if (choice === 'y' || choice === 'yes') break;
+  }
+
+  let submitted;
+  try {
+    submitted = await api.post('/api/workflows/submit', {
+      yaml,
+      ...(channel ? { channel } : {}),
+      prompt,
+    });
+  } catch (err) {
+    reportAndExit(err, 'crosstalk workflow compose (submit)');
+  }
+  if (submitted.relPath) {
+    process.stdout.write(`Workflow dispatched: ${submitted.relPath}\n`);
+  }
+  if (submitted.childChannel) {
+    process.stdout.write(`Child channel: ${submitted.childChannel.slice(0, 8)} (parent: ${(submitted.channel || '').slice(0, 8)})\n`);
+  }
+  return 0;
+}
+
+async function runRun(argv) {
+  const pos = positionals(argv, [
+    '--channel', '--from', '--containername', '-c',
+    '--profile', '--server',
+  ]);
+  const file = pos[0];
+  if (!file) {
+    process.stderr.write('crosstalk workflow run: <file> required.\n');
+    return 1;
+  }
+  if (!existsSync(file)) {
+    process.stderr.write(`crosstalk workflow run: file not found — ${file}\n`);
+    return 1;
+  }
+  const body = readFileSync(file, 'utf-8');
+  if (body.length === 0) {
+    process.stderr.write('crosstalk workflow run: file is empty.\n');
+    return 1;
+  }
+
+  const api = apiFor(argv);
+  const payload = {
+    type: 'workflow',
+    channel: flag(argv, '--channel'),
+    from: flag(argv, '--from') ?? process.env.USER ?? 'operator',
+    body,
+  };
+  let resp;
+  try {
+    resp = await api.post('/messages', payload);
+  } catch (err) {
+    reportAndExit(err, 'crosstalk workflow run');
+  }
+  process.stdout.write(`Workflow dispatched: ${resp.relPath}\n`);
+  process.stdout.write(`Child channel: ${(resp.childChannel || '').slice(0, 8)} (parent: ${(resp.channel || '').slice(0, 8)})\n`);
+  return 0;
+}
+
+async function runStatus(argv) {
+  const api = apiFor(argv);
+  const id = flag(argv, '--id');
+  if (id) {
+    let r;
+    try { r = await api.get(`/api/workflows/${encodeURIComponent(id)}`); }
+    catch (err) { reportAndExit(err, 'crosstalk workflow status'); }
+    printDetail(r);
+    return 0;
+  }
+  let r;
+  try { r = await api.get('/api/workflows'); }
+  catch (err) { reportAndExit(err, 'crosstalk workflow status'); }
+  const list = r.workflows || [];
+  if (list.length === 0) {
+    process.stdout.write('(no workflows on this transport)\n');
+    return 0;
+  }
+  for (const w of list) printSummaryLine(w);
+  return 0;
+}
+
+function printSummaryLine(w) {
+  const id = (w.childUuid || '').slice(0, 8);
+  const parent = (w.parentName || (w.parentUuid || '').slice(0, 8) || '-');
+  const phase = w.phase || (w.isComplete ? 'complete' : 'in-flight');
+  const fan = w.fanoutDispatched != null
+    ? `${w.fanoutReplied}/${w.fanoutDispatched} replies`
+    : '';
+  process.stdout.write(`  ${id}  ${parent.padEnd(20)}  ${phase.padEnd(12)}  ${fan}\n`);
+}
+
+function printDetail(d) {
+  if (!d) {
+    process.stdout.write('(no detail)\n');
+    return;
+  }
+  const lines = [];
+  if (d.childUuid)      lines.push(`uuid:    ${d.childUuid}`);
+  if (d.parentUuid)     lines.push(`parent:  ${d.parentUuid}`);
+  if (d.markerRelPath)  lines.push(`marker:  ${d.markerRelPath}`);
+  if (d.phase)          lines.push(`phase:   ${d.phase}`);
+  if (d.fanoutDispatched != null) lines.push(`fanout:  ${d.fanoutReplied}/${d.fanoutDispatched} replies`);
+  if (d.synthesizeStatus) lines.push(`synth:   ${d.synthesizeStatus}`);
+  if (d.isComplete != null) lines.push(`complete: ${d.isComplete}`);
+  process.stdout.write(lines.join('\n') + '\n');
+}

package/deploy/crosstalk@.service

@@ -0,0 +1,62 @@
+# crosstalk@<transport>.service — systemd template for v8-native system mode.
+#
+# Install:
+#   sudo deploy/install.sh
+#   sudo systemctl daemon-reload
+#   sudo systemctl enable --now crosstalk@main
+#
+# Instances: one per named transport. The instance name (the `<name>` in
+# `crosstalk@<name>`) becomes the storage subdirectory under /var/lib/
+# crosstalk and the dispatcher alias the engine boots with.
+#
+# alpha.18 monorepo: the daemon is now an internal subcommand of the
+# same `crosstalk` CLI — `crosstalk daemon dispatch …` replaces the
+# dropped `crosstalkd` bin.
+#
+# Prereqs (handled by deploy/install.sh):
+#   - 'crosstalk' system user + group exist
+#   - /var/lib/crosstalk/<name>/ exists (crosstalk:crosstalk 0750)
+#   - /var/log/crosstalk/ exists (crosstalk:crosstalk 0750)
+#   - The transport for <name> has been initialized via
+#     `sudo -u crosstalk crosstalk transport init --containername <name>`
+
+[Unit]
+Description=crosstalk engine (transport: %i)
+Documentation=https://github.com/cordfuse/crosstalk
+After=network.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=crosstalk
+Group=crosstalk
+Environment=CROSSTALK_USER_MODE=
+Environment=DISPATCH_POLL_SECONDS=30
+Environment=DISPATCH_JSON=true
+WorkingDirectory=/var/lib/crosstalk/%i/transport
+ExecStart=/usr/bin/crosstalk daemon dispatch --alias %i --poll ${DISPATCH_POLL_SECONDS} --json
+Restart=on-failure
+RestartSec=5
+StandardOutput=append:/var/log/crosstalk/%i.log
+StandardError=append:/var/log/crosstalk/%i.log
+
+# Hardening — daemon needs nothing outside its own state + transport dirs.
+# Mirrors @cordfuse/llmux v2's llmuxd.service profile.
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/var/lib/crosstalk /var/log/crosstalk
+PrivateTmp=true
+PrivateDevices=true
+ProtectKernelTunables=true
+ProtectKernelModules=true
+ProtectControlGroups=true
+RestrictSUIDSGID=true
+RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
+SystemCallFilter=@system-service
+SystemCallErrorNumber=EPERM
+LimitNOFILE=65536
+CapabilityBoundingSet=
+
+[Install]
+WantedBy=multi-user.target

package/deploy/install.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# crosstalk v8-native system-mode install.
+#
+# Run as root. Sets up the `crosstalk` system user + group, /etc + /var
+# directories, the systemd template unit, and points operators at the
+# next step (initializing a transport + enabling its instance).
+#
+# Mirrors the @cordfuse/llmux v2 install pattern so Cordfuse family
+# deployments use the same shape: npm-install the binary globally,
+# run this script to set up the OS-level scaffolding, then enable
+# the systemd unit instance per named transport.
+
+set -euo pipefail
+
+# ─── prerequisite checks ─────────────────────────────────────────────────
+if [ "${EUID:-$(id -u)}" -ne 0 ]; then
+  echo "error: this installer must run as root" >&2
+  exit 1
+fi
+if ! command -v systemctl >/dev/null 2>&1; then
+  echo "error: systemd not detected. v8-native system mode currently requires systemd." >&2
+  echo "       For non-systemd hosts, run user mode: CROSSTALK_USER_MODE=1 crosstalk server start" >&2
+  exit 1
+fi
+if ! command -v crosstalk >/dev/null 2>&1; then
+  echo "error: crosstalk binary not on PATH." >&2
+  echo "       Install first: npm install -g @cordfuse/crosstalk" >&2
+  exit 1
+fi
+
+# ─── service user + group ────────────────────────────────────────────────
+if ! getent group crosstalk >/dev/null; then
+  groupadd --system crosstalk
+  echo "created group: crosstalk"
+fi
+if ! id crosstalk >/dev/null 2>&1; then
+  # --home-dir /var/lib/crosstalk: agent CLI auth tokens (~/.claude/,
+  # ~/.codex/, ~/.gemini/) live under the service user's home. Daemon
+  # never reaches into /home/* — same $HOME-principle as llmux v2.
+  useradd --system --gid crosstalk --home-dir /var/lib/crosstalk \
+          --shell /usr/sbin/nologin --comment "crosstalk engine daemon" crosstalk
+  echo "created user: crosstalk"
+fi
+
+# ─── directories ─────────────────────────────────────────────────────────
+install -d -o root      -g crosstalk -m 0750 /etc/crosstalk
+install -d -o crosstalk -g crosstalk -m 0750 /var/lib/crosstalk
+install -d -o crosstalk -g crosstalk -m 0750 /var/log/crosstalk
+# Per-transport state dirs (e.g., /var/lib/crosstalk/main/) are created on
+# first `crosstalk transport init --containername <name>` run by the
+# service user.
+
+# ─── systemd unit ────────────────────────────────────────────────────────
+SOURCE_DIR="$(cd "$(dirname "$0")" && pwd)"
+install -o root -g root -m 0644 \
+  "$SOURCE_DIR/crosstalk@.service" \
+  /etc/systemd/system/crosstalk@.service
+
+systemctl daemon-reload
+echo "installed: /etc/systemd/system/crosstalk@.service"
+
+# ─── next steps ──────────────────────────────────────────────────────────
+cat <<'EOF'
+
+crosstalk v8-native system-mode install complete.
+
+Initialize a transport (system mode is the default now; no env var needed):
+
+  sudo -u crosstalk crosstalk transport init --containername main
+
+Then enable + start the systemd instance for it:
+
+  sudo systemctl enable --now crosstalk@main
+  sudo systemctl status crosstalk@main
+  sudo journalctl -u crosstalk@main -f      # or: tail -f /var/log/crosstalk/main.log
+
+To run additional named transports, repeat with a different name:
+
+  sudo -u crosstalk crosstalk transport init --containername staging
+  sudo systemctl enable --now crosstalk@staging
+
+EOF

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 }),
   };
 }