@securecoms/agent-bridge 0.11.2 → 0.15.0

package/dist/config.js

@@ -1,74 +0,0 @@
-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

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

@@ -1,25 +0,0 @@
-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

@@ -1,220 +0,0 @@
-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() };
-}