@cordfuse/crosstalk 6.0.0-alpha.1 → 6.0.0-alpha.2

package/bin/crosstalk.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 
 const SUBCOMMANDS = [
-  'dispatch', 'send', 'replies', 'wake', 'status', 'init', 'dlq', 'channel',
+  'dispatch', 'stop', 'send', 'replies', 'wake', 'status', 'init', 'dlq', 'channel',
   'chat', 'open', 'attach', 'upgrade',
 ];
 const STANDALONE_SUBCOMMANDS = new Set(['init']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cordfuse/crosstalk",
-  "version": "6.0.0-alpha.1",
+  "version": "6.0.0-alpha.2",
   "description": "Crosstalk runtime — async messaging between agents over git, across machines.",
   "type": "module",
   "license": "MIT",

package/src/dispatch.ts

@@ -36,6 +36,8 @@ import {
   readCursor,
   writeCursor,
   writeHeartbeat,
+  writePidfile,
+  removePidfile,
   logError,
 } from './state.js';
 import { recipients, reList, decideWake, splitForConcurrency } from './activation.js';
@@ -360,26 +362,32 @@ async function dispatchTick(): Promise<TickResult> {
       const cursor = readCursor(transportRoot, actorName, channelUuid);
       if (cursor === head) continue;
 
+      // First encounter: seed to HEAD so only future messages are dispatched.
+      // Without this, a null cursor falls through to `post = messages` and
+      // replays the full channel history on every fresh-state boot.
+      if (cursor === null) {
+        writeCursor(transportRoot, actorName, channelUuid, head);
+        continue;
+      }
+
       const messages = listChannelMessages(transportRoot, channelUuid);
       const senderByRelPath = new Map(messages.map((m) => [m.relPath, messageSender(m)]));
       const senderOf = (relPath: string) => senderByRelPath.get(relPath);
 
-      let post = messages;
-      if (cursor) {
-        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`);
-          }
-        }
-        if (added !== null) {
-          const prefix = `data/channels/${channelUuid}/`;
-          post = messages.filter((m) => added.has(prefix + m.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;
@@ -466,6 +474,12 @@ async function waitForWakeOrTimeout(ms: number): Promise<void> {
 }
 
 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();

package/src/send.ts

@@ -77,7 +77,7 @@ async function main(): Promise<void> {
     console.error(`but git ${pushResult.committed ? 'push' : 'commit'} FAILED:`);
     console.error(`  ${pushResult.error.slice(0, 300)}`);
     console.error('\nYour message is in the local clone but not on origin. Recover with:');
-    console.error('  git pull --rebase && git push');
+    console.error('  git fetch origin && git rebase origin/main && git push');
     process.exit(3);
   }
 

package/src/state.ts

@@ -8,6 +8,7 @@
 //   dlq/<id>.md                        — failed-dispatch entries
 //   errors.log                         — infra failures, JSONL, append-only
 //   heartbeat                          — last tick timestamp + pid + version
+//   dispatcher.pid                     — PID of the running dispatcher process
 //   wake.signal                        — touched to wake the dispatch loop
 //
 // Location: $CROSSTALK_STATE_DIR if set (exact dir — container-friendly),
@@ -19,6 +20,7 @@ import {
   mkdirSync,
   readFileSync,
   writeFileSync,
+  unlinkSync,
   appendFileSync,
 } from 'fs';
 import { join, dirname } from 'path';
@@ -95,6 +97,34 @@ export function writeCursor(
   writeFileSync(p, commit + '\n');
 }
 
+// ── pidfile ──
+
+export function pidfilePath(transportRoot: string): string {
+  return join(stateDir(transportRoot), 'dispatcher.pid');
+}
+
+export function writePidfile(transportRoot: string): void {
+  try {
+    writeFileSync(pidfilePath(transportRoot), `${process.pid}\n`);
+  } catch { /* best-effort */ }
+}
+
+export function removePidfile(transportRoot: string): void {
+  try {
+    unlinkSync(pidfilePath(transportRoot));
+  } catch { /* already gone */ }
+}
+
+export function readPidfile(transportRoot: string): number | null {
+  try {
+    const raw = readFileSync(pidfilePath(transportRoot), 'utf-8').trim();
+    const n = parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+
 // ── heartbeat + wake ──
 
 export function writeHeartbeat(transportRoot: string, version: string): void {

package/src/stop.ts

@@ -0,0 +1,37 @@
+// crosstalk stop — send SIGTERM to the running dispatcher and wait for it to exit.
+
+import { resolve } from 'path';
+import { spawnSync } from 'child_process';
+import { readPidfile, removePidfile } from './state.js';
+
+const transportRoot = resolve(process.cwd());
+
+function processRunning(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+const pid = readPidfile(transportRoot);
+if (pid === null) {
+  console.error('crosstalk stop: no dispatcher.pid found — is dispatch running?');
+  process.exit(1);
+}
+
+if (!processRunning(pid)) {
+  console.error(`crosstalk stop: pid ${pid} is not running — removing stale pidfile`);
+  removePidfile(transportRoot);
+  process.exit(1);
+}
+
+process.kill(pid, 'SIGTERM');
+
+const deadline = Date.now() + 5_000;
+while (Date.now() < deadline) {
+  if (!processRunning(pid)) {
+    console.log(`crosstalk stop: dispatcher (pid ${pid}) stopped`);
+    process.exit(0);
+  }
+  spawnSync('sleep', ['0.1']);
+}
+
+console.error(`crosstalk stop: pid ${pid} did not exit within 5s — try: kill -9 ${pid}`);
+process.exit(1);