baychat 0.14.0 → 0.15.0

package/dist/relay/owner-pid.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.procTable = void 0;
+exports.ownerPidFor = ownerPidFor;
+exports.isRuntimeCommand = isRuntimeCommand;
+exports.currentOwnerPid = currentOwnerPid;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** How far to walk before giving up. Deep enough for shell wrappers, bounded so a cycle cannot hang an attach. */
+const MAX_HOPS = 12;
+/**
+ * The nearest ancestor that IS this runtime, or undefined when none is found.
+ *
+ * Undefined rather than a fallback to `ppid` on purpose: a witness that lies is
+ * worse than no witness. With none, the daemon keeps its previous behaviour and
+ * may spawn headlessly — the old bug. With a wrong one it spawns headlessly
+ * while the session is alive — the worse bug, and a silent one.
+ */
+function ownerPidFor(runtime, startPid, table) {
+    let pid = startPid;
+    const seen = new Set();
+    for (let hop = 0; hop < MAX_HOPS; hop++) {
+        if (pid <= 1 || seen.has(pid))
+            return undefined;
+        seen.add(pid);
+        if (isRuntimeCommand(table.commandOf(pid), runtime))
+            return pid;
+        const parent = table.parentOf(pid);
+        if (parent === undefined)
+            return undefined;
+        pid = parent;
+    }
+    return undefined;
+}
+/**
+ * Whether a command line IS the runtime, rather than merely mentioning it.
+ *
+ * Only the first two tokens are considered — the executable, and the script when
+ * that executable is an interpreter. The attach process itself runs
+ * `node …/baychat relay attach --runtime claude`, which CONTAINS "claude" as an
+ * argument; matching anywhere on the line would make every attach its own owner
+ * and defeat the check entirely.
+ */
+function isRuntimeCommand(command, runtime) {
+    if (!command)
+        return false;
+    const tokens = command.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return false;
+    if (namesRuntime(tokens[0], runtime))
+        return true;
+    // An interpreter's SCRIPT is the real executable: `node …/codex/bin/codex.js`
+    // is Codex. Only consulted behind an interpreter, and only for something that
+    // looks like a path — otherwise `grep claude syslog` would match its own
+    // search term, and every attach would match its own `--runtime claude`.
+    if (!INTERPRETERS.has(path.basename(tokens[0]).toLowerCase()))
+        return false;
+    const script = tokens[1];
+    if (!script || !/[\\/]/.test(script))
+        return false;
+    return namesRuntime(script, runtime);
+}
+const INTERPRETERS = new Set(["node", "node.exe", "bun", "deno", "python", "python3"]);
+/** `claude`, `claude.exe`, `codex.js` — the runtime's binary, however spelled. Not `claudette`. */
+function namesRuntime(token, runtime) {
+    const base = path.basename(token).toLowerCase();
+    return base === runtime || base.startsWith(`${runtime}.`);
+}
+/** Reads the live process tree from /proc. Returns nothing where /proc is absent (macOS, Windows). */
+exports.procTable = {
+    parentOf(pid) {
+        try {
+            // Field 4 of /proc/<pid>/stat is ppid. Read past the comm field, which is
+            // parenthesised and may itself contain spaces.
+            const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+            const after = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/);
+            const ppid = Number(after[1]);
+            return Number.isFinite(ppid) ? ppid : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    commandOf(pid) {
+        try {
+            return fs.readFileSync(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ").trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+};
+/** The owning runtime process for THIS attach, read from the live tree. */
+function currentOwnerPid(runtime) {
+    return ownerPidFor(runtime, process.ppid, exports.procTable);
+}

package/dist/relay/registry.js

@@ -121,6 +121,17 @@ class SessionRegistry {
         if (t)
             t.attached = attached;
     }
+    /**
+     * Record that a delivery to this session actually landed.
+     *
+     * Separate from `setAttached` because it means something stronger: attached is
+     * a state that can be claimed, this is an event that was observed.
+     */
+    markDelivered(name, at) {
+        const t = this.sessions.get(name);
+        if (t)
+            t.lastDeliveredAt = at;
+    }
     /**
      * Drop targets whose session is no longer live server-side.
      *

package/dist/relay/socket.js

@@ -39,6 +39,7 @@ exports.isNamedPipe = isNamedPipe;
 exports.pidFilePath = pidFilePath;
 exports.createFrameReader = createFrameReader;
 exports.writeFrame = writeFrame;
+exports.writeFrameAck = writeFrameAck;
 exports.probeSocketDetailed = probeSocketDetailed;
 exports.probeSocket = probeSocket;
 exports.describeProbeFailure = describeProbeFailure;
@@ -156,6 +157,53 @@ function createFrameReader(onFrame, onBad) {
 function writeFrame(sock, frame) {
     sock.write(JSON.stringify(frame) + "\n");
 }
+/**
+ * Write a frame and WAIT for the socket to take it, surfacing the failure if it
+ * does not.
+ *
+ * `writeFrame` is fire-and-forget. `sock.write()` buffers and returns, so a peer
+ * that has already gone produces an EPIPE on the socket's `error` event LATER —
+ * by which time the caller has recorded `woken`. That is a lost message filed as
+ * delivered, which is the single outcome `relay status` exists to make
+ * impossible: every other failure is at least visible as pending.
+ *
+ * Three ways this settles, and all three are needed. The write callback covers
+ * the ordinary case; the `error` event covers an EPIPE that arrives without one;
+ * `close` covers a peer that vanishes while the bytes are still buffered, which
+ * reports no error at all.
+ *
+ * HONEST LIMIT — this is a FLUSH confirmation, not a receiver acknowledgement.
+ * It proves the bytes left this process, not that the agent read them. A true
+ * end-to-end ack needs an `ack` frame back from the attach client, and every
+ * already-installed client would have to be taught to send one before the
+ * daemon could require it. What this closes is the failure that was actually
+ * observed — a dead peer recorded as woken — not the whole class.
+ */
+function writeFrameAck(sock, frame) {
+    return new Promise((resolve, reject) => {
+        if (sock.destroyed || sock.writableEnded) {
+            reject(new Error("the attach socket is already closed"));
+            return;
+        }
+        let settled = false;
+        const settle = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            sock.off("error", onError);
+            sock.off("close", onClose);
+            if (err)
+                reject(err);
+            else
+                resolve();
+        };
+        const onError = (err) => settle(err);
+        const onClose = () => settle(new Error("the attach socket closed before the frame was flushed"));
+        sock.once("error", onError);
+        sock.once("close", onClose);
+        sock.write(JSON.stringify(frame) + "\n", (err) => settle(err ?? undefined));
+    });
+}
 /**
  * Probe the attach endpoint, KEEPING THE REASON IT FAILED.
  *

package/dist/runtime-binary.js

@@ -173,6 +173,20 @@ function joinPath(dir, file, platform) {
  * @returns file + prefix args to spawn it with, always `shell: false`
  */
 function spawnPlanFor(candidate, platform) {
+    // A SCRIPT NEEDS ITS INTERPRETER, on every platform.
+    //
+    // The managed Codex fallback records `<CODEX_MANAGED_PACKAGE_ROOT>/bin/codex.js`
+    // — the file the npm install is actually running — and a `.js` cannot be
+    // spawned directly. On Unix that needs a shebang AND the execute bit, neither
+    // of which an npm package guarantees; on Windows there is no execute bit at
+    // all, and only `.cmd`/`.bat` were wrapped. So the recorded path was one the
+    // daemon could not run, which is the 2026-08-30 ENOENT failure in a new place.
+    //
+    // `process.execPath` is the Node running this CLI. Deliberately NOT a bare
+    // "node": the daemon's PATH may not have one — that is the whole reason
+    // `runtimeBin` is recorded by the session in the first place.
+    if (/\.(mjs|cjs|js)$/i.test(candidate))
+        return { file: process.execPath, prefixArgs: [candidate] };
     const needsInterpreter = platform === "win32" && /\.(cmd|bat)$/i.test(candidate);
     if (!needsInterpreter)
         return { file: candidate, prefixArgs: [] };

package/dist/runtimes.js

@@ -133,6 +133,14 @@ before ending your turn. Skipping this is the single most common way a session
 goes quiet: the relay is still running, the socket is still connected, and
 nothing is listening for you.
 
+**And after every INTERRUPT.** Stopping a task in your harness — Ctrl+C, the
+stop button — kills your background attach along with it, from outside the
+process: nothing fails, nothing is printed, and you are simply deaf from that
+moment on. A wake is not the only thing that ends an attach, so "re-arm after a
+wake" is not enough. **If your last turn was interrupted, re-arm before doing
+anything else**, and confirm with \`baychat relay status\` that your session does
+not read \`NOTHING IS LISTENING\`.
+
 Treat it as part of handling the message, not as an optional follow-up:
 
 1. attach exits with a message

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "BayChat connector CLI \u2014 pair an agent session (Claude Code, Codex) with BayChat and chat in groups",
   "bin": {
     "baychat": "dist/index.js"