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

package/src/dispatch.ts

@@ -1,531 +0,0 @@
-// crosstalk dispatch — the loop.
-//
-// Tick: pull → for each local actor, scan channels for messages past the
-// cursor → decideWake (activation.ts, the one rule) → invoke the actor's
-// CLI per batch → write replies (re: linked per sender) → commit+push.
-//
-// Only the commit+push is locked, and the lock is advisory (turnq.ts) —
-// git arbitrates correctness. Cursors, DLQ, heartbeat and the error log
-// live in the machine-local state dir (state.ts), so a tick's commit only
-// ever contains data/ and there is no self-inflicted git deadlock to heal.
-
-import { resolve, join, dirname } from 'path';
-import { spawn } from 'child_process';
-import { mkdirSync, writeFileSync, readFileSync, existsSync, appendFileSync } from 'fs';
-import { watch } from 'fs/promises';
-import { fileURLToPath } from 'url';
-import {
-  findHostFile,
-  loadActorProfile,
-  pickTier,
-  tokenizeCli,
-  type HostActorTiers,
-  type HostFile,
-} from './actor.js';
-import {
-  discoverChannels,
-  listChannelMessages,
-  gitPull,
-  gitCommitAndPush,
-  cursorBaseline,
-  newFilesSince,
-  hostFileCommit,
-  type ChannelMessage,
-} from './transport.js';
-import {
-  stateDir,
-  readCursor,
-  writeCursor,
-  writeHeartbeat,
-  writePidfile,
-  removePidfile,
-  logError,
-} from './state.js';
-import { recipients, reList, decideWake, splitForConcurrency } from './activation.js';
-import { now, messageFilename } from './filenames.js';
-import { serializeFrontmatter } from './frontmatter.js';
-import { withLock } from './turnq.js';
-import { writeDlqEntry, isQuarantined } from './dlq.js';
-
-const RUNTIME_VERSION: string = (() => {
-  try {
-    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
-    return (JSON.parse(readFileSync(pkgPath, 'utf-8')) as { version?: string }).version ?? 'unknown';
-  } catch {
-    return 'unknown';
-  }
-})();
-
-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 onceMode = argv.includes('--once');
-const jsonMode = argv.includes('--json');
-const hostOverride = flag('--host');
-const pollSeconds = Number(flag('--poll')) || 30;
-const logFile = flag('--log-file');
-
-const CLI_TIMEOUT_MS = 5 * 60_000;
-const MAX_BACKOFF_MULTIPLIER = 10;
-const BACKOFF_GRACE = 2;
-
-function log(event: string, fields: Record<string, unknown> = {}): void {
-  let line: string;
-  if (jsonMode) {
-    line = JSON.stringify({ ts: new Date().toISOString(), event, ...fields });
-  } else {
-    const tail = Object.entries(fields)
-      .map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`)
-      .join(' ');
-    line = `[${new Date().toISOString()}] ${event}${tail ? ' ' + tail : ''}`;
-  }
-  console.log(line);
-  if (logFile) {
-    try { appendFileSync(logFile, line + '\n'); } catch { /* best-effort */ }
-  }
-}
-
-// Config errors (bad host file, bad actor profile) repeat every tick until
-// fixed — log each distinct one once per process run, not once per tick.
-const loggedConfigErrors = new Set<string>();
-function logConfigError(scope: string, message: string): void {
-  const key = `${scope}::${message}`;
-  if (loggedConfigErrors.has(key)) return;
-  loggedConfigErrors.add(key);
-  logError(transportRoot, 'parse', `${scope}: ${message}`);
-  log('config_error', { scope, message: message.slice(0, 200) });
-}
-
-const protocolPrompt = (() => {
-  const p = join(transportRoot, 'upstream', 'PROTOCOL.md');
-  return existsSync(p) ? readFileSync(p, 'utf-8').trim() : '';
-})();
-
-function composeSystemPrompt(actorPrompt: string): string {
-  return [protocolPrompt, actorPrompt].filter((p) => p.length > 0).join('\n\n---\n\n');
-}
-
-function actorConcurrency(tiers: HostActorTiers): number {
-  for (const value of Object.values(tiers)) {
-    if (typeof value === 'object' && typeof value.count === 'number' && value.count > 0) {
-      return value.count;
-    }
-  }
-  return 1;
-}
-
-function messageSender(msg: ChannelMessage): string {
-  return typeof msg.data['from'] === 'string' ? (msg.data['from'] as string) : 'unknown';
-}
-
-interface CliResult {
-  status: number;
-  stdout: string;
-  stderr: string;
-}
-
-function invokeCli(
-  cli: string,
-  systemPrompt: string,
-  userMessage: string,
-  env: Record<string, string>,
-): Promise<CliResult> {
-  return new Promise((res) => {
-    const fullPrompt = `${systemPrompt}\n\n---\n\n${userMessage}`;
-    const parts = tokenizeCli(cli);
-    if (parts.length === 0) {
-      res({ status: 1, stdout: '', stderr: 'tokenized cli is empty' });
-      return;
-    }
-    // detached: new process group, so the timeout SIGKILL takes the actor's
-    // children with it — orphans writing to the transport after a timeout
-    // was an observed v5 hazard.
-    const child = spawn(parts[0]!, parts.slice(1), {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      detached: true,
-      env: { ...process.env, ...env },
-    });
-    let stdout = '';
-    let stderr = '';
-    let resolved = false;
-    const timeout = setTimeout(() => {
-      if (resolved) return;
-      resolved = true;
-      try {
-        if (typeof child.pid === 'number') process.kill(-child.pid, 'SIGKILL');
-        else child.kill('SIGKILL');
-      } catch {
-        try { child.kill('SIGKILL'); } catch { /* already dead */ }
-      }
-      res({ status: 124, stdout, stderr: stderr + '\n[timeout]' });
-    }, CLI_TIMEOUT_MS);
-    child.stdout.on('data', (d) => { stdout += d.toString(); });
-    child.stderr.on('data', (d) => { stderr += d.toString(); });
-    child.on('close', (code) => {
-      if (resolved) return;
-      resolved = true;
-      clearTimeout(timeout);
-      res({ status: code ?? 1, stdout, stderr });
-    });
-    child.on('error', (err) => {
-      if (resolved) return;
-      resolved = true;
-      clearTimeout(timeout);
-      res({ status: 1, stdout, stderr: stderr + '\n' + err.message });
-    });
-    child.stdin.on('error', () => { /* child closed stdin */ });
-    try { child.stdin.write(fullPrompt); } catch { /* same */ }
-    try { child.stdin.end(); } catch { /* ignore */ }
-  });
-}
-
-function writeReply(
-  channelUuid: string,
-  fromActor: string,
-  toActor: string,
-  re: string | string[],
-  body: string,
-): void {
-  const ts = now();
-  const dir = join(transportRoot, 'data', 'channels', channelUuid, ts.pathDate);
-  mkdirSync(dir, { recursive: true });
-  const content = serializeFrontmatter(
-    { from: fromActor, to: toActor, type: 'text', timestamp: ts.iso, re },
-    body,
-  );
-  writeFileSync(join(dir, messageFilename(ts)), content);
-}
-
-function formatBatchedUserMessage(msgs: ChannelMessage[]): string {
-  if (msgs.length === 1) return msgs[0]!.body;
-  const parts = [`You have ${msgs.length} new messages in this channel. Process them collectively and reply once.`];
-  for (let i = 0; i < msgs.length; i++) {
-    const m = msgs[i]!;
-    const ts = typeof m.data['timestamp'] === 'string' ? `, ts: ${m.data['timestamp']}` : '';
-    parts.push(`--- Message ${i + 1} of ${msgs.length} (from: ${messageSender(m)}, ref: ${m.relPath}${ts}) ---`);
-    parts.push(m.body);
-  }
-  return parts.join('\n\n');
-}
-
-interface PendingDispatch {
-  actorName: string;
-  channelUuid: string;
-  msgs: ChannelMessage[];
-  tiers: HostActorTiers;
-}
-
-async function dispatchOne(p: PendingDispatch): Promise<boolean> {
-  const firstMsg = p.msgs[0]!;
-  const lastMsg = p.msgs[p.msgs.length - 1]!;
-
-  if (isQuarantined(transportRoot, p.actorName, p.channelUuid, lastMsg.relPath)) {
-    log('dispatch_skipped_quarantined', {
-      actor: p.actorName,
-      channel: p.channelUuid.slice(0, 8),
-      msg: lastMsg.relPath,
-    });
-    return false;
-  }
-
-  const preferredTier = typeof firstMsg.data['tier'] === 'string' ? (firstMsg.data['tier'] as string) : undefined;
-  let cli: string;
-  let profile;
-  try {
-    cli = pickTier(p.tiers, preferredTier).cli;
-    profile = loadActorProfile(transportRoot, p.actorName);
-  } catch (err) {
-    logConfigError(`actor:${p.actorName}`, (err as Error).message);
-    return false;
-  }
-
-  log('dispatch', {
-    actor: p.actorName,
-    channel: p.channelUuid.slice(0, 8),
-    batch_size: p.msgs.length,
-    first_msg: firstMsg.relPath,
-    last_msg: lastMsg.relPath,
-  });
-
-  const result = await invokeCli(
-    cli,
-    composeSystemPrompt(profile.systemPrompt),
-    formatBatchedUserMessage(p.msgs),
-    {
-      CROSSTALK_DISPATCH_ACTOR: p.actorName,
-      CROSSTALK_DISPATCH_CHANNEL: p.channelUuid,
-      // Every relPath in the batch — `crosstalk send` records them all as
-      // the reply's re: list, so batching never loses an answered message.
-      CROSSTALK_DISPATCH_RE: p.msgs.map((m) => m.relPath).join(','),
-    },
-  );
-
-  if (result.status !== 0) {
-    const r = writeDlqEntry(
-      transportRoot,
-      p.actorName,
-      p.channelUuid,
-      lastMsg.relPath,
-      `cli exit=${result.status}\n${result.stderr.slice(0, 1000)}`,
-    );
-    log('dispatch_failed', {
-      actor: p.actorName,
-      channel: p.channelUuid.slice(0, 8),
-      batch_size: p.msgs.length,
-      dlq_id: r.id,
-      attempts: r.attempts,
-      quarantined: r.quarantined,
-      exit: result.status,
-    });
-    return false;
-  }
-
-  const reply = result.stdout.trim();
-  if (reply.length === 0) {
-    // Legitimate: the actor routed its answer via `crosstalk send` (which
-    // auto-links re:). If it truly did nothing, the asker's `crosstalk
-    // replies` stays PENDING — visible, not silently lost.
-    log('dispatch_silent', { actor: p.actorName, channel: p.channelUuid.slice(0, 8), batch_size: p.msgs.length });
-    log('dispatch_done', { actor: p.actorName, channel: p.channelUuid.slice(0, 8), batch_size: p.msgs.length, replied: false });
-    return true;
-  }
-
-  // One reply per distinct sender, re:-linked to EVERY message that sender
-  // had in the batch — the asker's activation rule fires, and `crosstalk
-  // replies` sees each individual message as answered.
-  const bySender = new Map<string, string[]>();
-  for (const m of p.msgs) {
-    const sender = messageSender(m);
-    bySender.set(sender, [...(bySender.get(sender) ?? []), m.relPath]);
-  }
-  bySender.delete('unknown');
-  if (bySender.size === 0) bySender.set(messageSender(firstMsg), [firstMsg.relPath]);
-  for (const [sender, relPaths] of bySender) {
-    writeReply(p.channelUuid, p.actorName, sender, relPaths.length === 1 ? relPaths[0]! : relPaths, reply);
-  }
-  log('dispatch_done', { actor: p.actorName, channel: p.channelUuid.slice(0, 8), batch_size: p.msgs.length, replied: true });
-  return true;
-}
-
-interface TickResult {
-  didWork: boolean;
-  infraOk: boolean;
-}
-
-async function dispatchTick(): Promise<TickResult> {
-  writeHeartbeat(transportRoot, RUNTIME_VERSION);
-  let infraOk = true;
-
-  const pullResult = gitPull(transportRoot);
-  if (!pullResult.ok) {
-    // Skip the whole tick: a failed pull can leave origin/HEAD (the cursor
-    // baseline) ahead of the working tree, and scanning against that would
-    // advance cursors past messages that never materialized.
-    logError(transportRoot, 'git_pull', pullResult.error ?? 'unknown');
-    log('git_pull_failed', { error: (pullResult.error ?? '').slice(0, 200) });
-    return { didWork: false, infraOk: false };
-  }
-
-  let host: HostFile;
-  try {
-    host = findHostFile(transportRoot, hostOverride);
-  } catch (err) {
-    logConfigError('host', (err as Error).message);
-    return { didWork: false, infraOk };
-  }
-
-  // Cursors are commit hashes, not relPaths: filenames order by sender
-  // timestamp but arrive in push order, so a relPath cursor can advance
-  // past a slower writer's earlier-stamped message and lose it forever.
-  // "New since cursor" is asked of git, which records arrival truthfully.
-  const head = cursorBaseline(transportRoot);
-  if (!head) {
-    logError(transportRoot, 'other', 'git rev-parse failed for origin/HEAD and HEAD — skipping tick');
-    return { didWork: false, infraOk: false };
-  }
-  // diff results keyed by cursor commit (shared across actors on the same
-  // cursor); null = commit unknown to this clone -> full re-scan.
-  const addedSince = new Map<string, Set<string> | null>();
-
-  let didWork = false;
-  const channels = discoverChannels(transportRoot);
-
-  for (const actorName of Object.keys(host.actors)) {
-    const tiers = host.actors[actorName]!;
-    const concurrency = actorConcurrency(tiers);
-    const pending: PendingDispatch[] = [];
-
-    for (const channelUuid of channels) {
-      const persistedCursor = readCursor(transportRoot, actorName, channelUuid);
-      if (persistedCursor === head) continue;
-
-      // First encounter: seed to the commit that introduced this actor's host
-      // file. Messages sent after the host joined are delivered (store-and-
-      // forward); pre-join history is ignored. Seeding to HEAD would silently
-      // drop messages sent while the dispatcher was offline — the wrong trade.
-      // Fall through after seeding so this tick processes the post-join backlog
-      // (otherwise `--once` users hit a seed-then-dispatch two-tick gotcha).
-      let cursor: string;
-      if (persistedCursor === null) {
-        const joinCommit = hostFileCommit(transportRoot, host.alias);
-        cursor = joinCommit ?? head;
-        writeCursor(transportRoot, actorName, channelUuid, cursor);
-        if (cursor === head) continue;
-      } else {
-        cursor = persistedCursor;
-      }
-
-      const messages = listChannelMessages(transportRoot, channelUuid);
-      const senderByRelPath = new Map(messages.map((m) => [m.relPath, messageSender(m)]));
-      const senderOf = (relPath: string) => senderByRelPath.get(relPath);
-
-      let added = addedSince.get(cursor);
-      if (added === undefined) {
-        const files = newFilesSince(transportRoot, cursor);
-        added = files === null ? null : new Set(files);
-        addedSince.set(cursor, added);
-        if (added === null) {
-          logError(transportRoot, 'other', `cursor commit ${cursor.slice(0, 12)} unknown to this clone — full channel re-scan`);
-        }
-      }
-      let post = messages;
-      if (added !== null) {
-        const prefix = `data/channels/${channelUuid}/`;
-        post = messages.filter((m) => added.has(prefix + m.relPath));
-      }
-      if (post.length === 0) {
-        writeCursor(transportRoot, actorName, channelUuid, head);
-        continue;
-      }
-
-      const batch: ChannelMessage[] = [];
-      for (const msg of post) {
-        if (msg.data['type'] !== 'text') continue;
-        const decision = decideWake(
-          {
-            from: messageSender(msg),
-            to: recipients(msg.data['to']),
-            re: reList(msg.data['re']),
-          },
-          actorName,
-          host.alias,
-          senderOf,
-        );
-        if (decision === 'wake') {
-          batch.push(msg);
-        } else if (decision === 'wrong-host') {
-          log('host_routing_mismatch', {
-            actor: actorName,
-            this_host: host.alias,
-            channel: channelUuid.slice(0, 8),
-            msg: msg.relPath,
-            to: recipients(msg.data['to']),
-          });
-        }
-      }
-
-      if (batch.length === 0) {
-        writeCursor(transportRoot, actorName, channelUuid, head);
-        continue;
-      }
-      for (const g of splitForConcurrency(batch, concurrency)) {
-        pending.push({ actorName, channelUuid, msgs: g, tiers });
-      }
-    }
-
-    // Waves of `concurrency` parallel CLI invocations. The cursor advances
-    // to the scanned commit whether each batch succeeded or DLQ'd —
-    // at-least-once was attempted; `crosstalk dlq --retry` rewinds the
-    // cursor explicitly. A crash mid-wave leaves the cursor behind, so the
-    // whole span replays next tick (at-least-once, never lost).
-    for (let i = 0; i < pending.length; i += concurrency) {
-      const wave = pending.slice(i, i + concurrency);
-      const results = await Promise.all(wave.map((p) => dispatchOne(p)));
-      if (results.some(Boolean)) didWork = true;
-    }
-    for (const p of pending) {
-      writeCursor(transportRoot, p.actorName, p.channelUuid, head);
-    }
-  }
-
-  if (didWork) {
-    const pushResult = await withLock(transportRoot, 'git', async () =>
-      gitCommitAndPush(transportRoot, `dispatch: replies ${new Date().toISOString()}`),
-    );
-    if (!pushResult.ok && pushResult.error) {
-      logError(transportRoot, pushResult.committed ? 'git_push' : 'git_commit', pushResult.error);
-      log('git_push_failed', { committed_locally: pushResult.committed, error: pushResult.error.slice(0, 200) });
-      infraOk = false;
-    }
-  }
-
-  return { didWork, infraOk };
-}
-
-async function waitForWakeOrTimeout(ms: number): Promise<void> {
-  const dir = stateDir(transportRoot);
-  const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), ms);
-  try {
-    const watcher = watch(dir, { signal: ac.signal });
-    for await (const ev of watcher) {
-      if (ev.filename === 'wake.signal') return;
-    }
-  } catch {
-    /* abort = timeout */
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function main(): Promise<void> {
-  writePidfile(transportRoot);
-  const cleanup = () => removePidfile(transportRoot);
-  process.on('exit', cleanup);
-  process.on('SIGTERM', () => { cleanup(); process.exit(0); });
-  process.on('SIGINT',  () => { cleanup(); process.exit(0); });
-
-  log('dispatch_start', { transport: transportRoot, version: RUNTIME_VERSION, state_dir: stateDir(transportRoot) });
-  if (onceMode) {
-    await dispatchTick();
-    process.exit(0);
-  }
-  log('dispatch_running', { quiet_poll_s: pollSeconds });
-
-  let consecutiveInfraFailures = 0;
-  while (true) {
-    try {
-      const r = await dispatchTick();
-      if (r.infraOk) {
-        if (consecutiveInfraFailures > 0) log('backoff_cleared', { previous_failures: consecutiveInfraFailures });
-        consecutiveInfraFailures = 0;
-      } else {
-        consecutiveInfraFailures++;
-      }
-      const beyondGrace = Math.max(0, consecutiveInfraFailures - BACKOFF_GRACE);
-      const backoffFactor = Math.min(MAX_BACKOFF_MULTIPLIER, 2 ** beyondGrace);
-      if (backoffFactor > 1) {
-        log('backoff_active', { consecutive_failures: consecutiveInfraFailures, factor: backoffFactor });
-      }
-      if (r.didWork) {
-        await new Promise((res) => setTimeout(res, 1_000 * backoffFactor));
-      } else {
-        await waitForWakeOrTimeout(pollSeconds * 1_000 * backoffFactor);
-      }
-    } catch (err) {
-      const msg = (err as Error).message;
-      logError(transportRoot, 'other', `tick error: ${msg}`);
-      log('tick_error', { message: msg });
-      consecutiveInfraFailures++;
-      await new Promise((res) => setTimeout(res, pollSeconds * 1_000));
-    }
-  }
-}
-
-main();