@cordfuse/crosstalk 6.0.0-alpha.7 → 6.0.0-alpha.9

package/package.json

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

package/src/actor.ts

@@ -1,8 +1,31 @@
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { hostname as osHostname } from 'os';
+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;
@@ -36,13 +59,15 @@ export function findHostFile(transportRoot: string, override?: string): HostFile
     if (!target) throw new Error(`Host file '${override}' not found in ${dir}`);
     return parseHostFile(join(dir, target));
   }
-  const hostName = osHostname();
+  const names = candidateHostNames();
   for (const f of files) {
     const parsed = parseHostFile(join(dir, f));
-    if (parsed.hostname === hostName || parsed.alias === hostName) return parsed;
+    for (const n of names) {
+      if (parsed.hostname === n || parsed.alias === n) return parsed;
+    }
   }
   throw new Error(
-    `No host file matches hostname '${hostName}' in ${dir}. ` +
+    `No host file matches any of [${names.join(', ')}] in ${dir}. ` +
       `Pass --host <alias> to override.`,
   );
 }

package/src/dispatch.ts

@@ -362,17 +362,23 @@ async function dispatchTick(): Promise<TickResult> {
     const pending: PendingDispatch[] = [];
 
     for (const channelUuid of channels) {
-      const cursor = readCursor(transportRoot, actorName, channelUuid);
-      if (cursor === head) continue;
+      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.
-      if (cursor === null) {
+      // 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);
-        writeCursor(transportRoot, actorName, channelUuid, joinCommit ?? head);
-        continue;
+        cursor = joinCommit ?? head;
+        writeCursor(transportRoot, actorName, channelUuid, cursor);
+        if (cursor === head) continue;
+      } else {
+        cursor = persistedCursor;
       }
 
       const messages = listChannelMessages(transportRoot, channelUuid);

package/src/send.ts

@@ -8,7 +8,7 @@
 // Operators (no env) always send new tasks.
 
 import { resolve, join } from 'path';
-import { mkdirSync, writeFileSync } from 'fs';
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
 import { now, messageFilename } from './filenames.js';
 import { serializeFrontmatter } from './frontmatter.js';
 import { gitCommitAndPush, discoverChannels } from './transport.js';
@@ -56,6 +56,26 @@ async function main(): Promise<void> {
     }
   }
 
+  // Warn when --to names an actor@host whose host file isn't in the transport
+  // yet. The dispatcher's high-water-mark seeds past any commit before the
+  // host file landed, so messages to an un-provisioned host are silently
+  // skipped on first boot. Surfacing this here turns the silent drop into an
+  // operator-visible error before the message is even written.
+  const recipients = to.split(',').map((s) => s.trim()).filter(Boolean);
+  for (const recipient of recipients) {
+    const at = recipient.indexOf('@');
+    if (at === -1) continue;
+    const host = recipient.slice(at + 1);
+    const hostPath = join(transportRoot, 'hosts', `${host}.md`);
+    if (!existsSync(hostPath)) {
+      console.error(
+        `crosstalk send: WARNING — no host file at hosts/${host}.md. ` +
+          `Messages addressed to '${recipient}' will be skipped by that host ` +
+          `until hosts/${host}.md is committed to the transport.`,
+      );
+    }
+  }
+
   const reTargets = (isNew ? '' : process.env['CROSSTALK_DISPATCH_RE'] ?? '')
     .split(',')
     .map((s) => s.trim())