openmausbot 0.1.93 → 0.1.95

package/dist-server/local-computer.js

@@ -13,7 +13,8 @@ function resolveProxy(relative) {
   return existsSync(source) ? source : join(SERVER_ROOT, `${relative}.js`);
 }
 var SPAWNED_PROXIES = {
-  browser: resolveProxy("browser-proxy"),
+  // The built-in browser and the cloud computer: argv[2] picks which.
+  harnessMcp: resolveProxy("harness-mcp-proxy"),
   localComputer: resolveProxy("local-computer-proxy"),
   permission: resolveProxy("permission-proxy"),
   containerMcp: resolveProxy("container-mcp"),
@@ -22,6 +23,7 @@ var SPAWNED_PROXIES = {
   dweb: resolveProxy("drivers/dweb-proxy"),
   connectors: resolveProxy("connector-proxy"),
   mcpGate: resolveProxy("mcp-gate"),
+  mcpRemote: resolveProxy("mcp-remote-proxy"),
   phone: resolveProxy("drivers/phone-proxy"),
   hook: resolveProxy("hooks/omb-hook"),
   // Loaded by the external `pi` process via `-e`, not by this server — but

package/dist-server/mcp-gate.js

@@ -4,6 +4,60 @@ import { mkdirSync, readdirSync as readdirSync2, rmSync, statSync as statSync2,
 import { join as join2 } from "node:path";
 import { createInterface } from "node:readline";
 
+// shared/tool-scope.ts
+var SERVER_NAME = /^[a-z][a-z0-9_-]{0,31}$/;
+var CONTROL_CHARACTER = /[\x00-\x1f\x7f]/;
+var MAX_SELECTORS = 256;
+var MAX_SELECTOR_LENGTH = 1024;
+function validName(name) {
+  return typeof name === "string" && name.trim().length > 0 && name.length <= MAX_SELECTOR_LENGTH && !CONTROL_CHARACTER.test(name) && !name.includes("*");
+}
+function selectorIdentity(selector) {
+  if (selector.length > MAX_SELECTOR_LENGTH || CONTROL_CHARACTER.test(selector)) return;
+  if (selector.startsWith("native:")) {
+    const name = selector.slice(7);
+    if (name === "*" || validName(name)) return { kind: "native", name };
+  } else if (selector.startsWith("mcp:")) {
+    const separator = selector.indexOf(":", 4);
+    if (separator < 0) return;
+    const server = selector.slice(4, separator);
+    const name = selector.slice(separator + 1);
+    if (SERVER_NAME.test(server) && (name === "*" || validName(name))) {
+      return { kind: "mcp", server, name };
+    }
+  }
+}
+function parseToolScope(value) {
+  if (value === void 0) return { ok: true, scope: void 0 };
+  const invalid = { ok: false, error: "Tool selection must contain only valid allow and deny lists." };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return invalid;
+  const scope2 = {};
+  for (const key of Reflect.ownKeys(value)) {
+    if (key !== "allow" && key !== "deny") return invalid;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor)) return invalid;
+    const list = descriptor.value;
+    if (!Array.isArray(list) || list.length > MAX_SELECTORS) return invalid;
+    if (!Array.from(list).every((entry) => typeof entry === "string" && selectorIdentity(entry))) return invalid;
+    scope2[key] = [...new Set(list)];
+  }
+  return { ok: true, scope: scope2 };
+}
+function matches(selector, tool) {
+  const selected = selectorIdentity(selector);
+  return selected?.kind === tool.kind && (selected.kind !== "mcp" || tool.kind === "mcp" && selected.server === tool.server) && (selected.name === "*" || selected.name === tool.name);
+}
+function permits(scope2, tool) {
+  if (!validName(tool.name) || tool.kind === "mcp" && !SERVER_NAME.test(tool.server)) return false;
+  return (scope2?.allow === void 0 || scope2.allow.some((selector) => matches(selector, tool))) && !scope2?.deny?.some((selector) => matches(selector, tool));
+}
+function allowsTool(scope2, tool) {
+  const parsed = parseToolScope(scope2);
+  return parsed.ok && permits(parsed.scope, tool);
+}
+
 // server/env-path.ts
 import { execFile } from "node:child_process";
 import { closeSync, existsSync, openSync, readFileSync, readSync, statSync, readdirSync } from "node:fs";
@@ -447,21 +501,60 @@ async function stopCliTree(child2, pid, timeoutMs) {
 }
 
 // server/mcp-gate.ts
-var NAME = process.env.OMB_GATE_NAME || "mcp";
-var SPILL_DIR = process.env.OMB_GATE_SPILL_DIR || "";
-var BUDGET = Number(process.env.OMB_GATE_BUDGET) > 0 ? Number(process.env.OMB_GATE_BUDGET) : DEFAULT_RESULT_BUDGET;
+function gateEnvironment() {
+  if (process.argv.length === 2) return process.env;
+  try {
+    const key = process.argv[3];
+    if (process.argv.length !== 4 || process.argv[2] !== "--config-env" || !key || !/^OMB_GATE_CONFIG_[a-f0-9]{64}$/.test(key)) throw new Error();
+    const value = JSON.parse(process.env[key] ?? "");
+    if (!value || typeof value !== "object" || Array.isArray(value) || !["OMB_GATE_NAME", "OMB_GATE_UPSTREAM", "OMB_GATE_TOOL_SCOPE"].every((name) => typeof value[name] === "string") || !Object.entries(value).every(([name, setting]) => GATE_ENV_KEYS.includes(name) && typeof setting === "string")) throw new Error();
+    return value;
+  } catch {
+    process.stderr.write("mcp-gate: invalid private configuration\n");
+    process.exit(1);
+  }
+}
+var GATE_ENV_KEYS = ["OMB_GATE_NAME", "OMB_GATE_SPILL_DIR", "OMB_GATE_BUDGET", "OMB_GATE_UPSTREAM", "OMB_GATE_SPILL_HINT", "OMB_GATE_TOOL_SCOPE"];
+var gateEnv = gateEnvironment();
+var NAME = gateEnv.OMB_GATE_NAME || "mcp";
+var SPILL_DIR = gateEnv.OMB_GATE_SPILL_DIR || "";
+var rawBudget = Number(gateEnv.OMB_GATE_BUDGET);
+var BUDGET = Number.isFinite(rawBudget) && rawBudget >= 0 ? rawBudget : DEFAULT_RESULT_BUDGET;
 var SPILL_MAX_AGE_MS = 24 * 60 * 6e4;
-var SPILL_HINT = process.env.OMB_GATE_SPILL_HINT === "1";
-var GATE_ENV_KEYS = ["OMB_GATE_NAME", "OMB_GATE_SPILL_DIR", "OMB_GATE_BUDGET", "OMB_GATE_UPSTREAM", "OMB_GATE_SPILL_HINT"];
+var SPILL_HINT = gateEnv.OMB_GATE_SPILL_HINT === "1";
 function fail(message) {
   process.stderr.write(`mcp-gate(${NAME}): ${message}
 `);
   process.exit(1);
 }
+function toolScope() {
+  const raw = gateEnv.OMB_GATE_TOOL_SCOPE;
+  if (raw === void 0) return;
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    fail("invalid tool selection JSON");
+  }
+  const parsed = parseToolScope(value);
+  if (!parsed.ok || parsed.scope === void 0) fail("invalid tool selection; check the bot's Access settings");
+  if (!/^[a-z][a-z0-9_-]{0,31}$/.test(NAME)) fail("invalid MCP server identity for tool selection");
+  return parsed.scope;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function requestKey(id) {
+  return typeof id === "string" || typeof id === "number" && Number.isFinite(id) ? `${typeof id}:${id}` : void 0;
+}
+function rejectRequest(id, code, message) {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id: requestKey(id) ? id : null, error: { code, message } })}
+`);
+}
 function upstreamSpec() {
   let parsed;
   try {
-    parsed = JSON.parse(process.env.OMB_GATE_UPSTREAM ?? "");
+    parsed = JSON.parse(gateEnv.OMB_GATE_UPSTREAM ?? "");
   } catch {
     fail("OMB_GATE_UPSTREAM is not valid JSON");
   }
@@ -503,6 +596,7 @@ function spill(tool, text) {
   }
 }
 function trimCallResult(result, tool) {
+  if (BUDGET === 0) return false;
   const content = result.content;
   if (!Array.isArray(content)) return false;
   const textBlocks = content.filter(
@@ -525,10 +619,11 @@ function trimCallResult(result, tool) {
   }
   return trimmed;
 }
+var scope = toolScope();
 var spec = upstreamSpec();
 if (SPILL_DIR) sweepSpill(SPILL_DIR);
 var childEnv = { ...process.env, ...spec.env };
-for (const key of GATE_ENV_KEYS) delete childEnv[key];
+for (const key of Object.keys(childEnv)) if (key.startsWith("OMB_GATE_")) delete childEnv[key];
 var resolved = resolveCliSpawn(spec.command, spec.args ?? []);
 var child = spawn2(resolved.command, resolved.args, {
   stdio: ["pipe", "pipe", "pipe"],
@@ -560,14 +655,35 @@ child.on("error", (error) => {
 child.stderr.pipe(process.stderr);
 var pending = /* @__PURE__ */ new Map();
 createInterface({ input: process.stdin }).on("line", (line) => {
+  let message;
   if (line.trim()) {
     try {
-      const message = JSON.parse(line);
-      if (message.method === "tools/call" && message.id !== void 0 && message.id !== null) {
-        const params = message.params;
-        pending.set(String(message.id), typeof params?.name === "string" ? params.name : "tool");
-      }
+      const parsed = JSON.parse(line);
+      if (isRecord(parsed)) message = parsed;
     } catch {
+      if (scope) return rejectRequest(null, -32700, "Invalid JSON-RPC frame");
+    }
+    if (scope && (!message || message.jsonrpc !== "2.0")) return rejectRequest(message?.id, -32600, "Invalid JSON-RPC frame");
+  }
+  const id = requestKey(message?.id);
+  const params = isRecord(message?.params) ? message.params : void 0;
+  if (scope && message?.method === "tools/call") {
+    if (!id || typeof params?.name !== "string" || params.arguments !== void 0 && !isRecord(params.arguments)) {
+      return rejectRequest(message.id, -32602, "Invalid tool call");
+    }
+    if (!allowsTool(scope, { kind: "mcp", server: NAME, name: params.name })) {
+      return rejectRequest(message.id, -32602, "Tool selection excludes this tool. Check the bot's Access settings.");
+    }
+  }
+  if (scope && message?.method === "tools/list" && !id) {
+    return rejectRequest(message.id, -32600, "Tool listing needs a request ID");
+  }
+  if (id && typeof message?.method === "string") {
+    if (scope && pending.has(id)) fail("duplicate request ID on a restricted connection");
+    if (message.method === "tools/call") {
+      pending.set(id, { kind: "call", tool: typeof params?.name === "string" ? params.name : "tool" });
+    } else if (scope) {
+      pending.set(id, { kind: message.method === "tools/list" ? "list" : "other" });
     }
   }
   child.stdin.write(`${line}
@@ -578,24 +694,36 @@ createInterface({ input: child.stdout }).on("line", (line) => {
   if (!line.trim()) return;
   let message;
   try {
-    message = JSON.parse(line);
+    const parsed = JSON.parse(line);
+    if (isRecord(parsed)) message = parsed;
   } catch {
+    if (scope) fail("unreadable upstream frame on a restricted connection");
+  }
+  if (!message || scope && message.jsonrpc !== "2.0") {
+    if (scope) fail("invalid upstream frame on a restricted connection");
     process.stdout.write(`${line}
 `);
     return;
   }
-  const id = message.id === void 0 || message.id === null ? void 0 : String(message.id);
-  const tool = id === void 0 ? void 0 : pending.get(id);
+  const id = typeof message.method === "string" ? void 0 : requestKey(message.id);
+  const request = id === void 0 ? void 0 : pending.get(id);
+  if (scope && id !== void 0 && !request) fail("unrequested upstream response on a restricted connection");
   if (id !== void 0) pending.delete(id);
   const result = message.result;
-  if (tool && result && typeof result === "object" && !Array.isArray(result)) {
+  if (scope && request?.kind === "list" && message.error === void 0) {
+    if (!isRecord(result) || !Array.isArray(result.tools) || !result.tools.every((tool) => isRecord(tool) && typeof tool.name === "string" && tool.name.trim().length > 0) || result.nextCursor !== void 0 && typeof result.nextCursor !== "string") {
+      return rejectRequest(message.id, -32603, "Invalid tool catalog on a restricted connection");
+    }
+    result.tools = result.tools.filter((tool) => allowsTool(scope, { kind: "mcp", server: NAME, name: tool.name }));
+  }
+  if (request?.kind === "call" && isRecord(result)) {
     try {
-      if (trimCallResult(result, tool)) {
-        process.stderr.write(`mcp-gate(${NAME}): trimmed ${tool} to ${BUDGET} chars
+      if (trimCallResult(result, request.tool)) {
+        process.stderr.write(`mcp-gate(${NAME}): trimmed ${request.tool} to ${BUDGET} chars
 `);
       }
     } catch (error) {
-      process.stderr.write(`mcp-gate(${NAME}): could not trim ${tool}: ${String(error)}
+      process.stderr.write(`mcp-gate(${NAME}): could not trim ${request.tool}: ${String(error)}
 `);
       process.stdout.write(`${line}
 `);

package/dist-server/mcp-remote-proxy.js

@@ -0,0 +1,437 @@
+// server/mcp-remote-proxy.ts
+import { createInterface } from "node:readline";
+
+// server/mcp-http.ts
+var McpHttpError = class extends Error {
+  kind;
+  status;
+  /** The server's `WWW-Authenticate` challenge on a 401: where to sign in. */
+  wwwAuthenticate;
+  constructor(kind, message, status, wwwAuthenticate) {
+    super(message);
+    this.name = "McpHttpError";
+    this.kind = kind;
+    this.status = status;
+    this.wwwAuthenticate = wwwAuthenticate;
+  }
+};
+var MAX_BODY_BYTES = 1048576;
+var PROTOCOL_VERSION = "2025-06-18";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function remoteMcpSpec(value) {
+  if (!isRecord(value) || value.type !== "http" && value.type !== "sse" || typeof value.url !== "string") return;
+  try {
+    const url = new URL(value.url);
+    if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password) return;
+    const headers = value.headers ?? {};
+    if (!isRecord(headers) || !Object.values(headers).every((header) => typeof header === "string")) return;
+    new Headers(headers);
+    return { type: value.type, url: value.url, headers };
+  } catch {
+    return;
+  }
+}
+function unwrap(message) {
+  if (message.error !== void 0) {
+    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;
+}
+async function readSse(response, signal, onEvent, maxBytes = MAX_BODY_BYTES) {
+  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 > maxBytes) 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, maxBytes = MAX_BODY_BYTES) {
+  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 > maxBytes) {
+      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(() => {
+  });
+}
+var RemoteMcpClient = class {
+  target;
+  fetchImpl;
+  maxBytes;
+  onNotification;
+  sessionId = null;
+  protocolVersion = null;
+  nextId = 1;
+  closed = false;
+  /** Legacy SSE: one long GET stream carries every response. */
+  pending = /* @__PURE__ */ new Map();
+  sseEndpoint = null;
+  sseAbort = new AbortController();
+  constructor(target, options = {}) {
+    this.target = target;
+    this.fetchImpl = options.fetch ?? fetch;
+    this.maxBytes = options.maxBytes ?? MAX_BODY_BYTES;
+    this.onNotification = options.onNotification;
+  }
+  /** 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", void 0, signal);
+    return result;
+  }
+  request(method, params, signal) {
+    if (this.closed) return Promise.reject(new McpHttpError("protocol", "client closed"));
+    if (signal.aborted) return Promise.reject(new McpHttpError("network", "aborted"));
+    const id = this.nextId++;
+    const frame = { jsonrpc: "2.0", id, method, ...params === void 0 ? {} : { params } };
+    const onAbort = () => {
+      void this.notify("notifications/cancelled", { requestId: id, reason: "Request cancelled" }, AbortSignal.timeout(2e3)).catch(() => {
+      });
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    const reply = this.target.type === "sse" ? this.sseRequest(id, frame, signal) : this.streamableRequest(id, frame, signal);
+    return reply.finally(() => signal.removeEventListener("abort", onAbort));
+  }
+  async notify(method, params, signal) {
+    if (this.closed) throw new McpHttpError("protocol", "client closed");
+    const frame = { jsonrpc: "2.0", method, ...params === void 0 ? {} : { 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();
+    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(2e3) });
+        drain(response);
+      } catch {
+      }
+    }
+  }
+  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 (error2) {
+      if (signal.aborted) throw error2;
+      throw new McpHttpError("network", "request failed");
+    }
+    if (!response.ok) {
+      drain(response);
+      throw new McpHttpError("status", `HTTP ${response.status}`, response.status, response.headers.get("www-authenticate") ?? void 0);
+    }
+    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, this.maxBytes));
+      this.deliverNotifications(parsed);
+      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 void 0;
+        const parsed = parseMessage(event.data);
+        this.deliverNotifications(parsed);
+        const message = (Array.isArray(parsed) ? parsed : parsed ? [parsed] : []).find((entry) => entry.id === id);
+        if (!message) return void 0;
+        found = message;
+        return "stop";
+      }, this.maxBytes);
+      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 = (error2) => {
+        if (!settled) {
+          settled = true;
+          rejectEndpoint(error2);
+        }
+        for (const entry of this.pending.values()) entry.reject(error2);
+        this.pending.clear();
+      };
+      const headers = this.headers();
+      headers.set("accept", "text/event-stream");
+      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, response.headers.get("www-authenticate") ?? void 0);
+        }
+        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 void 0;
+          }
+          if (event.event !== "message") return void 0;
+          const parsed = parseMessage(event.data);
+          this.deliverNotifications(parsed);
+          for (const message of Array.isArray(parsed) ? parsed : parsed ? [parsed] : []) {
+            const entry = typeof message.id === "number" ? this.pending.get(message.id) : void 0;
+            if (!entry) continue;
+            this.pending.delete(message.id);
+            try {
+              entry.resolve(unwrap(message));
+            } catch (error2) {
+              entry.reject(error2 instanceof Error ? error2 : new McpHttpError("protocol", String(error2)));
+            }
+          }
+          return void 0;
+        }, this.maxBytes);
+        fail(new McpHttpError("network", "event stream ended"));
+      }).catch((error2) => {
+        fail(error2 instanceof McpHttpError ? error2 : 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: (error2) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(error2);
+        }
+      });
+      this.ssePost(frame, signal).catch((error2) => {
+        this.pending.delete(id);
+        signal.removeEventListener("abort", onAbort);
+        reject(error2 instanceof Error ? error2 : new McpHttpError("network", String(error2)));
+      });
+    });
+  }
+  deliverNotifications(parsed) {
+    for (const message of Array.isArray(parsed) ? parsed : parsed ? [parsed] : []) {
+      if (typeof message.method === "string" && message.id === void 0) this.onNotification?.(message);
+    }
+  }
+};
+
+// server/mcp-remote-proxy.ts
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function requestKey(id) {
+  return typeof id === "string" || typeof id === "number" && Number.isFinite(id) ? `${typeof id}:${id}` : void 0;
+}
+function send(frame) {
+  process.stdout.write(`${JSON.stringify(frame)}
+`);
+}
+function error(id, code, message) {
+  send({ jsonrpc: "2.0", id: requestKey(id) ? id : null, error: { code, message } });
+}
+var spec;
+try {
+  spec = remoteMcpSpec(JSON.parse(process.env.OMB_REMOTE_MCP_SERVER ?? ""));
+} catch {
+}
+delete process.env.OMB_REMOTE_MCP_SERVER;
+if (!spec) {
+  process.stderr.write("mcp-remote-proxy: invalid remote MCP configuration\n");
+  process.exit(1);
+}
+var client = new RemoteMcpClient(spec, { maxBytes: 32 * 1024 * 1024, onNotification: send });
+var pending = /* @__PURE__ */ new Map();
+var tasks = /* @__PURE__ */ new Set();
+var initialized = false;
+var closing = false;
+async function handle(message) {
+  const id = requestKey(message.id);
+  if (typeof message.method !== "string" || message.jsonrpc !== "2.0") {
+    error(message.id, -32600, "Invalid JSON-RPC request");
+    return;
+  }
+  if (message.method === "notifications/cancelled") {
+    const key = isRecord2(message.params) ? requestKey(message.params.requestId) : void 0;
+    if (key) pending.get(key)?.abort();
+    return;
+  }
+  if (!id) {
+    if (message.method === "notifications/initialized" && initialized) return;
+    try {
+      await client.notify(message.method, message.params, AbortSignal.timeout(3e4));
+    } catch {
+    }
+    return;
+  }
+  if (pending.has(id)) {
+    error(message.id, -32600, "Duplicate request ID");
+    return;
+  }
+  const controller = new AbortController();
+  pending.set(id, controller);
+  const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(message.method === "tools/call" ? 12e4 : 3e4)]);
+  try {
+    const result = message.method === "initialize" ? await client.initialize("OpenMausBot tool proxy", signal) : await client.request(message.method, message.params, signal);
+    if (message.method === "initialize") initialized = true;
+    send({ jsonrpc: "2.0", id: message.id, result });
+  } catch {
+    error(message.id, signal.aborted ? -32800 : -32603, signal.aborted ? "MCP request cancelled" : "Remote MCP request failed");
+  } finally {
+    pending.delete(id);
+  }
+}
+var input = createInterface({ input: process.stdin });
+input.on("line", (line) => {
+  if (closing || !line.trim()) return;
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    error(null, -32700, "Invalid JSON-RPC frame");
+    return;
+  }
+  if (!isRecord2(value)) {
+    error(null, -32600, "Invalid JSON-RPC frame");
+    return;
+  }
+  const task = handle(value);
+  tasks.add(task);
+  void task.finally(() => tasks.delete(task));
+});
+async function shutdown() {
+  if (closing) return;
+  closing = true;
+  input.close();
+  for (const controller of pending.values()) controller.abort();
+  await Promise.allSettled(tasks);
+  await client.close();
+  process.exit(0);
+}
+input.on("close", () => {
+  void shutdown();
+});
+process.on("SIGTERM", () => {
+  void shutdown();
+});
+process.on("SIGINT", () => {
+  void shutdown();
+});