openmausbot 0.1.80 → 0.1.81

package/dist-server/server/local-vm-lease.js

@@ -55,4 +55,8 @@ export class LocalVmLeasePool {
         }
         return lease;
     }
+    /** Drop an idle per-target lane after its owning bot and VM are gone. */
+    forget(targetKey) {
+        this.leases.delete(targetKey);
+    }
 }

package/dist-server/server/mcp-http.js

@@ -0,0 +1,337 @@
+export class McpHttpError extends Error {
+    kind;
+    status;
+    constructor(kind, message, status) {
+        super(message);
+        this.name = "McpHttpError";
+        this.kind = kind;
+        this.status = status;
+    }
+}
+/** Bytes of one response (or one SSE stream) a probe is willing to read. */
+const MAX_BODY_BYTES = 1_048_576;
+const PROTOCOL_VERSION = "2025-06-18";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function unwrap(message) {
+    if (message.error !== undefined) {
+        const detail = isRecord(message.error) && typeof message.error.message === "string" ? message.error.message : "request failed";
+        throw new McpHttpError("protocol", `MCP error: ${detail}`);
+    }
+    return message.result;
+}
+function parseMessage(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (Array.isArray(parsed))
+            return parsed.filter(isRecord);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseSseBlock(block) {
+    let event = "message";
+    const data = [];
+    for (const line of block.split("\n")) {
+        if (!line || line.startsWith(":"))
+            continue;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let value = colon === -1 ? "" : line.slice(colon + 1);
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        if (field === "event")
+            event = value;
+        else if (field === "data")
+            data.push(value);
+    }
+    return data.length ? { event, data: data.join("\n") } : null;
+}
+/** Read an event stream until the handler says stop, the server ends it,
+ * or the signal fires. Bounded, so a chatty server cannot fill memory. */
+async function readSse(response, signal, onEvent) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new McpHttpError("protocol", "empty event stream");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let bytes = 0;
+    const onAbort = () => void reader.cancel().catch(() => { });
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                return;
+            bytes += value.byteLength;
+            if (bytes > MAX_BODY_BYTES)
+                throw new McpHttpError("protocol", "event stream too large");
+            buffer += decoder.decode(value, { stream: true }).replace(/\r\n?/g, "\n");
+            let separator;
+            while ((separator = buffer.indexOf("\n\n")) !== -1) {
+                const block = buffer.slice(0, separator);
+                buffer = buffer.slice(separator + 2);
+                const event = parseSseBlock(block);
+                if (event && onEvent(event) === "stop") {
+                    await reader.cancel().catch(() => { });
+                    return;
+                }
+            }
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+    }
+}
+async function readBounded(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return "";
+    const decoder = new TextDecoder();
+    let text = "";
+    let bytes = 0;
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            return text + decoder.decode();
+        bytes += value.byteLength;
+        if (bytes > MAX_BODY_BYTES) {
+            await reader.cancel().catch(() => { });
+            throw new McpHttpError("protocol", "response too large");
+        }
+        text += decoder.decode(value, { stream: true });
+    }
+}
+function drain(response) {
+    void response.body?.cancel().catch(() => { });
+}
+export class RemoteMcpClient {
+    target;
+    fetchImpl;
+    sessionId = null;
+    protocolVersion = null;
+    nextId = 1;
+    closed = false;
+    /** Legacy SSE: one long GET stream carries every response. */
+    pending = new Map();
+    sseEndpoint = null;
+    sseAbort = new AbortController();
+    constructor(target, options = {}) {
+        this.target = target;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    /** The MCP handshake: initialize, then the initialized notification. */
+    async initialize(clientName, signal) {
+        const result = await this.request("initialize", {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: clientName, version: "1" },
+        }, signal);
+        if (isRecord(result) && typeof result.protocolVersion === "string")
+            this.protocolVersion = result.protocolVersion;
+        await this.notify("notifications/initialized", undefined, signal);
+        return result;
+    }
+    request(method, params, signal) {
+        if (this.closed)
+            return Promise.reject(new McpHttpError("protocol", "client closed"));
+        const id = this.nextId++;
+        const frame = { jsonrpc: "2.0", id, method, ...(params === undefined ? {} : { params }) };
+        return this.target.type === "sse" ? this.sseRequest(id, frame, signal) : this.streamableRequest(id, frame, signal);
+    }
+    async notify(method, params, signal) {
+        if (this.closed)
+            throw new McpHttpError("protocol", "client closed");
+        const frame = { jsonrpc: "2.0", method, ...(params === undefined ? {} : { params }) };
+        if (this.target.type === "sse") {
+            await this.ssePost(frame, signal);
+            return;
+        }
+        const response = await this.post(this.target.url, frame, signal);
+        drain(response);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.sseAbort.abort();
+        for (const entry of this.pending.values())
+            entry.reject(new McpHttpError("network", "client closed"));
+        this.pending.clear();
+        // Streamable HTTP: tell the server its session is over. Best effort —
+        // many servers answer 405 here, and a probe has nothing left to lose.
+        if (this.sessionId && this.target.type !== "sse") {
+            try {
+                const headers = this.headers();
+                headers.set("mcp-session-id", this.sessionId);
+                const response = await this.fetchImpl(this.target.url, { method: "DELETE", headers, signal: AbortSignal.timeout(2_000) });
+                drain(response);
+            }
+            catch {
+                // the session lapses on its own
+            }
+        }
+    }
+    headers() {
+        const headers = new Headers();
+        for (const [name, value] of Object.entries(this.target.headers))
+            headers.set(name, value);
+        headers.set("accept", "application/json, text/event-stream");
+        if (this.sessionId)
+            headers.set("mcp-session-id", this.sessionId);
+        if (this.protocolVersion)
+            headers.set("mcp-protocol-version", this.protocolVersion);
+        return headers;
+    }
+    async post(url, frame, signal) {
+        const headers = this.headers();
+        headers.set("content-type", "application/json");
+        let response;
+        try {
+            response = await this.fetchImpl(url, { method: "POST", headers, body: JSON.stringify(frame), signal });
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            throw new McpHttpError("network", "request failed");
+        }
+        if (!response.ok) {
+            drain(response);
+            throw new McpHttpError("status", `HTTP ${response.status}`, response.status);
+        }
+        const session = response.headers.get("mcp-session-id");
+        if (session)
+            this.sessionId = session;
+        return response;
+    }
+    // ── streamable HTTP: each request is one POST; the answer is JSON or a
+    //    short event stream that carries the response among server messages ──
+    async streamableRequest(id, frame, signal) {
+        const response = await this.post(this.target.url, frame, signal);
+        const type = (response.headers.get("content-type") ?? "").toLowerCase();
+        if (type.startsWith("application/json")) {
+            const parsed = parseMessage(await readBounded(response));
+            const message = (Array.isArray(parsed) ? parsed : parsed ? [parsed] : []).find((entry) => entry.id === id);
+            if (!message)
+                throw new McpHttpError("protocol", "response did not answer the request");
+            return unwrap(message);
+        }
+        if (type.startsWith("text/event-stream")) {
+            let found;
+            await readSse(response, signal, (event) => {
+                if (event.event !== "message")
+                    return undefined;
+                const parsed = parseMessage(event.data);
+                const message = (Array.isArray(parsed) ? parsed : parsed ? [parsed] : []).find((entry) => entry.id === id);
+                if (!message)
+                    return undefined;
+                found = message;
+                return "stop";
+            });
+            if (signal.aborted)
+                throw new McpHttpError("network", "aborted");
+            if (!found)
+                throw new McpHttpError("protocol", "event stream ended without the response");
+            return unwrap(found);
+        }
+        drain(response);
+        throw new McpHttpError("protocol", "unexpected content type");
+    }
+    // ── legacy SSE: a GET opens the stream, its first event names where to
+    //    POST, and every response comes back over the stream ──
+    openSseStream(signal) {
+        if (this.sseEndpoint)
+            return this.sseEndpoint;
+        this.sseEndpoint = new Promise((resolveEndpoint, rejectEndpoint) => {
+            let settled = false;
+            const fail = (error) => {
+                if (!settled) {
+                    settled = true;
+                    rejectEndpoint(error);
+                }
+                for (const entry of this.pending.values())
+                    entry.reject(error);
+                this.pending.clear();
+            };
+            const headers = this.headers();
+            headers.set("accept", "text/event-stream");
+            // the caller's signal covers the opening; once open, the stream lives
+            // until close(), because later requests are answered on it
+            const opening = AbortSignal.any([signal, this.sseAbort.signal]);
+            this.fetchImpl(this.target.url, { method: "GET", headers, signal: opening })
+                .then(async (response) => {
+                if (!response.ok) {
+                    drain(response);
+                    throw new McpHttpError("status", `HTTP ${response.status}`, response.status);
+                }
+                await readSse(response, this.sseAbort.signal, (event) => {
+                    if (event.event === "endpoint") {
+                        if (!settled) {
+                            settled = true;
+                            try {
+                                resolveEndpoint(new URL(event.data, this.target.url).toString());
+                            }
+                            catch {
+                                rejectEndpoint(new McpHttpError("protocol", "invalid endpoint event"));
+                            }
+                        }
+                        return undefined;
+                    }
+                    if (event.event !== "message")
+                        return undefined;
+                    const parsed = parseMessage(event.data);
+                    for (const message of Array.isArray(parsed) ? parsed : parsed ? [parsed] : []) {
+                        const entry = typeof message.id === "number" ? this.pending.get(message.id) : undefined;
+                        if (!entry)
+                            continue;
+                        this.pending.delete(message.id);
+                        try {
+                            entry.resolve(unwrap(message));
+                        }
+                        catch (error) {
+                            entry.reject(error instanceof Error ? error : new McpHttpError("protocol", String(error)));
+                        }
+                    }
+                    return undefined;
+                });
+                fail(new McpHttpError("network", "event stream ended"));
+            })
+                .catch((error) => {
+                fail(error instanceof McpHttpError ? error : new McpHttpError("network", "event stream failed"));
+            });
+        });
+        return this.sseEndpoint;
+    }
+    async ssePost(frame, signal) {
+        const endpoint = await this.openSseStream(signal);
+        const response = await this.post(endpoint, frame, signal);
+        drain(response);
+    }
+    sseRequest(id, frame, signal) {
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                this.pending.delete(id);
+                reject(new McpHttpError("network", "aborted"));
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            this.pending.set(id, {
+                resolve: (value) => {
+                    signal.removeEventListener("abort", onAbort);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    signal.removeEventListener("abort", onAbort);
+                    reject(error);
+                },
+            });
+            this.ssePost(frame, signal).catch((error) => {
+                this.pending.delete(id);
+                signal.removeEventListener("abort", onAbort);
+                reject(error instanceof Error ? error : new McpHttpError("network", String(error)));
+            });
+        });
+    }
+}

package/dist-server/server/mcp-probe.js

@@ -1,6 +1,8 @@
 import { augmentedPath } from "./env-path.js";
 import { PROVIDER_CREDENTIAL_ENV, stripWorkspaceCredentialEnv, } from "./config.js";
 import { createLineSplitter } from "./mcp-bridge.js";
+import { McpHttpError, RemoteMcpClient } from "./mcp-http.js";
+import { isRemoteMcpServer } from "./mcp-registry.js";
 import { killCliTree, spawnCli } from "./procs.js";
 const MAX_STDOUT_BYTES = 1_048_576;
 const MAX_TOOLS = 100;
@@ -24,18 +26,79 @@ function publicProbeError(kind) {
         return "Connection test was cancelled.";
     return "The command did not return a valid MCP tools list.";
 }
-function redactConfiguredValues(value, env) {
+function redactConfiguredValues(value, secrets) {
     let redacted = value;
-    for (const secret of Object.values(env)) {
+    for (const secret of Object.values(secrets)) {
         if (secret)
             redacted = redacted.split(secret).join("[redacted]");
     }
     return redacted;
 }
+/** The bounded, redacted tool list the renderer may see. `secrets` are the
+ * configured values (env or header values) a careless server might echo. */
+function publicTools(raw, secrets) {
+    const tools = [];
+    for (const entry of raw.slice(0, MAX_TOOLS)) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const candidate = entry;
+        if (typeof candidate.name !== "string" || !candidate.name.trim())
+            continue;
+        tools.push({
+            name: redactConfiguredValues(candidate.name, secrets).slice(0, 200),
+            ...(typeof candidate.description === "string"
+                ? { description: redactConfiguredValues(candidate.description, secrets).slice(0, 500) }
+                : {}),
+        });
+    }
+    return tools;
+}
+/** Prove the MCP handshake and list the tools of one configured server,
+ * whichever way it is reached. Neither path returns anything the renderer
+ * must not see: child stderr, environment values, header values. */
+export function probeMcpServer(server, timeoutMs = DEFAULT_TIMEOUT_MS, signal) {
+    return isRemoteMcpServer(server)
+        ? probeRemoteMcpServer(server, timeoutMs, signal)
+        : probeStdioMcpServer(server, timeoutMs, signal);
+}
+/** Connect to a remote server over its transport, bounded by the same
+ * timeout as a command. HTTP status codes are safe to show and are the one
+ * detail that tells a wrong token from a wrong address. */
+async function probeRemoteMcpServer(server, timeoutMs, signal) {
+    if (signal?.aborted)
+        return { ok: false, error: publicProbeError("cancelled") };
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+    const client = new RemoteMcpClient(server);
+    try {
+        await client.initialize("OpenMausBot", combined);
+        const result = await client.request("tools/list", {}, combined);
+        const tools = result && typeof result === "object" ? result.tools : undefined;
+        if (!Array.isArray(tools))
+            return { ok: false, error: "The server did not return a valid MCP tools list." };
+        return { ok: true, tools: publicTools(tools, server.headers) };
+    }
+    catch (error) {
+        if (signal?.aborted)
+            return { ok: false, error: publicProbeError("cancelled") };
+        if (timeout.aborted)
+            return { ok: false, error: publicProbeError("timeout") };
+        if (error instanceof McpHttpError && error.kind === "status") {
+            return { ok: false, error: `The server answered HTTP ${error.status}. Check the address and headers.` };
+        }
+        if (error instanceof McpHttpError && error.kind === "protocol") {
+            return { ok: false, error: "The server did not return a valid MCP tools list." };
+        }
+        return { ok: false, error: "Could not reach this address. Check the URL and your network." };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
 /** Start one stdio server long enough to prove the MCP handshake and list its
  * tools. It is always reaped, never inherits OpenMaus credentials, and never
  * returns child stderr or environment values to the renderer. */
-export function probeMcpServer(server, timeoutMs = DEFAULT_TIMEOUT_MS, signal) {
+function probeStdioMcpServer(server, timeoutMs, signal) {
     return new Promise((resolve) => {
         if (signal?.aborted) {
             resolve({ ok: false, error: publicProbeError("cancelled") });
@@ -102,21 +165,7 @@ export function probeMcpServer(server, timeoutMs = DEFAULT_TIMEOUT_MS, signal) {
                 finish({ ok: false, error: publicProbeError("protocol") });
                 return;
             }
-            const tools = [];
-            for (const raw of result.tools.slice(0, MAX_TOOLS)) {
-                if (!raw || typeof raw !== "object")
-                    continue;
-                const candidate = raw;
-                if (typeof candidate.name !== "string" || !candidate.name.trim())
-                    continue;
-                tools.push({
-                    name: redactConfiguredValues(candidate.name, server.env).slice(0, 200),
-                    ...(typeof candidate.description === "string"
-                        ? { description: redactConfiguredValues(candidate.description, server.env).slice(0, 500) }
-                        : {}),
-                });
-            }
-            finish({ ok: true, tools });
+            finish({ ok: true, tools: publicTools(result.tools, server.env) });
         });
         timer = setTimeout(() => {
             finish({ ok: false, error: publicProbeError("timeout") });