@securecoms/agent-bridge 0.1.0

package/dist/ws-server.js

@@ -0,0 +1,254 @@
+import { WebSocketServer, WebSocket } from "ws";
+import { ChannelPendingError, RateLimitedError } from "./bridge-agent.js";
+import { tokenMatches, bearerFrom, originHostAllowed } from "./auth.js";
+import { wsErrorFrame } from "./errors.js";
+const PING_INTERVAL_MS = 30_000;
+/** Pull the local token from `?token=` first, then `Authorization: Bearer`. */
+function tokenFromUpgrade(req) {
+    try {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const q = url.searchParams.get("token");
+        if (q)
+            return q;
+    }
+    catch {
+        /* malformed URL — fall through to header */
+    }
+    return bearerFrom(req.headers.authorization);
+}
+function authedUpgrade(req, opts) {
+    if (!tokenMatches(tokenFromUpgrade(req), opts.token))
+        return false;
+    if (!originHostAllowed({ origin: req.headers.origin, host: req.headers.host }, opts.allowOrigins)) {
+        return false;
+    }
+    return true;
+}
+export function attachAgentWebSocket(server, agent, opts) {
+    const wss = new WebSocketServer({ server, path: "/v1/ws" });
+    // Server-side keepalive: ping every interval, drop sockets that miss a pong.
+    const keepalive = setInterval(() => {
+        for (const client of wss.clients) {
+            const sock = client;
+            if (sock.isAlive === false) {
+                sock.terminate();
+                continue;
+            }
+            sock.isAlive = false;
+            try {
+                sock.ping();
+            }
+            catch {
+                /* socket on its way out */
+            }
+        }
+    }, PING_INTERVAL_MS);
+    // Don't let the interval pin the process open.
+    if (typeof keepalive.unref === "function")
+        keepalive.unref();
+    // One agent per process: the live connection currently owning the inbound
+    // stream, carrying its cleanup so a replacement can drain it synchronously.
+    let current = null;
+    wss.on("connection", (sock, req) => {
+        // Auth is enforced here (not verifyClient) so we can close with a clean
+        // 1008 policy-violation code that the client observes, rather than a bare
+        // HTTP handshake rejection.
+        if (!authedUpgrade(req, opts)) {
+            sock.close(1008, "unauthorized");
+            return;
+        }
+        // Single consumer, newest wins (mirrors the SSE path). Close the prior
+        // socket AND run its cleanup synchronously, so its un-acked in-flight is
+        // re-buffered (in FIFO order) BEFORE this socket's initial flush — otherwise
+        // the replaced socket's async close could re-buffer those messages after
+        // this socket has already consumed newer ones, reordering delivery.
+        if (current && current.sock !== sock) {
+            const prior = current;
+            if (prior.sock.readyState === WebSocket.OPEN) {
+                prior.sock.close(1000, "replaced by newer connection");
+            }
+            prior.cleanup();
+        }
+        sock.isAlive = true;
+        sock.on("pong", () => {
+            sock.isAlive = true;
+        });
+        // Delivered-but-unacked messages, keyed by message_id in delivery order.
+        // Held until the agent acks; re-buffered on disconnect (at-least-once).
+        const inflight = new Map();
+        const flush = () => {
+            if (sock.readyState !== WebSocket.OPEN)
+                return;
+            const batch = agent.takeBuffered();
+            for (let i = 0; i < batch.length; i++) {
+                if (sock.readyState !== WebSocket.OPEN) {
+                    // Socket closing mid-flush — give the rest back to the buffer.
+                    agent.requeueFront(batch.slice(i));
+                    return;
+                }
+                const frame = { type: "message", ...batch[i] };
+                try {
+                    sock.send(JSON.stringify(frame));
+                    inflight.set(batch[i].message_id, batch[i]);
+                }
+                catch {
+                    agent.requeueFront(batch.slice(i));
+                    return;
+                }
+            }
+        };
+        const unsubscribe = agent.subscribe(flush);
+        let cleaned = false;
+        const cleanup = () => {
+            if (cleaned)
+                return;
+            cleaned = true;
+            unsubscribe();
+            // Re-buffer anything delivered but never acked, in original order, so the
+            // next consumer redelivers it rather than the daemon dropping it. Poke
+            // listeners so a still-connected replacement consumer drains it now.
+            if (inflight.size) {
+                agent.requeueFront([...inflight.values()]);
+                inflight.clear();
+                agent.wakeListeners();
+            }
+            if (current?.sock === sock)
+                current = null;
+        };
+        current = { sock, cleanup };
+        sock.on("close", cleanup);
+        sock.on("error", cleanup);
+        sock.on("message", (data) => {
+            void handleInbound(sock, agent, data, inflight);
+        });
+        // Flush anything already buffered for an agent that connects after delivery.
+        flush();
+    });
+    return {
+        close() {
+            clearInterval(keepalive);
+            for (const client of wss.clients) {
+                try {
+                    client.terminate();
+                }
+                catch {
+                    /* already gone */
+                }
+            }
+            wss.close();
+        },
+    };
+}
+function sendJson(sock, body) {
+    if (sock.readyState !== WebSocket.OPEN)
+        return;
+    try {
+        sock.send(JSON.stringify(body));
+    }
+    catch {
+        /* socket closing */
+    }
+}
+async function handleInbound(sock, agent, data, inflight) {
+    let msg;
+    try {
+        msg = JSON.parse(data.toString("utf8"));
+    }
+    catch {
+        sendJson(sock, wsErrorFrame("invalid_request"));
+        return;
+    }
+    if (typeof msg !== "object" || msg === null) {
+        sendJson(sock, wsErrorFrame("invalid_request"));
+        return;
+    }
+    const m = msg;
+    if (m.type === "ack") {
+        // Consume confirmation: drop the message from in-flight so it is not
+        // re-buffered on disconnect. Fire-and-forget (no reply frame).
+        if (typeof m.message_id !== "string" || !m.message_id) {
+            sendJson(sock, wsErrorFrame("invalid_request"));
+            return;
+        }
+        inflight.delete(m.message_id);
+        return;
+    }
+    if (m.type === "send") {
+        if (typeof m.channel_id !== "string" || !m.channel_id) {
+            sendJson(sock, wsErrorFrame("invalid_request"));
+            return;
+        }
+        if (m.a2a && typeof m.a2a === "object") {
+            const a = m.a2a;
+            if (typeof a.a2a_version !== "string" || !a.a2a_version || (a.kind !== "message" && a.kind !== "task" && a.kind !== "artifact") || typeof a.object !== "object" || a.object === null) {
+                sendJson(sock, wsErrorFrame("invalid_request"));
+                return;
+            }
+            try {
+                const r = await agent.sendA2A(m.channel_id, { a2a_version: a.a2a_version, kind: a.kind, object: a.object });
+                sendJson(sock, { type: "sent", message_id: r.message_id });
+            }
+            catch (e) {
+                if (e instanceof ChannelPendingError) {
+                    sendJson(sock, wsErrorFrame("channel_pending"));
+                }
+                else if (e instanceof RateLimitedError) {
+                    sendJson(sock, wsErrorFrame("rate_limited"));
+                }
+                else {
+                    sendJson(sock, wsErrorFrame("invalid_request"));
+                }
+            }
+            return;
+        }
+        if (typeof m.text !== "string" || !m.text) {
+            sendJson(sock, wsErrorFrame("invalid_request"));
+            return;
+        }
+        const idempotencyKey = typeof m.idempotency_key === "string" ? m.idempotency_key : undefined;
+        try {
+            const r = await agent.send(m.channel_id, m.text, idempotencyKey);
+            sendJson(sock, { type: "sent", message_id: r.message_id });
+        }
+        catch (e) {
+            if (e instanceof ChannelPendingError) {
+                sendJson(sock, wsErrorFrame("channel_pending"));
+            }
+            else if (e instanceof RateLimitedError) {
+                sendJson(sock, wsErrorFrame("rate_limited"));
+            }
+            else {
+                sendJson(sock, wsErrorFrame("invalid_request"));
+            }
+        }
+        return;
+    }
+    if (m.type === "status") {
+        const states = ["idle", "working", "stalled", "error"];
+        if (typeof m.channel_id !== "string" ||
+            !m.channel_id ||
+            typeof m.state !== "string" ||
+            !states.includes(m.state)) {
+            sendJson(sock, wsErrorFrame("invalid_request"));
+            return;
+        }
+        const detail = typeof m.detail === "string" ? m.detail : undefined;
+        try {
+            await agent.reportStatus(m.channel_id, m.state, detail);
+            sendJson(sock, { type: "ok" });
+        }
+        catch (e) {
+            if (e instanceof ChannelPendingError) {
+                sendJson(sock, wsErrorFrame("channel_pending"));
+            }
+            else if (e instanceof RateLimitedError) {
+                sendJson(sock, wsErrorFrame("rate_limited"));
+            }
+            else {
+                sendJson(sock, wsErrorFrame("invalid_request"));
+            }
+        }
+        return;
+    }
+    sendJson(sock, wsErrorFrame("invalid_request"));
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@securecoms/agent-bridge",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "agent-bridge": "dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && node esbuild.config.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@agentvault/crypto": "^0.4.1",
+    "@noble/curves": "^1.9.7",
+    "@noble/hashes": "^1.4.0",
+    "@noble/ciphers": "^1.3.0",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
+    "ws": "^8.21.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    "esbuild": "0.24.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  }
+}