opensquid 0.5.395

package/dist/chat/daemon/rpc.test.js

@@ -0,0 +1,177 @@
+/**
+ * RPC server + client integration tests (v0.7.1 Phase B).
+ *
+ * Exercise the full wire path: real Unix socket / named pipe, real
+ * JSON-RPC framing, real client → server round-trip. Stubs the gateway
+ * with a tiny fake so the test doesn't need bot tokens. The protocol
+ * IS the contract here, so synthetic transport would prove nothing.
+ */
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { ChatGateway } from "../gateway.js";
+import { DaemonClient, DaemonRpcError, DaemonUnreachableError } from "./rpc-client.js";
+import { daemonSockAddress } from "./protocol.js";
+import { RpcServer } from "./rpc-server.js";
+class StubAdapter {
+    platform;
+    constructor(platform) {
+        this.platform = platform;
+    }
+    start() {
+        return Promise.resolve();
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+    onMessage(_) {
+        /* noop */
+    }
+    send(msg) {
+        return Promise.resolve({
+            platform: this.platform,
+            channel: msg.channel,
+            messageId: `stub-${Date.now()}`,
+            deliveredAt: new Date(),
+        });
+    }
+    identity() {
+        return Promise.resolve({ username: `stub-${this.platform}`, nativeId: "0" });
+    }
+}
+let tmpRoot;
+let server;
+let prevOpensquidHome;
+beforeEach(async () => {
+    tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opensquid-rpc-test-"));
+    // The protocol's address calculation looks at process.env.OPENSQUID_HOME
+    // via daemonPaths → resolveDataRoot. Set it for the duration of the
+    // test so the client and server resolve the same address.
+    prevOpensquidHome = process.env.OPENSQUID_HOME;
+    process.env.OPENSQUID_HOME = tmpRoot;
+});
+afterEach(async () => {
+    if (server) {
+        try {
+            await server.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    if (prevOpensquidHome === undefined)
+        delete process.env.OPENSQUID_HOME;
+    else
+        process.env.OPENSQUID_HOME = prevOpensquidHome;
+    await fs.rm(tmpRoot, { recursive: true, force: true });
+});
+describe("daemonSockAddress", () => {
+    it("returns a filesystem path on POSIX, named pipe on Windows", () => {
+        const addr = daemonSockAddress(tmpRoot);
+        if (os.platform() === "win32") {
+            expect(addr).toMatch(/^\\\\\.\\pipe\\opensquid-chat-daemon-/);
+        }
+        else {
+            expect(addr).toBe(path.join(tmpRoot, "chat-daemon.sock"));
+        }
+    });
+});
+describe("RpcServer + DaemonClient round-trip", () => {
+    it("ping returns pong, pid, and version", async () => {
+        const gw = new ChatGateway([new StubAdapter("telegram")]);
+        await gw.start();
+        server = new RpcServer({ gateway: gw, dataRoot: tmpRoot, version: "test-v1" });
+        await server.listen();
+        const client = new DaemonClient({ dataRoot: tmpRoot });
+        const res = await client.ping();
+        expect(res.pong).toBe(true);
+        expect(res.pid).toBe(process.pid);
+        expect(res.version).toBe("test-v1");
+    });
+    it("list_channels surfaces the gateway's active platforms", async () => {
+        const gw = new ChatGateway([new StubAdapter("telegram"), new StubAdapter("discord")]);
+        await gw.start();
+        server = new RpcServer({ gateway: gw, dataRoot: tmpRoot });
+        await server.listen();
+        const client = new DaemonClient({ dataRoot: tmpRoot });
+        const res = await client.listChannels();
+        expect(res.active_platforms).toEqual(expect.arrayContaining(["telegram", "discord"]));
+        expect(res.uptime_ms).toBeGreaterThanOrEqual(0);
+    });
+    it("send delegates to gateway.send and returns the message id + delivery time", async () => {
+        const gw = new ChatGateway([new StubAdapter("telegram")]);
+        await gw.start();
+        server = new RpcServer({ gateway: gw, dataRoot: tmpRoot });
+        await server.listen();
+        const client = new DaemonClient({ dataRoot: tmpRoot });
+        const res = await client.send({ channel: "telegram:12345", text: "hello world" });
+        expect(res.ok).toBe(true);
+        expect(res.platform).toBe("telegram");
+        expect(res.message_id).toMatch(/^stub-/);
+        expect(res.delivered_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    });
+    it("send with missing params returns INVALID_PARAMS (-32602)", async () => {
+        const gw = new ChatGateway([new StubAdapter("telegram")]);
+        await gw.start();
+        server = new RpcServer({ gateway: gw, dataRoot: tmpRoot });
+        await server.listen();
+        const client = new DaemonClient({ dataRoot: tmpRoot });
+        await expect(client.call("send", {})).rejects.toMatchObject({
+            name: "DaemonRpcError",
+            code: -32602,
+        });
+    });
+    it("unknown method returns METHOD_NOT_FOUND (-32601)", async () => {
+        const gw = new ChatGateway([new StubAdapter("telegram")]);
+        await gw.start();
+        server = new RpcServer({ gateway: gw, dataRoot: tmpRoot });
+        await server.listen();
+        const client = new DaemonClient({ dataRoot: tmpRoot });
+        await expect(client.call("does_not_exist", {})).rejects.toMatchObject({
+            name: "DaemonRpcError",
+            code: -32601,
+        });
+    });
+    it("pipelines multiple requests on independent connections", async () => {
+        const gw = new ChatGateway([new StubAdapter("telegram")]);
+        await gw.start();
+        server = new RpcServer({ gateway: gw, dataRoot: tmpRoot });
+        await server.listen();
+        const client = new DaemonClient({ dataRoot: tmpRoot });
+        const results = await Promise.all([client.ping(), client.ping(), client.ping()]);
+        expect(results.length).toBe(3);
+        for (const r of results)
+            expect(r.pong).toBe(true);
+    });
+    it("DaemonUnreachableError when no server is listening", async () => {
+        // Don't start the server.
+        const client = new DaemonClient({ dataRoot: tmpRoot, connectTimeoutMs: 250 });
+        await expect(client.ping()).rejects.toBeInstanceOf(DaemonUnreachableError);
+    });
+    it("DaemonUnreachableError after server.close()", async () => {
+        const gw = new ChatGateway([new StubAdapter("telegram")]);
+        await gw.start();
+        server = new RpcServer({ gateway: gw, dataRoot: tmpRoot });
+        await server.listen();
+        await server.close();
+        const client = new DaemonClient({ dataRoot: tmpRoot, connectTimeoutMs: 250 });
+        await expect(client.ping()).rejects.toBeInstanceOf(DaemonUnreachableError);
+    });
+    it("DaemonRpcError surfaces both the message and the code", async () => {
+        const gw = new ChatGateway([new StubAdapter("telegram")]);
+        await gw.start();
+        server = new RpcServer({ gateway: gw, dataRoot: tmpRoot });
+        await server.listen();
+        const client = new DaemonClient({ dataRoot: tmpRoot });
+        try {
+            await client.call("does_not_exist", {});
+            throw new Error("expected to throw");
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(DaemonRpcError);
+            expect(err.code).toBe(-32601);
+            expect(err.message).toContain("unknown method");
+        }
+    });
+});

package/dist/chat/daemon/subscribers.js

@@ -0,0 +1,257 @@
+/**
+ * subscribers.ts — TPS.6 patch 1 (v0.5.125) subscriber registry.
+ *
+ * In-process registry of long-lived MCP-bridge subscribers. Each
+ * subscriber is an MCP bridge subprocess that opened a UDS connection
+ * and called `subscribe` with a session_id + chat_ids selector. The
+ * daemon's `gateway.onMessage` handler (wired in TPS.6 patch 2) iterates
+ * registry.forChatId(...) and pushes one notification per subscriber.
+ *
+ * Two indexes:
+ *   - byId: session_id → Subscriber (idempotency + unregister)
+ *   - byChat: chat_id → Set<session_id> (broadcast lookup)
+ *   - wildcardIds: Set<session_id> for subscribers with chat_ids=[]
+ *
+ * Per-subscriber send queue (bounded, FIFO). When socket.write returns
+ * false (kernel buffer full), notifications are queued and drained on
+ * the 'drain' event. Queue overflow drops oldest with a logged warning.
+ *
+ * Lifecycle: register() returns the Subscriber handle; socket close /
+ * error events auto-unregister via the listener installed in register().
+ * Idempotency: re-register on the same session_id evicts the old slot
+ * (with a graceful close of the old socket) before installing the new.
+ *
+ * No timers; no background work. Purely event-driven from the socket
+ * lifecycle + broadcast invocations.
+ *
+ * Rebuild path: ad-hoc tsc invocation (see telegram.ts header).
+ */
+export const SUBSCRIBER_QUEUE_CAP = 100;
+export class SubscriberRegistry {
+    byId = new Map();
+    byChat = new Map();
+    wildcardIds = new Set();
+    /**
+     * Install a new subscriber. If `session_id` already exists, the old
+     * slot is gracefully closed first (idempotent re-register on
+     * MCP-bridge reconnect).
+     *
+     * Returns the SubscriberRecord. Callers must NOT mutate it.
+     */
+    register(args) {
+        // Evict any existing slot first.
+        const existing = this.byId.get(args.session_id);
+        if (existing) {
+            this.removeFromIndexes(existing.record);
+            this.detachListeners(existing);
+            try {
+                existing.record.socket.end();
+            }
+            catch {
+                /* socket already closed */
+            }
+            this.byId.delete(args.session_id);
+        }
+        const record = {
+            session_id: args.session_id,
+            workspace_uuid: args.workspace_uuid,
+            workspace_path: args.workspace_path,
+            chat_ids: [...args.chat_ids],
+            wildcard: args.chat_ids.length === 0,
+            socket: args.socket,
+            dropped_count: 0,
+        };
+        const entry = {
+            record,
+            queue: [],
+            paused: false,
+            onClose: () => this.unregister(args.session_id),
+            onError: () => this.unregister(args.session_id),
+            onDrain: () => this.drainQueue(entry),
+        };
+        args.socket.on("close", entry.onClose);
+        args.socket.on("error", entry.onError);
+        args.socket.on("drain", entry.onDrain);
+        this.byId.set(args.session_id, entry);
+        if (record.wildcard) {
+            this.wildcardIds.add(args.session_id);
+        }
+        else {
+            for (const chatId of record.chat_ids) {
+                let bucket = this.byChat.get(chatId);
+                if (!bucket) {
+                    bucket = new Set();
+                    this.byChat.set(chatId, bucket);
+                }
+                bucket.add(args.session_id);
+            }
+        }
+        return record;
+    }
+    /**
+     * Remove a subscriber (by session_id). Idempotent — no-op if the
+     * session is not registered. The socket is NOT closed by unregister
+     * (caller decides; auto-unregister-on-close hooks don't want to
+     * loop). Returns true iff something was removed.
+     */
+    unregister(session_id) {
+        const entry = this.byId.get(session_id);
+        if (!entry)
+            return false;
+        this.removeFromIndexes(entry.record);
+        this.detachListeners(entry);
+        this.byId.delete(session_id);
+        return true;
+    }
+    /** All subscribers whose selector matches `chat_id` (literal chat or wildcard). */
+    forChatId(chat_id) {
+        const matches = [];
+        const specific = this.byChat.get(chat_id);
+        if (specific) {
+            for (const id of specific) {
+                const entry = this.byId.get(id);
+                if (entry)
+                    matches.push(entry.record);
+            }
+        }
+        for (const id of this.wildcardIds) {
+            const entry = this.byId.get(id);
+            if (entry)
+                matches.push(entry.record);
+        }
+        return matches;
+    }
+    /** Look up by session_id. */
+    get(session_id) {
+        return this.byId.get(session_id)?.record;
+    }
+    /** Total registered subscribers (test/diag use). */
+    size() {
+        return this.byId.size;
+    }
+    /**
+     * Push a notification to one subscriber. Returns true if the write
+     * went out cleanly, false if it was queued (or dropped on overflow).
+     * Never throws — write failures are logged + cause eviction.
+     */
+    push(session_id, notif) {
+        const entry = this.byId.get(session_id);
+        if (!entry)
+            return false;
+        const line = JSON.stringify(notif) + "\n";
+        if (entry.paused) {
+            this.enqueue(entry, line);
+            return false;
+        }
+        let ok;
+        try {
+            ok = entry.record.socket.write(line);
+        }
+        catch {
+            // Write to a half-closed socket — evict.
+            this.unregister(session_id);
+            return false;
+        }
+        if (!ok) {
+            entry.paused = true;
+        }
+        return ok;
+    }
+    /**
+     * Broadcast a notification to every subscriber matching `chat_id`.
+     * Returns the count of attempted deliveries (includes queued ones).
+     */
+    broadcast(chat_id, notif) {
+        let count = 0;
+        for (const subscriber of this.forChatId(chat_id)) {
+            this.push(subscriber.session_id, notif);
+            count += 1;
+        }
+        return count;
+    }
+    /**
+     * Send a `daemon_shutdown` notification to every subscriber + close
+     * their sockets. Called from worker SIGTERM handler.
+     */
+    shutdown(reason, restartExpectedAt) {
+        const notif = {
+            jsonrpc: "2.0",
+            method: "daemon_shutdown",
+            params: restartExpectedAt
+                ? { reason, restart_expected_at: restartExpectedAt }
+                : { reason },
+        };
+        for (const session_id of [...this.byId.keys()]) {
+            this.push(session_id, notif);
+            const entry = this.byId.get(session_id);
+            if (entry) {
+                try {
+                    entry.record.socket.end();
+                }
+                catch {
+                    /* already closed */
+                }
+            }
+        }
+    }
+    // -----------------------------------------------------------------
+    // Internals
+    // -----------------------------------------------------------------
+    enqueue(entry, line) {
+        if (entry.queue.length >= SUBSCRIBER_QUEUE_CAP) {
+            // Drop oldest, keep newest. Telegram messages are time-sensitive;
+            // a backlog of >100 means the subscriber is hopelessly behind
+            // and the newest message is more valuable than the oldest.
+            entry.queue.shift();
+            entry.record.dropped_count += 1;
+            process.stderr.write(`[subscribers] queue overflow for session=${entry.record.session_id}; dropped oldest (total dropped=${String(entry.record.dropped_count)})\n`);
+        }
+        entry.queue.push(line);
+    }
+    drainQueue(entry) {
+        while (entry.queue.length > 0) {
+            const line = entry.queue[0];
+            if (line === undefined)
+                break;
+            let ok;
+            try {
+                ok = entry.record.socket.write(line);
+            }
+            catch {
+                this.unregister(entry.record.session_id);
+                return;
+            }
+            entry.queue.shift();
+            if (!ok) {
+                // Re-paused mid-drain — wait for next 'drain'.
+                return;
+            }
+        }
+        entry.paused = false;
+    }
+    removeFromIndexes(record) {
+        if (record.wildcard) {
+            this.wildcardIds.delete(record.session_id);
+        }
+        else {
+            for (const chatId of record.chat_ids) {
+                const bucket = this.byChat.get(chatId);
+                if (!bucket)
+                    continue;
+                bucket.delete(record.session_id);
+                if (bucket.size === 0)
+                    this.byChat.delete(chatId);
+            }
+        }
+    }
+    detachListeners(entry) {
+        try {
+            entry.record.socket.off("close", entry.onClose);
+            entry.record.socket.off("error", entry.onError);
+            entry.record.socket.off("drain", entry.onDrain);
+        }
+        catch {
+            /* socket already destroyed */
+        }
+    }
+}

package/dist/chat/daemon/worker.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Chat-daemon worker entrypoint (v0.7.1 Phase A).
+ *
+ * Spawned as a detached child by `lifecycle.startDaemon()`. Owns the
+ * single long-poll connection per chat platform. The MCP server side
+ * stays out of the polling business entirely — outbound RPC (Phase B)
+ * and inbox tailing (Phase C) replace the in-process gateway.
+ *
+ * Lifecycle inside the worker:
+ *   1. Write our PID to ~/.opensquid/chat-daemon.pid
+ *   2. Build the chat gateway from ~/.opensquid/config.json
+ *   3. Start every configured adapter (their long-poll loops run as
+ *      side effects of start())
+ *   4. Install SIGTERM / SIGINT handlers that stop the gateway and
+ *      remove the pidfile before exit
+ *   5. Park on process.stdin (which is /dev/null in detached mode)
+ *      so the event loop stays alive
+ *
+ * Crash behavior: any unhandled exception from gateway.start() prints
+ * to the (parent-redirected) log file and exits non-zero. The pidfile
+ * is cleaned up in the SIGTERM handler — if we crash before installing
+ * it, the pidfile may linger, and the next `status` call will report
+ * `stale_pid` (lifecycle.startDaemon cleans up stale pidfiles before
+ * spawning).
+ */
+export declare function runDaemonWorker(dataRoot?: string): Promise<never>;
+//# sourceMappingURL=worker.d.ts.map

package/dist/chat/daemon/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../src.legacy/chat/daemon/worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAkBH,wBAAsB,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAkLvE"}