openmausbot 0.1.79 → 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/managed-desktop.js

@@ -0,0 +1,205 @@
+import { createHash } from "node:crypto";
+import { lstatSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+const uuid = z.string().uuid();
+const model = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/:+-]{0,199}$/).refine(value => !value.includes("::"));
+const connectionSchema = z.object({
+    portalOrigin: z.string().max(2048), organizationId: uuid, organizationName: z.string().trim().min(1).max(100),
+    email: z.string().email().max(320), deviceId: uuid, token: z.string().regex(/^omg_[A-Za-z0-9_-]{43}$/),
+    expiresAt: z.number().finite().int().positive(),
+    providers: z.array(z.object({ id: z.enum(["anthropic", "openai", "openrouter"]), configured: z.boolean(), models: z.array(model).max(500) }).strict()).max(3),
+}).strict();
+const signature = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const expiredMessage = "Company access has ended. Reconnect your organization or explicitly choose a personal model; personal billing will not be used automatically.";
+/** Validate only messages received over Electron's private utility-parent port.
+ * Never expose this input to renderer HTTP or merge it into saved AppConfig.
+ */
+export function parseManagedDesktopConnection(raw, now = Date.now()) {
+    if (raw === null)
+        return null;
+    const parsed = connectionSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new Error("Invalid Company connection from the desktop parent.");
+    const value = parsed.data, url = new URL(value.portalOrigin);
+    if (url.username || url.password || url.pathname !== "/" || url.search || url.hash ||
+        (url.protocol !== "https:" && !(url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)))) {
+        throw new Error("Company connection must use an HTTPS origin or loopback fixture.");
+    }
+    if (value.expiresAt <= now)
+        throw new Error("Company connection expired. Reconnect your organization.");
+    if (new Set(value.providers.map(provider => provider.id)).size !== value.providers.length)
+        throw new Error("Duplicate Company provider configuration.");
+    return { ...value, portalOrigin: url.origin, email: value.email.toLowerCase(), providers: value.providers.map(provider => ({ ...provider, models: [...new Set(provider.models)] })).sort((a, b) => a.id.localeCompare(b.id)) };
+}
+export function companyInstanceId(connection, provider) {
+    // Device identity prevents an old company's native resume cursor from being
+    // inherited by a different enrollment using the same organization/email.
+    return `company.${signature([connection.portalOrigin, connection.organizationId, connection.deviceId]).slice(0, 24)}.${provider}`;
+}
+export function companyInstanceConfigs(connection, runtimeDirectory) {
+    const entries = {};
+    for (const provider of connection.providers) {
+        if (!provider.configured || !provider.models.length)
+            continue;
+        const id = companyInstanceId(connection, provider.id), base = `${connection.portalOrigin}/api/desktop/gateway/${provider.id}`;
+        const displayName = `Company · ${connection.organizationName} · ${provider.id === "anthropic" ? "Claude" : provider.id === "openai" ? "Codex" : "OpenRouter"}`;
+        if (provider.id === "anthropic")
+            entries[id] = {
+                driver: "claudeAgent", displayName,
+                config: { configDir: join(runtimeDirectory, id, "claude"), managed: true },
+                environment: { ANTHROPIC_API_KEY: connection.token, ANTHROPIC_AUTH_TOKEN: connection.token, ANTHROPIC_BASE_URL: base, ANTHROPIC_MODEL: provider.models[0] },
+            };
+        if (provider.id === "openai")
+            entries[id] = {
+                driver: "codex", displayName, config: { managed: { url: `${base}/v1`, models: provider.models } },
+                environment: { OPENMAUSBOT_COMPANY_API_KEY: connection.token, CODEX_HOME: join(runtimeDirectory, id, "codex") },
+            };
+        if (provider.id === "openrouter")
+            entries[id] = {
+                driver: "openai-compat", displayName, config: { url: `${base}/v1`, apiKeyEnv: "OPENMAUSBOT_COMPANY_API_KEY", model: provider.models[0], provider: "" },
+                environment: { OPENMAUSBOT_COMPANY_API_KEY: connection.token },
+            };
+    }
+    return entries;
+}
+/** One memory-only Company overlay, separate from all personal settings.
+ * Revocation fences wrappers synchronously, then stops only their instances.
+ */
+export class ManagedDesktopProviders {
+    connection = null;
+    currentSignature = signature(null);
+    revision = 0;
+    ids = new Set();
+    tail = Promise.resolve();
+    timer;
+    now;
+    options;
+    constructor(options) { this.options = options; this.now = options.now ?? Date.now; }
+    info(instanceId) {
+        if (!this.ids.has(instanceId) || !this.connection || this.connection.expiresAt <= this.now())
+            return;
+        return { organizationId: this.connection.organizationId, organizationName: this.connection.organizationName };
+    }
+    /** Ids this overlay has ever created in this process, so a personal instance
+     * that happens to be named company.* is never treated as managed. */
+    known = new Set();
+    owns(instanceId) { return this.known.has(instanceId); }
+    apply(raw, force = false) {
+        const connection = parseManagedDesktopConnection(raw, this.now()), nextSignature = signature(connection);
+        if (!force && nextSignature === this.currentSignature)
+            return this.tail;
+        this.currentSignature = nextSignature;
+        this.connection = connection;
+        const revision = ++this.revision;
+        clearTimeout(this.timer);
+        const replace = async () => {
+            const previous = [...this.ids];
+            await this.options.beforeReplace?.(previous);
+            for (const id of previous)
+                await this.options.registry.dispose(id);
+            this.ids.clear();
+            if (revision !== this.revision || !connection || connection.expiresAt <= this.now()) {
+                this.options.afterReplace?.([]);
+                return;
+            }
+            // Keep native sessions across server/app restarts, but outside portable
+            // workspace backups. Device-scoped ids prevent a new enrollment from
+            // inheriting another account's native conversation or credentials.
+            const directory = this.ensureDirectory(["providers", "company"]);
+            const configs = companyInstanceConfigs(connection, directory);
+            for (const [id, entry] of Object.entries(configs)) {
+                if (this.options.registry.entries().some(existing => existing.instanceId === id))
+                    throw new Error("Company instance conflicts with an existing account.");
+                if (entry.driver === "claudeAgent" || entry.driver === "codex") {
+                    this.ensureDirectory(["providers", "company", id, entry.driver === "claudeAgent" ? "claude" : "codex"]);
+                }
+                this.ids.add(id);
+                this.known.add(id);
+            }
+            const active = () => revision === this.revision && connection.expiresAt > this.now();
+            await this.options.registry.load(configs, instance => {
+                const provider = connection.providers.find(provider => companyInstanceId(connection, provider.id) === instance.instanceId);
+                const models = { default: provider.models[0], options: provider.models.map(id => ({ id, label: `${id} (Company)` })) };
+                return {
+                    ...instance, models,
+                    refreshModels: async () => { },
+                    startAuthentication: undefined, getAuthentication: undefined, completeAuthentication: undefined, cancelAuthentication: undefined, signOut: undefined,
+                    snapshot: async () => {
+                        if (!active())
+                            return { state: "unavailable", reason: expiredMessage };
+                        const snapshot = await instance.snapshot();
+                        if (!active())
+                            return { state: "unavailable", reason: expiredMessage };
+                        return { ...snapshot, authenticated: snapshot.state === "available", billing: "metered", account: { email: connection.email, organization: connection.organizationName, method: "api-key" } };
+                    },
+                    adapter: {
+                        ...instance.adapter,
+                        sendTurn: async (input) => {
+                            if (!active())
+                                throw new Error(expiredMessage);
+                            if (!input.model || !provider.models.includes(input.model))
+                                throw new Error("This model is not enabled by your Company administrator.");
+                            return instance.adapter.sendTurn(input);
+                        },
+                    },
+                };
+            });
+            if (revision === this.revision) {
+                this.options.afterReplace?.([...this.ids]);
+                this.scheduleExpiry(connection, revision);
+            }
+        };
+        this.tail = this.tail.catch(() => { }).then(replace).catch(async (error) => {
+            // A partial replacement must neither retain usable Company wrappers
+            // nor memoize failure forever. Do not invalidate a newer queued grant.
+            if (revision === this.revision) {
+                this.revision++;
+                this.connection = null;
+                this.currentSignature = null;
+                clearTimeout(this.timer);
+            }
+            await Promise.allSettled([...this.ids].map(id => this.options.registry.dispose(id)));
+            this.ids.clear();
+            this.options.afterReplace?.([]);
+            throw error;
+        });
+        return this.tail;
+    }
+    /** Called after the ordinary fleet is rebuilt; never add Company to cfg. */
+    restore() { return this.apply(this.connection && this.connection.expiresAt > this.now() ? this.connection : null, true); }
+    ensureDirectory(parts) {
+        // Only the configured workspace root may already be an operator-chosen
+        // alias. None of our owned descendants may redirect into personal homes.
+        mkdirSync(this.options.dataDirectory, { recursive: true, mode: 0o700 });
+        let directory = this.options.dataDirectory;
+        for (const part of parts) {
+            directory = join(directory, part);
+            try {
+                mkdirSync(directory, { mode: 0o700 });
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+            }
+            const stat = lstatSync(directory);
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                throw new Error("Company native storage must be an owned workspace directory.");
+        }
+        return directory;
+    }
+    scheduleExpiry(connection, revision) {
+        this.timer = setTimeout(() => {
+            if (revision !== this.revision)
+                return;
+            if (connection.expiresAt > this.now())
+                this.scheduleExpiry(connection, revision);
+            else
+                void this.apply(null).catch(() => { });
+        }, Math.min(2_147_483_647, Math.max(1, connection.expiresAt - this.now())));
+        this.timer.unref?.();
+    }
+    async close() {
+        await this.apply(null, true);
+    }
+}

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") });