opensquid 0.5.441 → 0.5.449

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

@@ -1,177 +0,0 @@
-/**
- * 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

@@ -1,257 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}