@securecoms/agent-bridge 0.11.0 → 0.11.2

package/dist/config.js

@@ -0,0 +1,74 @@
+import { readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+const REQUIRED = ["api_key", "identity_id", "device_id", "signing_private_key", "enclave_id", "api_base"];
+export function loadConfig(opts) {
+    const raw = readFileSync(opts.credentialPath, "utf8");
+    // Perms check (advisory): warn to STDERR if not owner-only.
+    try {
+        const mode = statSync(opts.credentialPath).mode & 0o777;
+        if (mode & 0o077)
+            process.stderr.write(`[bridge] WARNING: credential file ${opts.credentialPath} permission ${mode.toString(8)} is not 0600 — tighten it (chmod 600).\n`);
+    }
+    catch { /* stat best-effort */ }
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("credential file is not valid JSON");
+    }
+    for (const k of REQUIRED)
+        if (typeof json[k] !== "string" || !json[k])
+            throw new Error(`credential file missing required field: ${k}`);
+    const storePath = opts.storePath ?? join(dirname(opts.credentialPath), "bridge-state.db");
+    // Optional agent name for the room @mention filter: prefer agent_name, else display_name.
+    const agentName = typeof json.agent_name === "string" && json.agent_name
+        ? json.agent_name
+        : typeof json.display_name === "string" && json.display_name
+            ? json.display_name
+            : undefined;
+    const rateLimitCapacity = typeof json.rate_limit_capacity === "number" ? json.rate_limit_capacity : 20;
+    const rateLimitRefillPerMinute = typeof json.rate_limit_refill_per_minute === "number" ? json.rate_limit_refill_per_minute : 20;
+    return {
+        apiKey: json.api_key, identityId: json.identity_id, deviceId: json.device_id,
+        signingPrivateKey: json.signing_private_key, enclaveId: json.enclave_id,
+        apiBase: json.api_base, storePath, agentName,
+        rateLimitCapacity, rateLimitRefillPerMinute,
+    };
+}
+function arg(argv, flag) {
+    const i = argv.indexOf(flag);
+    return i >= 0 ? argv[i + 1] : undefined;
+}
+function args(argv, flag) {
+    const out = [];
+    for (let i = 0; i < argv.length; i++)
+        if (argv[i] === flag && argv[i + 1])
+            out.push(argv[i + 1]);
+    return out;
+}
+export function parseDaemonArgs(argv, env) {
+    const tlsCert = arg(argv, "--tls-cert") ?? env.SECURECOMS_TLS_CERT;
+    const tlsKey = arg(argv, "--tls-key") ?? env.SECURECOMS_TLS_KEY;
+    return {
+        port: Number(arg(argv, "--port") ?? env.SECURECOMS_PORT ?? 7077),
+        bind: arg(argv, "--bind") ?? env.SECURECOMS_BIND ?? "127.0.0.1",
+        tokenFile: arg(argv, "--token-file") ?? env.SECURECOMS_TOKEN_FILE,
+        token: arg(argv, "--token") ?? env.SECURECOMS_LOCAL_TOKEN,
+        tls: Boolean(tlsCert && tlsKey),
+        tlsCert,
+        tlsKey,
+        allowOrigins: args(argv, "--allow-origin"),
+    };
+}
+export function isLoopback(host) {
+    return (host === "localhost" ||
+        host === "::1" ||
+        host === "[::1]" ||
+        /^127\./.test(host));
+}
+export function validateBind(bind, tls) {
+    if (!isLoopback(bind) && !tls) {
+        throw new Error(`refusing non-loopback bind '${bind}' without TLS — supply --tls-cert and --tls-key for cross-host, or bind a loopback address`);
+    }
+}

package/dist/coordination.js

@@ -0,0 +1,63 @@
+// Multi-agent ROOM coordination floor — @mention filter.
+//
+// Ported faithfully from the gen2 OpenClaw plugin
+// (packages/plugin/src/openclaw-entry.ts: _parseMentions / _shouldProcessRoomMessage /
+// _ownRoomNames). Pure functions only — no rate limiter (a later slice), no globals,
+// no console output. Semantics must match gen2 exactly.
+/** Extract @mention names from plaintext. Returns lowercased names. */
+export function parseMentions(text) {
+    const mentions = [];
+    // Match @word at a word boundary — supports multiple via sequential matching.
+    const re = /@(\w[\w]*)/gi;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        mentions.push(match[1].toLowerCase());
+    }
+    return mentions;
+}
+/**
+ * Lower-cased set of names that count as "this agent" in a room: framework
+ * agentName + its first word, accountId + its first word, and (when known) the
+ * AgentVault room display_name + its first word. First word = split on
+ * whitespace or "(".
+ */
+export function ownRoomNames(agentName, accountId, roomDisplayName) {
+    const names = new Set();
+    const add = (n) => {
+        if (!n)
+            return;
+        const lower = n.toLowerCase();
+        names.add(lower);
+        names.add(lower.split(/[\s(]/)[0]);
+    };
+    add(agentName);
+    add(accountId);
+    add(roomDisplayName);
+    return names;
+}
+/**
+ * Whether this agent should process a room message based on its @mentions.
+ *
+ * Loop prevention is the rate-limiter's job (a later slice), so this filter does
+ * NOT gate on senderIsAgent — every message is processed unless it @mentions a
+ * *different* agent specifically:
+ *   - no mentions            → true (broadcast)
+ *   - @all / @everyone       → true
+ *   - this agent is mentioned → true
+ *   - else (a different agent is mentioned) → false
+ */
+export function shouldProcessRoomMessage(plaintext, agentName, accountId, opts) {
+    const mentions = parseMentions(plaintext);
+    // No mentions → broadcast to all agents.
+    if (mentions.length === 0)
+        return true;
+    // @all / @everyone → all agents process.
+    if (mentions.includes("all") || mentions.includes("everyone"))
+        return true;
+    // This agent addressed by framework name / accountId / room display_name.
+    const ownNames = ownRoomNames(agentName, accountId, opts?.roomDisplayName);
+    if (mentions.some((m) => ownNames.has(m)))
+        return true;
+    // Has @mentions but none match this agent — skip.
+    return false;
+}

package/dist/errors.js

@@ -0,0 +1,25 @@
+export const BRIDGE_ERRORS = {
+    unauthorized: { http: 401, message: "missing or invalid bearer token" },
+    forbidden_origin: { http: 403, message: "origin or host not allowed" },
+    not_found: { http: 404, message: "no such route" },
+    invalid_request: { http: 400, message: "request failed validation" },
+    invalid_json: { http: 400, message: "request body is not valid JSON" },
+    body_too_large: { http: 400, message: "request body exceeds the size limit" },
+    channel_pending: { http: 503, message: "channel not yet admitted; retry shortly" },
+    rate_limited: { http: 429, message: "rate limit exceeded; retry shortly" },
+    internal: { http: 500, message: "internal error" },
+};
+/** The shared error payload (used as-is by HTTP, and spread into the WS frame). */
+export function errorBody(code, detail) {
+    const body = { error: code, message: BRIDGE_ERRORS[code].message };
+    if (detail !== undefined)
+        body.detail = detail;
+    return body;
+}
+export function httpStatus(code) {
+    return BRIDGE_ERRORS[code].http;
+}
+/** WebSocket error frame: the shared body under a `{type:"error"}` envelope. */
+export function wsErrorFrame(code, detail) {
+    return { type: "error", ...errorBody(code, detail) };
+}

package/dist/http-server.js

@@ -0,0 +1,220 @@
+import { createServer as createHttp } from "node:http";
+import { createServer as createHttps } from "node:https";
+import { z } from "zod";
+import { ChannelPendingError, RateLimitedError, InvalidPathError } from "./bridge-agent.js";
+import { bearerFrom, tokenMatches, originHostAllowed } from "./auth.js";
+import { errorBody, httpStatus } from "./errors.js";
+export function writeSse(res, msgs) {
+    for (let i = 0; i < msgs.length; i++) {
+        if (res.destroyed || res.writableEnded)
+            return msgs.slice(i);
+        try {
+            res.write(`event: message\ndata: ${JSON.stringify(msgs[i])}\n\n`);
+        }
+        catch {
+            return msgs.slice(i);
+        }
+    }
+    return [];
+}
+/** The daemon's self-describing capability contract (A2A-style discovery). */
+export function capabilities(opts) {
+    return {
+        api_version: "1",
+        receive_modes: ["longpoll", "sse", ...(opts.websocket ? ["websocket"] : [])],
+        send_types: ["text", "agent_status", "a2a"],
+        webhook_push: false, // B3: A2A-style push-notification config (ciphertext/wake-only)
+    };
+}
+const SEND_CAP = 64 * 1024;
+const OTHER_CAP = 8 * 1024;
+const a2aSchema = z.object({
+    a2a_version: z.string().min(1),
+    kind: z.enum(["message", "task", "artifact"]),
+    object: z.record(z.unknown()),
+});
+const sendAttachmentSchema = z.object({
+    channel_id: z.string().min(1),
+    path: z.string().min(1),
+    caption: z.string().optional(),
+});
+const sendSchema = z.object({
+    channel_id: z.string().min(1),
+    text: z.string().optional(),
+    idempotency_key: z.string().optional(),
+    a2a: a2aSchema.optional(),
+}).refine((d) => typeof d.text === "string" || d.a2a !== undefined, {
+    message: "send requires either text or a2a",
+});
+const statusSchema = z.object({
+    channel_id: z.string().min(1),
+    state: z.enum(["idle", "working", "stalled", "error"]),
+    detail: z.string().optional(),
+});
+function json(res, status, body) {
+    const s = JSON.stringify(body);
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(s);
+}
+/** Render a canonical error to its mapped HTTP status + shared body. */
+function jsonError(res, code, detail) {
+    json(res, httpStatus(code), errorBody(code, detail));
+}
+function readBody(req, cap) {
+    return new Promise((resolve, reject) => {
+        let size = 0;
+        let done = false;
+        const chunks = [];
+        const onData = (c) => {
+            if (done)
+                return;
+            size += c.length;
+            if (size > cap) {
+                // Stop consuming and let the response (400) flush; do NOT destroy the
+                // socket here, that races with the response write and surfaces to the
+                // client as "other side closed" instead of a clean 400.
+                done = true;
+                req.removeListener("data", onData);
+                req.pause();
+                reject(new Error("body_too_large"));
+                return;
+            }
+            chunks.push(c);
+        };
+        req.on("data", onData);
+        req.on("end", () => { if (!done) {
+            done = true;
+            resolve(Buffer.concat(chunks).toString("utf8"));
+        } });
+        req.on("error", (e) => { if (!done) {
+            done = true;
+            reject(e);
+        } });
+    });
+}
+export function createHttpServer(agent, opts) {
+    // SSE state is wired in the next task; declared here so closeAllSseStreams exists.
+    let closeSse = () => { };
+    let sse = null;
+    const tearDownSse = () => {
+        if (!sse)
+            return;
+        sse.unsubscribe();
+        clearInterval(sse.keepalive);
+        try {
+            sse.res.end();
+        }
+        catch { /* already closed */ }
+        sse = null;
+    };
+    closeSse = tearDownSse; // replaces the no-op placeholder
+    const handler = async (req, res) => {
+        try {
+            const url = new URL(req.url ?? "/", "http://localhost");
+            const path = url.pathname;
+            const method = req.method ?? "GET";
+            if (method === "GET" && path === "/healthz") {
+                return json(res, 200, { ...agent.health(), capabilities: capabilities(opts) });
+            }
+            // Auth + origin/host for everything else.
+            if (!tokenMatches(bearerFrom(req.headers.authorization), opts.token)) {
+                return jsonError(res, "unauthorized");
+            }
+            if (!originHostAllowed({ origin: req.headers.origin, host: req.headers.host }, opts.allowOrigins)) {
+                return jsonError(res, "forbidden_origin");
+            }
+            if (method === "GET" && path === "/v1/channels") {
+                return json(res, 200, await agent.listChannels());
+            }
+            // SecureComs-envelope latency percentiles (ms), messaging hops only —
+            // excludes LLM time. Behind the bearer (timing aggregates leak rate).
+            if (method === "GET" && path === "/v1/metrics") {
+                return json(res, 200, agent.metrics());
+            }
+            if (method === "POST" && path === "/v1/send") {
+                const parsed = sendSchema.safeParse(JSON.parse(await readBody(req, SEND_CAP)));
+                if (!parsed.success)
+                    return jsonError(res, "invalid_request", parsed.error.issues);
+                const r = parsed.data.a2a
+                    ? await agent.sendA2A(parsed.data.channel_id, parsed.data.a2a, parsed.data.idempotency_key)
+                    // `text` is guaranteed present here by the sendSchema refine (text | a2a)
+                    : await agent.send(parsed.data.channel_id, parsed.data.text, parsed.data.idempotency_key);
+                return json(res, 200, r);
+            }
+            if (method === "POST" && path === "/v1/send-attachment") {
+                const parsed = sendAttachmentSchema.safeParse(JSON.parse(await readBody(req, OTHER_CAP)));
+                if (!parsed.success)
+                    return jsonError(res, "invalid_request", parsed.error.issues);
+                const r = await agent.sendAttachment(parsed.data.channel_id, parsed.data.path, parsed.data.caption);
+                return json(res, 200, r);
+            }
+            if (method === "POST" && path === "/v1/status") {
+                const parsed = statusSchema.safeParse(JSON.parse(await readBody(req, OTHER_CAP)));
+                if (!parsed.success)
+                    return jsonError(res, "invalid_request", parsed.error.issues);
+                await agent.reportStatus(parsed.data.channel_id, parsed.data.state, parsed.data.detail);
+                return json(res, 200, { ok: true });
+            }
+            if (method === "GET" && path === "/v1/messages") {
+                const channel = url.searchParams.get("channel_id") ?? undefined;
+                const wait = Math.max(0, Math.min(50, Number(url.searchParams.get("wait") ?? 0)));
+                return json(res, 200, await agent.drain(channel, wait));
+            }
+            if (method === "GET" && path === "/v1/events") {
+                const channel = url.searchParams.get("channel_id") ?? undefined;
+                tearDownSse(); // single consumer: newest wins
+                res.writeHead(200, {
+                    "content-type": "text/event-stream",
+                    "cache-control": "no-cache",
+                    connection: "keep-alive",
+                });
+                res.write(":connected\n\n"); // deterministic open signal (clients ignore comments)
+                const drainToClient = () => {
+                    const left = writeSse(res, agent.takeBuffered(channel));
+                    if (left.length)
+                        agent.requeueFront(left);
+                };
+                const unsubscribe = agent.subscribe(drainToClient);
+                const keepalive = setInterval(() => { try {
+                    res.write(":keepalive\n\n");
+                }
+                catch { /* gone */ } }, 15_000);
+                sse = { res, unsubscribe, keepalive };
+                drainToClient(); // flush anything already buffered
+                req.on("close", () => { if (sse?.res === res)
+                    tearDownSse(); });
+                return; // keep the connection open
+            }
+            return jsonError(res, "not_found");
+        }
+        catch (e) {
+            if (e.message === "body_too_large") {
+                // The request stream was paused mid-body (readBody stops consuming at the
+                // cap). Send `Connection: close` so Node flushes the 400 and then closes
+                // this socket — discarding the unread body. This avoids both the
+                // keep-alive stall (a paused, unconsumed stream blocks the next pipelined
+                // request) and the response-truncation race that destroying the socket
+                // directly would cause. (review issue 1)
+                if (!res.headersSent) {
+                    res.writeHead(httpStatus("body_too_large"), { "content-type": "application/json", connection: "close" });
+                }
+                res.end(JSON.stringify(errorBody("body_too_large")));
+                return;
+            }
+            if (e instanceof ChannelPendingError)
+                return jsonError(res, "channel_pending");
+            if (e instanceof RateLimitedError)
+                return jsonError(res, "rate_limited");
+            if (e instanceof InvalidPathError)
+                return jsonError(res, "invalid_request", e.message);
+            if (e instanceof SyntaxError)
+                return jsonError(res, "invalid_json");
+            process.stderr.write(`[bridge] request error: ${e?.message ?? e}\n`);
+            return jsonError(res, "internal");
+        }
+    };
+    const server = opts.tls
+        ? createHttps({ cert: opts.tls.cert, key: opts.tls.key }, (req, res) => void handler(req, res))
+        : createHttp((req, res) => void handler(req, res));
+    return { server, closeAllSseStreams: () => closeSse() };
+}

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export { createHttpServer, writeSse, capabilities, type HttpServerOptions } from
 export { attachAgentWebSocket, type AgentWebSocketOptions } from "./ws-server.js";
 export { resolveToken, tokenMatches, originHostAllowed } from "./auth.js";
 export { BRIDGE_ERRORS, errorBody, httpStatus, wsErrorFrame, type BridgeErrorCode } from "./errors.js";
+export { ensureSodiumReady } from "./sodium-ready.js";