@cordfuse/crosstalk 6.0.0-alpha.9 → 7.0.0-alpha.10

package/src/activation.ts

@@ -1,104 +0,0 @@
-// The activation rule — pure functions, no I/O, exhaustively unit-tested.
-//
-// One rule (CROSSTALK.md "Activation"):
-//
-//   A message wakes its addressee if it has no `re:` (a new task), or its
-//   `re:` points at a message the addressee sent.
-//
-// `re:` is written by the runtime at send time, never inferred at read
-// time. It is a string or a list: a reply that answers a batch of N
-// messages records ALL N relPaths, so no answered message is ever lost to
-// batching.
-
-export interface ActivationMessage {
-  from: string;
-  to: string[];
-  re?: string | string[];
-}
-
-export function recipients(toField: unknown): string[] {
-  if (Array.isArray(toField)) return toField.map(String);
-  if (typeof toField === 'string') return [toField];
-  return [];
-}
-
-export function reList(reField: unknown): string[] {
-  if (Array.isArray(reField)) return reField.map(String);
-  if (typeof reField === 'string') return [reField];
-  return [];
-}
-
-// A recipient is `actor` or `actor@host`.
-export function extractActor(recipient: string): string {
-  const at = recipient.indexOf('@');
-  return at === -1 ? recipient : recipient.slice(0, at);
-}
-
-export function targetHost(recipient: string): string | null {
-  const at = recipient.indexOf('@');
-  return at === -1 ? null : recipient.slice(at + 1);
-}
-
-export interface RoutingResult {
-  addressed: boolean;
-  // Actor was named, but every instance targeted a different host — logged
-  // by the dispatcher so wrong-host routes are visible, never silent.
-  wrongHost: boolean;
-}
-
-export function matchRouting(
-  recipientList: string[],
-  actorName: string,
-  thisHost: string,
-): RoutingResult {
-  let actorNamedAtAll = false;
-  for (const r of recipientList) {
-    if (r === 'all') return { addressed: true, wrongHost: false };
-    if (extractActor(r) !== actorName) continue;
-    actorNamedAtAll = true;
-    const host = targetHost(r);
-    if (host === null || host === thisHost) return { addressed: true, wrongHost: false };
-  }
-  return { addressed: false, wrongHost: actorNamedAtAll };
-}
-
-export type WakeDecision = 'wake' | 'skip' | 'wrong-host';
-
-// `senderOf` resolves a channel relPath to the `from:` of the message there,
-// or undefined if no such message exists. A dangling `re:` entry (target
-// missing) wakes the addressee — fail open so a message is never silently
-// dropped; no loop is possible because the reply to it carries a
-// resolvable `re:`.
-export function decideWake(
-  msg: ActivationMessage,
-  actorName: string,
-  thisHost: string,
-  senderOf: (relPath: string) => string | undefined,
-): WakeDecision {
-  const routing = matchRouting(msg.to, actorName, thisHost);
-  if (!routing.addressed) return routing.wrongHost ? 'wrong-host' : 'skip';
-  if (msg.from === actorName) return 'skip';
-  const targets = reList(msg.re);
-  if (targets.length === 0) return 'wake';
-  for (const target of targets) {
-    const asker = senderOf(target);
-    if (asker === undefined || asker === actorName) return 'wake';
-  }
-  return 'skip';
-}
-
-// Split a channel's pending messages (already sorted by relPath) into
-// contiguous batches sized for the actor's concurrency. Contiguous so each
-// batch's highest relPath is monotone across batches — the cursor advances
-// safely per batch. When pending fits within concurrency, every batch is a
-// single message (parallel fan-out); when it exceeds, batches collapse into
-// ~concurrency invocations (fan-in stays O(1) per actor).
-export function splitForConcurrency<T>(msgs: T[], concurrency: number): T[][] {
-  if (concurrency <= 1 || msgs.length <= 1) return [msgs];
-  const chunkSize = Math.max(1, Math.ceil(msgs.length / concurrency));
-  const out: T[][] = [];
-  for (let i = 0; i < msgs.length; i += chunkSize) {
-    out.push(msgs.slice(i, i + chunkSize));
-  }
-  return out;
-}

package/src/actor.ts

@@ -1,131 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
-import { hostname as osHostname, platform } from 'os';
-import { spawnSync } from 'child_process';
-import { parseFrontmatter } from './frontmatter.js';
-
-// Collect the names this machine might be known by. On macOS, the kernel
-// hostname (`os.hostname()`) drifts with DHCP/VPN/Tailscale when the static
-// HostName is unset — `scutil --get LocalHostName` is the stable Bonjour
-// name (e.g. `Steves-MacBook-Air`), and host files commonly use the `.local`
-// form. Trying all variants makes auto-detect deterministic across network
-// state without forcing every Mac operator to pin `--host`.
-function candidateHostNames(): string[] {
-  const names = new Set<string>();
-  names.add(osHostname());
-  if (platform() === 'darwin') {
-    const r = spawnSync('scutil', ['--get', 'LocalHostName'], { encoding: 'utf-8' });
-    if (r.status === 0) {
-      const local = r.stdout.trim();
-      if (local) {
-        names.add(local);
-        names.add(`${local}.local`);
-      }
-    }
-  }
-  return [...names];
-}
-
-export interface HostActorTier {
-  cli: string;
-  count?: number;
-  systemPromptFile?: string;
-}
-
-export type HostActorTiers = Record<string, HostActorTier | string>;
-
-export interface HostFile {
-  alias: string;
-  hostname?: string;
-  actors: Record<string, HostActorTiers>;
-}
-
-export interface ActorProfile {
-  name: string;
-  systemPrompt: string;
-}
-
-export function findHostFile(transportRoot: string, override?: string): HostFile {
-  const dir = join(transportRoot, 'hosts');
-  if (!existsSync(dir)) {
-    throw new Error(`No host directory at ${dir}`);
-  }
-  const files = readdirSync(dir).filter((f) => f.endsWith('.md'));
-  if (files.length === 0) {
-    throw new Error(`No host files in ${dir}`);
-  }
-  if (override) {
-    const target = files.find((f) => f.replace(/\.md$/, '') === override);
-    if (!target) throw new Error(`Host file '${override}' not found in ${dir}`);
-    return parseHostFile(join(dir, target));
-  }
-  const names = candidateHostNames();
-  for (const f of files) {
-    const parsed = parseHostFile(join(dir, f));
-    for (const n of names) {
-      if (parsed.hostname === n || parsed.alias === n) return parsed;
-    }
-  }
-  throw new Error(
-    `No host file matches any of [${names.join(', ')}] in ${dir}. ` +
-      `Pass --host <alias> to override.`,
-  );
-}
-
-function parseHostFile(path: string): HostFile {
-  const raw = readFileSync(path, 'utf-8');
-  const { data } = parseFrontmatter<HostFile>(raw);
-  if (!data.alias) throw new Error(`Host file ${path} missing 'alias' field`);
-  if (!data.actors) throw new Error(`Host file ${path} missing 'actors' field`);
-  return data;
-}
-
-export function loadActorProfile(transportRoot: string, name: string): ActorProfile {
-  const candidates = [
-    join(transportRoot, 'local', 'actors', `${name}.md`),
-    join(transportRoot, 'upstream', 'actors', `${name}.md`),
-  ];
-  const path = candidates.find((p) => existsSync(p));
-  if (!path) {
-    throw new Error(
-      `Actor profile not found for '${name}'. Looked in:\n  ${candidates.join('\n  ')}`,
-    );
-  }
-  const raw = readFileSync(path, 'utf-8');
-  const { body } = parseFrontmatter(raw);
-  return { name, systemPrompt: body.trim() };
-}
-
-// Quote-aware tokenizer for CLI strings. Splits on whitespace but treats
-// "double-quoted" and 'single-quoted' segments as single tokens. Adequate
-// for `bash -c "cmd; cmd"` and similar; does not implement shell escape
-// sequences (operators who need those can use cli as a string[] in YAML
-// once we support that, or write a wrapper script).
-export function tokenizeCli(cli: string): string[] {
-  const tokens: string[] = [];
-  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(cli)) !== null) {
-    const tok = m[1] ?? m[2] ?? m[3] ?? '';
-    tokens.push(tok);
-  }
-  return tokens;
-}
-
-export function pickTier(
-  tiers: HostActorTiers,
-  preferred?: string,
-): { tier: string; cli: string } {
-  if (preferred && tiers[preferred] !== undefined) {
-    const value = tiers[preferred];
-    const cli = typeof value === 'string' ? value : value.cli;
-    if (cli) return { tier: preferred, cli };
-    // declared but cli missing — fall through to first-tier fallback
-  }
-  const entries = Object.entries(tiers);
-  if (entries.length === 0) throw new Error('No tiers defined for actor');
-  const [tier, value] = entries[0];
-  const cli = typeof value === 'string' ? value : value.cli;
-  if (!cli) throw new Error(`Tier '${tier}' has no cli command`);
-  return { tier, cli };
-}

package/src/attach.ts

@@ -1,118 +0,0 @@
-// crosstalk attach — pty-wrap an agent CLI in operator mode
-//
-// Spawns the operator's preferred agent CLI inside a pseudo-terminal,
-// preloading OPERATOR.md as system context so the agent acts as the
-// operator's natural-language interface to this Crosstalk transport.
-//
-// The CLI thinks it's running natively — its TUI features (slash commands,
-// autocompletion, syntax highlighting) all work because it has a real
-// (virtual) terminal underneath. The wrapper just forwards bytes both ways
-// and handles terminal resize.
-//
-// Usage:
-//   crosstalk attach
-//   CROSSTALK_OPERATOR_CLI="claude --append-system-prompt" crosstalk attach
-//   CROSSTALK_OPERATOR_CLI="gemini -i" crosstalk attach
-//   CROSSTALK_OPERATOR_CLI="agy -i" crosstalk attach
-//
-// CROSSTALK_OPERATOR_CLI is the full agent invocation including the
-// system-prompt-equivalent flag. OPERATOR.md content is appended as the
-// final argument. Defaults to `claude --append-system-prompt`.
-
-import { existsSync, readFileSync } from 'fs';
-import { resolve, join } from 'path';
-import { spawn as ptySpawn } from '@lydell/node-pty';
-import { tokenizeCli } from './actor.js';
-
-const transportRoot = resolve(process.cwd());
-const operatorMdPath = join(transportRoot, 'upstream', 'OPERATOR.md');
-
-if (!existsSync(operatorMdPath)) {
-  console.error(`crosstalk attach: OPERATOR.md not found at ${operatorMdPath}`);
-  console.error(`This tool requires upstream/OPERATOR.md to be present.`);
-  process.exit(1);
-}
-
-const operatorContent = readFileSync(operatorMdPath, 'utf-8').trim();
-const cliCommand = process.env['CROSSTALK_OPERATOR_CLI'] ?? 'claude --append-system-prompt';
-const parts = tokenizeCli(cliCommand);
-
-if (parts.length === 0) {
-  console.error('crosstalk attach: CROSSTALK_OPERATOR_CLI is empty');
-  process.exit(1);
-}
-
-const [bin, ...flagArgs] = parts;
-const args = [...flagArgs, operatorContent];
-
-const cols = process.stdout.columns ?? 80;
-const rows = process.stdout.rows ?? 24;
-
-process.stdout.write(`crosstalk: attaching to ${bin} (operator mode)\n`);
-
-let term;
-try {
-  term = ptySpawn(bin!, args, {
-    name: process.env['TERM'] ?? 'xterm-256color',
-    cols,
-    rows,
-    cwd: transportRoot,
-    env: process.env as Record<string, string>,
-  });
-} catch (err) {
-  console.error(
-    `crosstalk attach: failed to launch '${bin}': ${(err as Error).message}`,
-  );
-  console.error(
-    `Check that '${bin}' is installed and on your PATH. Override with` +
-      ` CROSSTALK_OPERATOR_CLI to use a different CLI.`,
-  );
-  process.exit(1);
-}
-
-const startedAt = Date.now();
-let turnCount = 0;
-
-if (process.stdin.isTTY) {
-  process.stdin.setRawMode(true);
-}
-process.stdin.resume();
-
-process.stdin.on('data', (data) => {
-  term.write(data.toString());
-  if (data.includes(0x0d) || data.includes(0x0a)) turnCount++;
-});
-
-term.onData((data) => {
-  process.stdout.write(data);
-});
-
-const handleResize = () => {
-  try {
-    term.resize(process.stdout.columns ?? cols, process.stdout.rows ?? rows);
-  } catch {
-    /* term may have exited */
-  }
-};
-process.stdout.on('resize', handleResize);
-
-const cleanup = (exitCode: number) => {
-  if (process.stdin.isTTY) {
-    try { process.stdin.setRawMode(false); } catch { /* ignore */ }
-  }
-  process.stdin.pause();
-  const seconds = ((Date.now() - startedAt) / 1000).toFixed(1);
-  process.stdout.write(
-    `\ncrosstalk: session ended (${turnCount} turns, ${seconds}s active)\n`,
-  );
-  process.exit(exitCode);
-};
-
-term.onExit(({ exitCode }) => cleanup(exitCode ?? 0));
-
-const forwardSignal = (sig: 'SIGINT' | 'SIGTERM' | 'SIGHUP') => {
-  try { term.kill(sig); } catch { /* term may already be gone */ }
-};
-process.on('SIGINT', () => forwardSignal('SIGINT'));
-process.on('SIGTERM', () => forwardSignal('SIGTERM'));
-process.on('SIGHUP', () => forwardSignal('SIGHUP'));

package/src/channel.ts

@@ -1,49 +0,0 @@
-// crosstalk channel — create a new channel directory with its CHANNEL.md.
-
-import { mkdirSync, writeFileSync, existsSync } from 'fs';
-import { resolve, join } from 'path';
-import { randomUUID } from 'crypto';
-import { serializeFrontmatter } from './frontmatter.js';
-
-const transportRoot = resolve(process.cwd());
-const argv = process.argv.slice(2);
-
-function flag(name: string): string | undefined {
-  const i = argv.indexOf(name);
-  if (i === -1 || i === argv.length - 1) return undefined;
-  return argv[i + 1];
-}
-
-const name = flag('--name');
-const parent = flag('--parent');
-const createdBy = flag('--created-by') ?? process.env['USER'] ?? 'operator';
-
-if (!name) {
-  console.error('Usage: crosstalk channel --name <name> [--parent <parent-uuid>] [--created-by <name>]');
-  process.exit(1);
-}
-
-const uuid = randomUUID();
-const dir = join(transportRoot, 'data', 'channels', uuid);
-
-if (existsSync(dir)) {
-  console.error(`Directory already exists: ${dir}`);
-  process.exit(1);
-}
-
-mkdirSync(dir, { recursive: true });
-
-const frontmatter: Record<string, unknown> = {
-  name,
-  created_by: createdBy,
-  created_at: new Date().toISOString(),
-};
-if (parent) frontmatter['parent'] = parent;
-
-const body = `# ${name}\n\n${parent ? `Subchannel of \`${parent}\`.` : 'Channel description goes here.'}\n`;
-writeFileSync(join(dir, 'CHANNEL.md'), serializeFrontmatter(frontmatter, body));
-
-console.log(`Created channel: ${uuid}`);
-console.log(`  name: ${name}`);
-if (parent) console.log(`  parent: ${parent}`);
-console.log(`  path: data/channels/${uuid}/CHANNEL.md`);

package/src/chat.ts

@@ -1,142 +0,0 @@
-// crosstalk chat — participate in a channel as a human, without invoking
-// any agent CLI locally. Sends messages by writing + committing + pushing
-// to the channel; polls for the reply whose re: points back at the sent
-// message; displays it.
-//
-// Use this when a dispatcher (local daemon, deployed crosstalk-server,
-// a peer's machine) is running against the transport and you want to chat
-// with the dispatched actors from a clean local clone. No agent CLI
-// needed locally, no auth.
-//
-// Difference from `open`:
-//   - `open` spawns the actor's CLI LOCALLY — needs claude/etc. installed,
-//     needs auth, doesn't use any remote dispatcher.
-//   - `chat` just produces messages and waits for the channel to fill in
-//     replies. Whatever's processing the channel handles the work.
-//
-// Usage:
-//   crosstalk chat --channel <uuid> --to <actor> [--as <name>] [--tier <name>]
-//   crosstalk chat --channel <uuid> --to concierge --as steve
-
-import { resolve, join } from 'path';
-import { mkdirSync, writeFileSync } from 'fs';
-import { createInterface } from 'readline/promises';
-import { now, messageFilename } from './filenames.js';
-import { serializeFrontmatter } from './frontmatter.js';
-import { gitPull, gitCommitAndPush, listChannelMessages, ChannelMessage } from './transport.js';
-import { reList } from './activation.js';
-import { withLock } from './turnq.js';
-import { sendWakeSignal } from './state.js';
-
-const transportRoot = resolve(process.cwd());
-const argv = process.argv.slice(2);
-
-function flag(name: string): string | undefined {
-  const i = argv.indexOf(name);
-  if (i === -1 || i === argv.length - 1) return undefined;
-  return argv[i + 1];
-}
-
-const channelUuid = flag('--channel');
-const toActor = flag('--to');
-const fromName = flag('--as') ?? process.env['USER'] ?? 'operator';
-const tier = flag('--tier');
-const pollSeconds = Number(flag('--poll')) || 5;
-const replyTimeoutSeconds = Number(flag('--timeout')) || 600;
-
-if (!channelUuid || !toActor) {
-  console.error(
-    'Usage: crosstalk chat --channel <uuid> --to <actor> [--as <name>] [--tier <name>] [--poll <seconds>] [--timeout <seconds>]',
-  );
-  process.exit(1);
-}
-
-async function sendMessage(body: string): Promise<string> {
-  const ts = now();
-  const dir = join(transportRoot, 'data', 'channels', channelUuid!, ts.pathDate);
-  mkdirSync(dir, { recursive: true });
-  const frontmatter: Record<string, unknown> = {
-    from: fromName,
-    to: toActor!,
-    type: 'text',
-    timestamp: ts.iso,
-  };
-  if (tier) frontmatter['tier'] = tier;
-  const filename = messageFilename(ts);
-  writeFileSync(join(dir, filename), serializeFrontmatter(frontmatter, body));
-
-  const r = await withLock(transportRoot, 'git', async () =>
-    gitCommitAndPush(
-      transportRoot,
-      `chat: ${fromName} -> ${toActor} in ${channelUuid!.slice(0, 8)}`,
-    ),
-  );
-  sendWakeSignal(transportRoot);
-  if (!r.ok && r.error) {
-    const kind = r.committed ? 'push' : 'commit';
-    console.error(`(${kind} failed: ${r.error.slice(0, 200)} — message is local-only)`);
-  }
-  return `${ts.pathDate}/${filename}`;
-}
-
-// A reply is the message whose re: list contains the relPath we sent —
-// recorded by the dispatcher at write time, so the match is exact, not a
-// timestamp/addressing heuristic.
-async function waitForReplyTo(sentRelPath: string): Promise<ChannelMessage | null> {
-  const deadline = Date.now() + replyTimeoutSeconds * 1_000;
-  while (Date.now() < deadline) {
-    gitPull(transportRoot);
-    const reply = listChannelMessages(transportRoot, channelUuid!).find((m) =>
-      reList(m.data['re']).includes(sentRelPath),
-    );
-    if (reply) return reply;
-    await new Promise((r) => setTimeout(r, pollSeconds * 1_000));
-  }
-  return null;
-}
-
-async function main(): Promise<void> {
-  console.log(
-    `crosstalk chat — channel=${channelUuid!.slice(0, 8)} from=${fromName} to=${toActor}`,
-  );
-  console.log(
-    'Type a message and press Enter. Replies will appear after the dispatcher processes them.',
-  );
-  console.log('Ctrl-C or Ctrl-D to exit.');
-  console.log('');
-
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-
-  try {
-    while (true) {
-      let userMsg: string;
-      try {
-        userMsg = await rl.question(`${fromName}> `);
-      } catch {
-        break;
-      }
-      if (userMsg === undefined || userMsg === null) break;
-      const trimmed = userMsg.trim();
-      if (!trimmed) continue;
-
-      const sentRelPath = await sendMessage(trimmed);
-      process.stdout.write(`(waiting for ${toActor}…) `);
-
-      const reply = await waitForReplyTo(sentRelPath);
-      if (!reply) {
-        console.log(
-          `\n(no reply within ${replyTimeoutSeconds}s — give up and try again, or check dispatch state)\n`,
-        );
-        continue;
-      }
-      process.stdout.write('\r' + ' '.repeat(40) + '\r');
-      const replyFrom = typeof reply.data['from'] === 'string' ? reply.data['from'] : toActor;
-      console.log(`${replyFrom}> ${reply.body}\n`);
-    }
-  } finally {
-    rl.close();
-  }
-  process.exit(0);
-}
-
-main();