baychat 0.8.1 → 0.9.0

package/dist/relay/commands.js

@@ -0,0 +1,312 @@
+"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.cmdRelayStart = cmdRelayStart;
+exports.ensureRelayInstalled = ensureRelayInstalled;
+exports.cmdRelayStatus = cmdRelayStatus;
+exports.cmdRelayStop = cmdRelayStop;
+exports.cmdRelayAttach = cmdRelayAttach;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const adapters_1 = require("./adapters");
+const daemon_1 = require("./daemon");
+const socket_1 = require("./socket");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const UNIT_NAME = "baychat-relay.service";
+/** Connect to a running daemon, or explain that there isn't one. */
+async function connectOrFail() {
+    const sockPath = (0, socket_1.socketPath)();
+    if (!(await (0, socket_1.probeSocket)(sockPath))) {
+        throw new Error("no relay is running — start one with `baychat relay start`");
+    }
+    return net.createConnection(sockPath);
+}
+/** One request/response round trip against the daemon. */
+function request(sock, frame, timeoutMs = 5_000) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            sock.destroy();
+            reject(new Error("relay did not answer in time"));
+        }, timeoutMs);
+        sock.on("data", (0, socket_1.createFrameReader)((f) => {
+            if (f.type === "status-result") {
+                clearTimeout(timer);
+                sock.end();
+                resolve(f.status);
+            }
+            else if (f.type === "error") {
+                clearTimeout(timer);
+                sock.end();
+                reject(new Error(f.message));
+            }
+        }));
+        sock.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        (0, socket_1.writeFrame)(sock, frame);
+    });
+}
+/**
+ * `baychat relay start`
+ *
+ * `--foreground` runs the daemon in this process (what the systemd unit
+ * executes). Without it we install and enable a user unit, so the relay comes
+ * back after a reboot rather than only after the next manual start.
+ */
+async function cmdRelayStart(opts = {}) {
+    if (opts.foreground) {
+        const daemon = new daemon_1.RelayDaemon();
+        const shutdown = () => {
+            void daemon.stop().then(() => process.exit(0));
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        await daemon.start();
+        return;
+    }
+    if (await (0, socket_1.probeSocket)((0, socket_1.socketPath)())) {
+        console.log("Relay is already running. `baychat relay status` for details.");
+        return;
+    }
+    if (process.platform !== "linux") {
+        console.log("Automatic startup needs systemd (Linux). Run the daemon yourself with:");
+        console.log("  baychat relay start --foreground");
+        return;
+    }
+    await installUserUnit();
+    console.log("Relay started and enabled at boot.");
+    console.log("  baychat relay status   — see sessions, cursor, pending deliveries");
+    console.log("  baychat relay stop     — stop it");
+}
+/**
+ * Write and enable the user unit.
+ *
+ * `enable-linger` is what makes "after reboot" true rather than "after the
+ * next login": without it a user manager only runs while someone is logged in,
+ * so a headless box that rebooted overnight would come back deaf.
+ */
+async function installUserUnit() {
+    const unitDir = path.join(os.homedir(), ".config", "systemd", "user");
+    fs.mkdirSync(unitDir, { recursive: true });
+    // Resolve the installed CLI entry point rather than assuming a global name —
+    // an npx-run or locally-linked copy must produce a unit that keeps working.
+    const entry = path.resolve(process.argv[1]);
+    const unit = `[Unit]
+Description=BayChat relay — wakes local agent sessions on new messages
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${entry} relay start --foreground
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=default.target
+`;
+    fs.writeFileSync(path.join(unitDir, UNIT_NAME), unit, { mode: 0o644 });
+    await execFileAsync("systemctl", ["--user", "daemon-reload"]);
+    await execFileAsync("systemctl", ["--user", "enable", "--now", UNIT_NAME]);
+    try {
+        await execFileAsync("loginctl", ["enable-linger", os.userInfo().username]);
+    }
+    catch {
+        console.log("Note: could not enable linger — the relay will start at login rather than at boot.");
+    }
+}
+/**
+ * Best-effort relay setup, run as the last step of `baychat connect`.
+ *
+ * Never throws and never aborts the connect flow: a laptop without systemd
+ * still gets a working MCP connection, just without instant wake-ups. Returns
+ * the line to show the user — including when it did nothing, because silently
+ * skipping would leave them believing wake-ups are live when they are not.
+ */
+async function ensureRelayInstalled() {
+    try {
+        // Escape hatch for tests and for anyone who wants `connect` to stay inert:
+        // installing a user unit is a side effect on the machine, and a test suite
+        // that drives `connect` to completion must not leave one behind.
+        if (process.env.BAYCHAT_NO_RELAY_AUTOSTART) {
+            return "Relay: auto-start skipped (BAYCHAT_NO_RELAY_AUTOSTART). Run `baychat relay start` to enable wake-ups.";
+        }
+        if (await (0, socket_1.probeSocket)((0, socket_1.socketPath)()))
+            return "Relay: already running — sessions wake instantly.";
+        if (process.platform !== "linux") {
+            return "Relay: not installed (needs systemd). Run `baychat relay start --foreground` to wake sessions instantly.";
+        }
+        await installUserUnit();
+        return "Relay: installed and started — sessions now wake the moment a message arrives.";
+    }
+    catch (err) {
+        return `Relay: could not start automatically (${err instanceof Error ? err.message : String(err)}). Run \`baychat relay start\` yourself.`;
+    }
+}
+async function cmdRelayStatus() {
+    let status;
+    try {
+        status = await request(await connectOrFail(), { type: "status" });
+    }
+    catch (err) {
+        console.log(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+    console.log(`Relay running (pid ${status.pid}, since ${status.startedAt})`);
+    console.log(`  polls: ${status.polls}   delivered: ${status.delivered}   cursor: ${status.cursor ?? "—"}`);
+    if (status.lastError)
+        console.log(`  last error: ${status.lastError}`);
+    console.log(`\nSessions (${status.sessions.length}):`);
+    if (status.sessions.length === 0) {
+        console.log("  none — a session registers itself by running `baychat relay attach`");
+    }
+    for (const s of status.sessions) {
+        const state = s.attached ? "attached" : s.resumeId ? "detached (headless resume ready)" : "detached (no resume id)";
+        console.log(`  ${s.name}  [${s.runtime}]  ${state}`);
+    }
+    // Pending is the point of the whole command: these are messages that reached
+    // this machine and that nobody answered.
+    if (status.pending.length > 0) {
+        console.log(`\nDELIVERY PENDING (${status.pending.length}) — reached this box, not answered:`);
+        for (const p of status.pending.slice(-10)) {
+            console.log(`  ${p.at}  ${p.session}  msg ${p.messageId}`);
+            console.log(`     ${p.reason}`);
+        }
+        return 2; // distinct exit code so a monitor can alert on it
+    }
+    return 0;
+}
+async function cmdRelayStop() {
+    if (process.platform === "linux" && fs.existsSync(path.join(os.homedir(), ".config", "systemd", "user", UNIT_NAME))) {
+        try {
+            await execFileAsync("systemctl", ["--user", "disable", "--now", UNIT_NAME]);
+            console.log("Relay stopped and disabled at boot.");
+            return 0;
+        }
+        catch {
+            // Fall through to the socket path — the unit may not be the thing running.
+        }
+    }
+    try {
+        await request(await connectOrFail(), { type: "stop" });
+        console.log("Relay stopped.");
+        return 0;
+    }
+    catch (err) {
+        console.log(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+}
+/**
+ * `baychat relay attach` — block until this session is woken.
+ *
+ * Exits 0 the moment a batch arrives, printing it. That exit is the wake: a
+ * harness that launched this as a background process re-invokes the session,
+ * which then reads the room properly through the BayChat tools. Exit 2 means
+ * the wait lapsed with nothing to report.
+ */
+async function cmdRelayAttach(opts) {
+    if (!(0, adapters_1.isKnownRuntime)(opts.runtime)) {
+        console.log(`unknown runtime "${opts.runtime}" — expected claude, codex, or hermes`);
+        return 1;
+    }
+    const runtime = opts.runtime;
+    let sock;
+    try {
+        sock = await connectOrFail();
+    }
+    catch (err) {
+        console.log(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+    return new Promise((resolve) => {
+        const timer = opts.timeoutMs
+            ? setTimeout(() => {
+                sock.end();
+                console.log("No new messages before timeout.");
+                resolve(2);
+            }, opts.timeoutMs)
+            : undefined;
+        sock.on("data", (0, socket_1.createFrameReader)((frame) => {
+            if (frame.type === "attached") {
+                console.log(`Attached as "${frame.session}". Waiting for messages…`);
+                return;
+            }
+            if (frame.type === "wake") {
+                if (timer)
+                    clearTimeout(timer);
+                console.log(`WAKE ${frame.messages.length} message(s) in ${frame.conversationId}:`);
+                for (const m of frame.messages) {
+                    const flag = m.shouldRespond ? " [shouldRespond=true]" : "";
+                    console.log(`  (${m.id}) ${m.senderType} ${m.senderId}${flag}: ${m.content}`);
+                }
+                sock.end();
+                resolve(0);
+                return;
+            }
+            if (frame.type === "error") {
+                if (timer)
+                    clearTimeout(timer);
+                console.log(frame.message);
+                sock.end();
+                resolve(1);
+            }
+        }));
+        sock.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            console.log(err.message);
+            resolve(1);
+        });
+        sock.on("close", () => {
+            if (timer)
+                clearTimeout(timer);
+            resolve(2);
+        });
+        (0, socket_1.writeFrame)(sock, {
+            type: "attach",
+            session: opts.session,
+            runtime,
+            resumeId: opts.resumeId,
+            cwd: process.cwd(),
+        });
+    });
+}

package/dist/relay/daemon.js

@@ -0,0 +1,301 @@
+"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.RelayDaemon = void 0;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const config_1 = require("../config");
+const adapters_1 = require("./adapters");
+const queue_1 = require("./queue");
+const registry_1 = require("./registry");
+const socket_1 = require("./socket");
+const updates_1 = require("./updates");
+class RelayDaemon {
+    registry = new registry_1.SessionRegistry();
+    queue;
+    abort = new AbortController();
+    /** Live attach sockets by session name. */
+    attached = new Map();
+    /** Per-conversation delivery watermark — the 409 catch-up baseline. */
+    watermarks = new Map();
+    pending = [];
+    server;
+    startedAt = new Date().toISOString();
+    cursor = null;
+    polls = 0;
+    delivered = 0;
+    lastError;
+    /** Live session names from the last poll, for pruning and for `relay status`. */
+    liveSessions = [];
+    log;
+    constructor(opts = {}) {
+        this.log = opts.log ?? ((line) => console.log(`[relay] ${line}`));
+        this.queue = new queue_1.SessionQueue((session, batch) => this.deliver(session, batch), (session, err) => {
+            this.lastError = `delivery failed for ${session}: ${errText(err)}`;
+            this.log(this.lastError);
+        });
+    }
+    async start() {
+        // The DEVICE credential, not an agent token. A laptop has one device login
+        // and its sessions mint their own agents when they join, so no single agent
+        // token can see them all — the server fans out across this device's live
+        // sessions and tags every event with the session it belongs to.
+        const device = (0, config_1.loadDeviceCredentials)();
+        if (!device) {
+            throw new Error("this machine is not logged in to BayChat — run `npx baychat login`");
+        }
+        if (new Date(device.expiresAt).getTime() <= Date.now()) {
+            throw new Error(`device credential expired ${device.expiresAt} — run \`npx baychat login\``);
+        }
+        const auth = { baseUrl: device.baseUrl, token: device.token };
+        this.registry.load();
+        const sockPath = (0, socket_1.socketPath)();
+        if (await (0, socket_1.probeSocket)(sockPath)) {
+            throw new Error(`a relay is already listening on ${sockPath} — run \`baychat relay status\``);
+        }
+        (0, socket_1.unlinkStaleSocket)(sockPath);
+        this.server = net.createServer((sock) => this.onConnection(sock));
+        await new Promise((resolve, reject) => {
+            this.server.once("error", reject);
+            this.server.listen(sockPath, () => {
+                // 0600: the socket is a wake channel into this user's sessions. Anyone
+                // who can write to it can make a local agent take a turn.
+                try {
+                    fs.chmodSync(sockPath, 0o600);
+                }
+                catch {
+                    /* best effort — XDG_RUNTIME_DIR is already user-private */
+                }
+                resolve();
+            });
+        });
+        writePidFile();
+        this.log(`listening on ${sockPath} (pid ${process.pid}) as device "${device.user.name}"`);
+        this.log(`${this.registry.all().length} known session target(s)`);
+        await (0, updates_1.runUpdatesLoop)({
+            auth,
+            watermarks: this.watermarks,
+            onEvents: (events) => {
+                for (const e of events)
+                    this.onEvent(e);
+            },
+            onSessions: (names) => {
+                this.liveSessions = names;
+                const dropped = this.registry.pruneToLive(names);
+                for (const name of dropped)
+                    this.log(`session ended server-side, dropped: ${name}`);
+            },
+            onPoll: (cursor) => {
+                this.cursor = cursor;
+                this.polls += 1;
+            },
+            onError: (err, willRetry) => {
+                this.lastError = `${errText(err)}${willRetry ? " (retrying)" : ""}`;
+                this.log(this.lastError);
+            },
+            signal: this.abort.signal,
+        });
+    }
+    /**
+     * Route one event and record the conversation watermark.
+     *
+     * Routing is the SERVER's answer (`sessionName`), not a local guess: the
+     * device poll already knows which session agent each event was queued for.
+     * Deriving it here from a locally cached conversation list would go stale the
+     * moment a session joined another room — and a session that joins a room the
+     * relay has never heard of still gets woken, with no local bookkeeping.
+     */
+    onEvent(event) {
+        const { conversationId, sessionName, message } = event;
+        const prior = this.watermarks.get(conversationId);
+        if (!prior || message.createdAt > prior)
+            this.watermarks.set(conversationId, message.createdAt);
+        if (!sessionName) {
+            this.log(`event ${message.id} carries no session (renamed or ended mid-poll) — ignoring`);
+            return;
+        }
+        // No self-echo guard is needed: the bus never queues an agent its own
+        // message. The previous one compared a sender id to a session name and so
+        // could never have matched anything.
+        this.queue.push(sessionName, { ...message, conversationId });
+    }
+    /**
+     * Deliver one coalesced batch to one session. Runs under the queue's
+     * per-session lock, so an attach wake and a headless resume can never be in
+     * flight for the same session at once.
+     */
+    async deliver(session, batch) {
+        const target = this.registry.get(session);
+        if (!target) {
+            this.record({ kind: "ignored", reason: `unknown session ${session}` }, session, batch);
+            return;
+        }
+        const sock = this.attached.get(session);
+        if (sock && !sock.destroyed) {
+            // Live session: hand it the batch and let the harness re-invoke it. The
+            // attach client exits after one wake, which is what makes this a wake
+            // rather than a stream — and why the socket is dropped here.
+            (0, socket_1.writeFrame)(sock, { type: "wake", conversationId: batch[0].conversationId, messages: batch });
+            this.record({ kind: "woken", via: "attach", session }, session, batch);
+            return;
+        }
+        const adapter = (0, adapters_1.adapterFor)(target.runtime);
+        const check = adapter.canResume(target);
+        if (!check.ok) {
+            // The honest outcome: it reached this box, and nothing answered it.
+            this.record({ kind: "pending", session, reason: check.reason ?? "cannot resume" }, session, batch);
+            return;
+        }
+        const prompt = (0, adapters_1.buildWakePrompt)(session, batch[0].conversationId, batch);
+        const { file, args } = adapter.headlessCommand(target, prompt);
+        const { exitCode, stderr } = await (0, adapters_1.runHeadless)(file, args, { cwd: target.cwd });
+        if (exitCode !== 0) {
+            // A non-zero headless turn did not necessarily reply. Recording it as
+            // delivered would claim an answer we cannot evidence.
+            this.record({ kind: "pending", session, reason: `headless ${target.runtime} exited ${exitCode}: ${stderr.slice(0, 200)}` }, session, batch);
+            return;
+        }
+        this.record({ kind: "woken", via: "headless", session, exitCode }, session, batch);
+    }
+    record(outcome, session, batch) {
+        if (outcome.kind === "woken") {
+            this.delivered += batch.length;
+            this.log(`woke ${session} via ${outcome.via} with ${batch.length} message(s)`);
+            return;
+        }
+        if (outcome.kind === "pending") {
+            for (const m of batch) {
+                this.pending.push({
+                    session,
+                    conversationId: m.conversationId,
+                    messageId: m.id,
+                    reason: outcome.reason,
+                    at: new Date().toISOString(),
+                });
+            }
+            // Bounded: a session left detached for a week must not grow the heap.
+            while (this.pending.length > 200)
+                this.pending.shift();
+            this.log(`DELIVERY PENDING for ${session} (${batch.length} message(s)): ${outcome.reason}`);
+            return;
+        }
+        this.log(`ignored ${batch.length} message(s): ${outcome.reason}`);
+    }
+    onConnection(sock) {
+        let session;
+        const read = (0, socket_1.createFrameReader)((frame) => {
+            if (frame.type === "attach") {
+                session = frame.session;
+                this.registry.upsert({
+                    name: frame.session,
+                    runtime: frame.runtime,
+                    resumeId: frame.resumeId,
+                    cwd: frame.cwd,
+                });
+                this.attached.set(frame.session, sock);
+                this.registry.setAttached(frame.session, true);
+                (0, socket_1.writeFrame)(sock, { type: "attached", session: frame.session });
+                this.log(`attached: ${frame.session} (${frame.runtime})`);
+                return;
+            }
+            if (frame.type === "status") {
+                (0, socket_1.writeFrame)(sock, { type: "status-result", status: this.status() });
+                return;
+            }
+            if (frame.type === "stop") {
+                this.log("stop requested over socket");
+                (0, socket_1.writeFrame)(sock, { type: "status-result", status: this.status() });
+                setTimeout(() => void this.stop(), 50);
+                return;
+            }
+        }, (bad) => (0, socket_1.writeFrame)(sock, { type: "error", message: `bad frame: ${bad.slice(0, 80)}` }));
+        sock.on("data", read);
+        const drop = () => {
+            if (session && this.attached.get(session) === sock) {
+                this.attached.delete(session);
+                this.registry.setAttached(session, false);
+                this.log(`detached: ${session}`);
+            }
+        };
+        sock.on("close", drop);
+        sock.on("error", drop);
+    }
+    status() {
+        const sessions = this.registry.all().map((t) => ({
+            ...t,
+            attached: this.attached.has(t.name),
+        }));
+        return {
+            running: true,
+            pid: process.pid,
+            startedAt: this.startedAt,
+            cursor: this.cursor,
+            polls: this.polls,
+            delivered: this.delivered,
+            sessions,
+            pending: this.pending,
+            lastError: this.lastError,
+        };
+    }
+    async stop() {
+        this.abort.abort();
+        for (const sock of this.attached.values())
+            sock.destroy();
+        this.attached.clear();
+        await this.queue.idle();
+        await new Promise((resolve) => (this.server ? this.server.close(() => resolve()) : resolve()));
+        (0, socket_1.unlinkStaleSocket)((0, socket_1.socketPath)());
+        try {
+            fs.unlinkSync((0, socket_1.pidFilePath)());
+        }
+        catch {
+            /* already gone */
+        }
+        this.log("stopped");
+    }
+}
+exports.RelayDaemon = RelayDaemon;
+function writePidFile() {
+    try {
+        fs.writeFileSync((0, socket_1.pidFilePath)(), String(process.pid), { mode: 0o600 });
+    }
+    catch {
+        // The pid file is a convenience for `relay stop`; the socket is the real
+        // handle, so failing to write it is not fatal.
+    }
+}
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}