clay-server 4.9.0-beta.1 → 5.0.0-beta.1

package/lib/project-mcp.js

@@ -1,375 +1,148 @@
-var crypto = require("crypto");
-
-// MCP Bridge module: manages remote MCP servers reported by the Chrome Extension.
-// Creates proxy MCP server objects that forward tool calls over WebSocket.
-// Follows the attachXxx(ctx) pattern per MODULE_MAP.md.
+var crypto = require('crypto');
+var createProxy = require('./mcp-proxy').createProxy;
+var createStore = require('./mcp-connection-store').createConnectionStore;
+var createRemoteConnections = require('./mcp-remote-connections').createRemoteConnections;
 
 function attachMcp(ctx) {
-  var send = ctx.send;
-  var sendTo = ctx.sendTo;
-  var slug = ctx.slug;
-  var isMate = ctx.isMate;
-  var getEnabledMcpServers = ctx.getEnabledMcpServers;
-  var setEnabledMcpServers = ctx.setEnabledMcpServers;
-  var getExtensionWs = ctx.getExtensionWs;
-  var getExtensionId = ctx.getExtensionId || function () { return null; };
-  var localMcp = ctx.localMcp || null; // mcp-local instance for localhost clients
-
-  // Available servers reported by extension: { name -> { name, transport, tools, enabled } }
-  var _availableServers = {};
-
-  // Proxy MCP server objects for the SDK: { name -> sdkMcpServerConfig }
-  var _proxyServers = {};
-
-  // Pending tool calls: { callId -> { resolve, reject, timer } }
-  var _pendingCalls = {};
-
-  var TOOL_TIMEOUT_MS = 30000;
-
-  // ---------- Message Handler ----------
-
+  var devices = new Map(), pending = new Map();
+  function ownerFor(ws) {
+    if (!ctx.canAccess(ws)) throw new Error('MCP access is not permitted.');
+    return ctx.isMultiUser() ? String(ws._clayUser.id) : 'default';
+  }
+  function authorizeOwner(owner) { if (!ctx.canUseOwner(owner)) throw new Error('MCP account is unavailable.'); }
+  function sendOwner(owner, msg) {
+    ctx.clients.forEach(function (ws) {
+      try { if (ws.readyState === 1 && ownerFor(ws) === owner) ctx.sendTo(ws, Object.assign({ slug: ctx.slug }, msg)); } catch (error) {}
+    });
+  }
+  var remote = createRemoteConnections({
+    remoteFetch: ctx.remoteFetch, createLoginBrowser: ctx.createLoginBrowser,
+    storage: ctx.storage || createStore(ctx.root, ctx.slug), authorize: authorizeOwner,
+    changed: function (owner) { broadcast(owner); }, sendOwner: sendOwner, sendTo: function (ws, msg) { ctx.sendTo(ws, Object.assign({ slug: ctx.slug }, msg)); },
+    identity: ctx.identity,
+    canAccess: function (ws, owner) { try { return ownerFor(ws) === owner; } catch (error) { return false; } },
+  });
+  function deviceFor(owner) {
+    var device = devices.get(owner);
+    if (!device || device.ws.readyState !== 1) return null;
+    try { if (ownerFor(device.ws) !== owner) return null; } catch (error) { return null; }
+    return device;
+  }
+  function enabled(owner, name) {
+    var legacy = !ctx.isMultiUser() && (ctx.getEnabledMcpServers() || []).indexOf(name) >= 0;
+    return remote.computerEnabled(owner, name, legacy);
+  }
+  function buildState(owner) {
+    var active = deviceFor(owner), device = devices.get(owner), servers = remote.view(owner);
+    if (device) device.servers.forEach(function (server) {
+      servers.push({ id: server.name, name: server.name, label: server.name, source: 'computer', transport: 'stdio',
+        toolCount: server.tools.length, tools: server.tools, projectEnabled: enabled(owner, server.name),
+        extensionEnabled: server.enabled, status: active && server.enabled && device.hostConnected ? 'ready' : 'unavailable',
+        error: active && device.hostConnected ? '' : 'Reconnect the local bridge on your computer.' });
+    });
+    return { type: 'mcp_servers_state', slug: ctx.slug, servers: servers,
+      hostConnected: !!(active && device.hostConnected), extensionConnected: !!active,
+      extensionId: device ? device.extensionId : null };
+  }
+  function broadcast(owner) {
+    try { sendOwner(owner, buildState(owner)); } catch (error) {}
+  }
+  function sendConnectionState(ws) {
+    try { ctx.sendTo(ws, buildState(ownerFor(ws))); } catch (error) {}
+  }
+  function disconnectDevice(ws) {
+    devices.forEach(function (device, owner) {
+      if (ws && device.ws !== ws) return;
+      if (!ws && device.ws.readyState === 1) return;
+      device.hostConnected = false;
+      pending.forEach(function (call, id) {
+        if (call.ws !== device.ws) return;
+        clearTimeout(call.timer); pending.delete(id); call.reject(new Error('Your computer disconnected.'));
+      });
+      broadcast(owner);
+    });
+  }
   function handleMcpMessage(ws, msg) {
-    if (msg.type === "mcp_servers_available") {
-      handleServersAvailable(ws, msg);
-      return true;
+    if (!msg || typeof msg.type !== 'string' || (msg.type.indexOf('mcp_') !== 0 && msg.type !== 'mcp_toggle_server')) return false;
+    var owner;
+    try { owner = ownerFor(ws); } catch (error) { return true; }
+    if (msg.type === 'mcp_state_request') { sendConnectionState(ws); return true; }
+    if (msg.type === 'mcp_servers_available') {
+      var servers = Array.isArray(msg.servers) ? msg.servers : [];
+      if (servers.length > 100 || JSON.stringify(servers).length > 2 * 1024 * 1024) return true;
+      servers = servers.filter(function (server) { return server && /^[a-zA-Z0-9_-]{1,80}$/.test(server.name) && !/^(clay-|remote-)/.test(server.name) && !Object.prototype.hasOwnProperty.call(Object.prototype, server.name) && !server.url && server.transport !== 'http'; }).map(function (server) {
+        return { name: server.name, enabled: server.enabled !== false, tools: Array.isArray(server.tools) ? server.tools.slice(0, 1000) : [] };
+      });
+      var old = devices.get(owner);
+      if (old && old.ws !== ws) disconnectDevice(old.ws);
+      devices.set(owner, { ws: ws, servers: servers, hostConnected: !!msg.hostConnected, extensionId: ctx.extensionId(ws) });
+      broadcast(owner); return true;
     }
-    if (msg.type === "mcp_tool_result") {
-      handleToolResult(msg);
+    if (msg.type === 'mcp_tool_result' || msg.type === 'mcp_tool_error') {
+      var call = pending.get(msg.callId);
+      if (!call || call.ws !== ws || call.owner !== owner) return true;
+      clearTimeout(call.timer); pending.delete(msg.callId);
+      try { call.authorize(); } catch (error) { call.reject(error); return true; }
+      if (msg.type === 'mcp_tool_error') call.reject(new Error('Computer MCP tool failed.'));
+      else call.resolve(msg.result || { content: [] });
       return true;
     }
-    if (msg.type === "mcp_tool_error") {
-      handleToolError(msg);
+    if (msg.type.indexOf('mcp_login_') === 0) { remote.handleBrowser(owner, ws, msg); return true; }
+    if (msg.type === 'mcp_toggle_server') {
+      var device = deviceFor(owner);
+      if (device && device.servers.some(function (server) { return server.name === msg.name; })) {
+        try { remote.toggleComputer(owner, msg.name, msg.enabled); } catch (error) { ctx.sendTo(ws, { type: 'mcp_action_result', ok: false, error: error.message }); }
+      }
       return true;
     }
-    if (msg.type === "mcp_toggle_server") {
-      handleToggleServer(ws, msg);
+    if (msg.type === 'mcp_connection_action') {
+      remote.command(owner, msg, ws).then(function (id) {
+        if (ownerFor(ws) === owner) ctx.sendTo(ws, { type: 'mcp_action_result', slug: ctx.slug, requestId: msg.requestId, ok: true, id: id, action: msg.action });
+      }).catch(function (error) {
+        try { if (ownerFor(ws) === owner) ctx.sendTo(ws, { type: 'mcp_action_result', slug: ctx.slug, requestId: msg.requestId, ok: false, error: error.message }); } catch (ignored) {}
+      });
       return true;
     }
     return false;
   }
-
-  var _remoteHostConnected = false;
-
-  function handleServersAvailable(ws, msg) {
-    var servers = msg.servers || [];
-    _remoteHostConnected = !!msg.hostConnected;
-    _availableServers = {};
-    for (var i = 0; i < servers.length; i++) {
-      var s = servers[i];
-      _availableServers[s.name] = {
-        name: s.name,
-        transport: s.transport || "stdio",
-        tools: s.tools || [],
-        enabled: s.enabled !== false,
-      };
-    }
-
-    // Rebuild proxy servers based on project-level enabled list
-    rebuildProxyServers();
-
-    // Broadcast updated state to all clients
-    broadcastMcpState();
-  }
-
-  function handleToolResult(msg) {
-    var callId = msg.callId;
-    console.log("[mcp-bridge] Tool result received: " + callId);
-    var pending = _pendingCalls[callId];
-    if (!pending) return;
-    if (pending.timer) clearTimeout(pending.timer);
-    delete _pendingCalls[callId];
-    pending.resolve(msg.result || { content: [{ type: "text", text: "(empty result)" }] });
-  }
-
-  function handleToolError(msg) {
-    var callId = msg.callId;
-    console.log("[mcp-bridge] Tool error received: " + callId + " error=" + (msg.error || "unknown"));
-    var pending = _pendingCalls[callId];
-    if (!pending) return;
-    if (pending.timer) clearTimeout(pending.timer);
-    delete _pendingCalls[callId];
-    pending.reject(new Error(msg.error || "MCP tool call failed"));
-  }
-
-  function handleToggleServer(ws, msg) {
-    var name = msg.name;
-    var enabled = !!msg.enabled;
-
-    var list = getEnabledMcpServers() || [];
-    var idx = list.indexOf(name);
-
-    if (enabled && idx === -1) {
-      list.push(name);
-    } else if (!enabled && idx !== -1) {
-      list.splice(idx, 1);
-    }
-
-    setEnabledMcpServers(list);
-    rebuildProxyServers();
-    broadcastMcpState();
-  }
-
-  // ---------- Proxy Server Builder ----------
-
-  function rebuildProxyServers() {
-    _proxyServers = {};
-
-    var sdk;
-    try {
-      sdk = require("@anthropic-ai/claude-agent-sdk");
-    } catch (e) {
-      console.error("[mcp-bridge] Failed to load SDK:", e.message);
-      return;
-    }
-
-    var createSdkMcpServer = sdk.createSdkMcpServer;
-    var tool = sdk.tool;
-    if (!createSdkMcpServer || !tool) {
-      console.error("[mcp-bridge] SDK missing createSdkMcpServer or tool helper");
-      return;
-    }
-
-    var z;
-    try { z = require("zod").z; } catch (e) {
-      try { z = require("zod"); } catch (e2) {
-        console.error("[mcp-bridge] Failed to load zod:", e2.message);
-        return;
-      }
-    }
-
-    var enabledList = getEnabledMcpServers() || [];
-
-    // --- Remote servers (via Extension) ---
-    var serverNames = Object.keys(_availableServers);
-    for (var si = 0; si < serverNames.length; si++) {
-      var serverName = serverNames[si];
-      var serverInfo = _availableServers[serverName];
-
-      if (!serverInfo.enabled) continue;
-      if (enabledList.indexOf(serverName) === -1) continue;
-
-      var tools = [];
-      var serverTools = serverInfo.tools || [];
-
-      for (var ti = 0; ti < serverTools.length; ti++) {
-        var mcpTool = serverTools[ti];
-        var toolName = mcpTool.name;
-        var toolDesc = mcpTool.description || toolName;
-        var shape = buildZodShape(z, mcpTool.inputSchema);
-
-        tools.push(tool(
-          toolName,
-          toolDesc,
-          shape,
-          createToolHandler(serverName, toolName)
-        ));
-      }
-
-      if (tools.length > 0) {
-        var mcpServer = createSdkMcpServer({
-          name: serverName,
-          version: "1.0.0",
-          tools: tools,
-        });
-        _proxyServers[serverName] = mcpServer;
-      }
-    }
-
-    // --- Local servers (direct process, localhost only) ---
-    if (localMcp && localMcp.isReady()) {
-      var localServers = localMcp.getAvailableServers();
-      for (var li = 0; li < localServers.length; li++) {
-        var ls = localServers[li];
-        if (!ls.ready) continue;
-        if (_proxyServers[ls.name]) continue; // remote takes precedence if same name
-        if (enabledList.indexOf(ls.name) === -1) continue;
-
-        var localTools = [];
-        for (var lti = 0; lti < ls.tools.length; lti++) {
-          var lt = ls.tools[lti];
-          var ltShape = buildZodShape(z, lt.inputSchema);
-          localTools.push(tool(
-            lt.name,
-            lt.description || lt.name,
-            ltShape,
-            createLocalToolHandler(ls.name, lt.name)
-          ));
-        }
-
-        if (localTools.length > 0) {
-          _proxyServers[ls.name] = createSdkMcpServer({
-            name: ls.name,
-            version: "1.0.0",
-            tools: localTools,
-          });
-        }
-      }
-    }
-  }
-
-  function createLocalToolHandler(serverName, toolName) {
-    return function (args) {
-      return localMcp.callTool(serverName, toolName, args);
-    };
-  }
-
-  function createToolHandler(serverName, toolName) {
-    return function (args) {
-      return new Promise(function (resolve, reject) {
-        var extWs = getExtensionWs();
-        if (!extWs || extWs.readyState !== 1) {
-          reject(new Error("Browser extension not connected. Cannot reach MCP server: " + serverName));
-          return;
-        }
-
-        var callId = "mc_" + Date.now() + "_" + crypto.randomUUID().slice(0, 8);
-
-        var timer = setTimeout(function () {
-          console.log("[mcp-bridge] Tool call TIMEOUT: " + callId + " server=" + serverName + " tool=" + toolName);
-          delete _pendingCalls[callId];
-          reject(new Error("MCP tool call timed out after " + (TOOL_TIMEOUT_MS / 1000) + "s"));
-        }, TOOL_TIMEOUT_MS);
-
-        _pendingCalls[callId] = { resolve: resolve, reject: reject, timer: timer };
-
-        console.log("[mcp-bridge] Sending tool call: " + callId + " server=" + serverName + " tool=" + toolName);
-        sendTo(extWs, {
-          type: "mcp_tool_call",
-          callId: callId,
-          server: serverName,
-          method: "tools/call",
-          params: { name: toolName, arguments: args },
-        });
-      });
-    };
-  }
-
-  // Build a Zod shape from MCP JSON Schema inputSchema
-  function buildZodShape(z, inputSchema) {
-    if (!inputSchema || !inputSchema.properties) return {};
-    var shape = {};
-    var props = inputSchema.properties;
-    var required = inputSchema.required || [];
-    var keys = Object.keys(props);
-
-    for (var i = 0; i < keys.length; i++) {
-      var k = keys[i];
-      var p = props[k];
-      var field;
-
-      if (p.type === "number" || p.type === "integer") {
-        field = z.number();
-      } else if (p.type === "boolean") {
-        field = z.boolean();
-      } else if (p.type === "array") {
-        field = z.array(z.any());
-      } else if (p.type === "object") {
-        field = z.record(z.any());
-      } else if (p.enum) {
-        field = z.enum(p.enum);
-      } else {
-        field = z.string();
-      }
-
-      if (p.description) field = field.describe(p.description);
-      if (required.indexOf(k) === -1) field = field.optional();
-      shape[k] = field;
+  function callComputer(owner, server, tool, args, authorize) {
+    return new Promise(function (resolve, reject) {
+      authorize();
+      var device = deviceFor(owner);
+      if (!device || !device.hostConnected || !enabled(owner, server)) throw new Error('Computer connection is unavailable or disabled.');
+      var row = device.servers.find(function (item) { return item.name === server && item.enabled; });
+      if (!row || !row.tools.some(function (item) { return item.name === tool; })) throw new Error('Computer tool is unavailable.');
+      var id = crypto.randomUUID();
+      var timer = setTimeout(function () { pending.delete(id); reject(new Error('Computer tool timed out.')); }, 60000);
+      pending.set(id, { owner: owner, ws: device.ws, resolve: resolve, reject: reject, timer: timer, authorize: function () {
+        authorize(); if (!enabled(owner, server) || deviceFor(owner) !== device) throw new Error('Computer access changed.');
+      } });
+      ctx.sendTo(device.ws, { type: 'mcp_tool_call', callId: id, server: server, method: 'tools/call', params: { name: tool, arguments: args } });
+    });
+  }
+  function getMcpServers(session) {
+    if (!session || !ctx.canUseSession(session)) return {};
+    var owner = ctx.isMultiUser() ? String(session.ownerId) : 'default';
+    function authorize() {
+      authorizeOwner(owner);
+      if (!ctx.canUseSession(session) || (ctx.isMultiUser() && String(session.ownerId) !== owner)) throw new Error('Session MCP access changed.');
     }
-    return shape;
-  }
-
-  // ---------- State Broadcasting ----------
-
-  function broadcastMcpState() {
-    var state = buildMcpState();
-    send(state);
-  }
-
-  function sendConnectionState(ws) {
-    sendTo(ws, buildMcpState());
-  }
-
-  function buildMcpState() {
-    var enabledList = getEnabledMcpServers() || [];
-    var servers = [];
-    var seen = {};
-
-    // Remote servers (from Extension)
-    var names = Object.keys(_availableServers);
-    for (var i = 0; i < names.length; i++) {
-      var name = names[i];
-      var info = _availableServers[name];
-      seen[name] = true;
-      servers.push({
-        name: name,
-        transport: info.transport,
-        toolCount: (info.tools || []).length,
-        extensionEnabled: info.enabled,
-        projectEnabled: enabledList.indexOf(name) !== -1,
-        source: "remote",
-      });
-    }
-
-    // Local servers
-    if (localMcp && localMcp.isReady()) {
-      var localServers = localMcp.getAvailableServers();
-      for (var j = 0; j < localServers.length; j++) {
-        var ls = localServers[j];
-        if (seen[ls.name]) continue;
-        servers.push({
-          name: ls.name,
-          transport: ls.transport || "stdio",
-          toolCount: ls.toolCount || 0,
-          extensionEnabled: true,
-          projectEnabled: enabledList.indexOf(ls.name) !== -1,
-          source: "local",
+    var result = {};
+    buildState(owner).servers.forEach(function (server) {
+      if (!server.projectEnabled || !server.extensionEnabled || !server.tools.length) return;
+      try {
+        result[server.name] = createProxy(server.name, server.tools, function (tool, args) {
+          return server.source === 'url' ? remote.call(owner, server.id, tool, args, authorize) : callComputer(owner, server.name, tool, args, authorize);
         });
-      }
-    }
-
-    return {
-      type: "mcp_servers_state",
-      servers: servers,
-      hostConnected: _remoteHostConnected || !!(localMcp && localMcp.isReady()),
-      extensionId: getExtensionId() || null,
-    };
-  }
-
-  // ---------- Public API ----------
-
-  function getMcpServers() {
-    return _proxyServers;
-  }
-
-  function cancelAllPending() {
-    var ids = Object.keys(_pendingCalls);
-    for (var i = 0; i < ids.length; i++) {
-      var pending = _pendingCalls[ids[i]];
-      if (pending.timer) clearTimeout(pending.timer);
-      pending.reject(new Error("MCP bridge disconnected"));
-    }
-    _pendingCalls = {};
-  }
-
-  function handleExtensionDisconnect() {
-    cancelAllPending();
-    _availableServers = {};
-    _proxyServers = {};
-    broadcastMcpState();
+      } catch (error) { /* Unsupported schemas are not advertised as callable tools. */ }
+    });
+    return result;
   }
-
-  function rebuildAndBroadcast() {
-    rebuildProxyServers();
-    broadcastMcpState();
+  function destroy() {
+    pending.forEach(function (call) { clearTimeout(call.timer); call.reject(new Error('MCP closed.')); }); pending.clear();
+    devices.clear(); remote.destroy();
   }
-
-  return {
-    handleMcpMessage: handleMcpMessage,
-    getMcpServers: getMcpServers,
-    sendConnectionState: sendConnectionState,
-    handleExtensionDisconnect: handleExtensionDisconnect,
-    rebuildAndBroadcast: rebuildAndBroadcast,
-  };
+  return { handleMcpMessage: handleMcpMessage, getMcpServers: getMcpServers, sendConnectionState: sendConnectionState,
+    handleExtensionDisconnect: disconnectDevice, rebuildAndBroadcast: function () { devices.forEach(function (device, owner) { broadcast(owner); }); }, destroy: destroy };
 }
-
 module.exports = { attachMcp: attachMcp };

package/lib/project-user-message.js

@@ -308,6 +308,7 @@ function attachUserMessage(ctx) {
 
     // --- Browser Extension ---
     if (msg.type === "browser_tab_list") {
+      ws._clayMcpExtensionId = typeof msg.extensionId === "string" ? msg.extensionId : null;
       browserState._extensionWs = ws; // Track which client has the extension
       if (msg.extensionId) browserState._extensionId = msg.extensionId;
       var tabs = msg.tabs || [];
@@ -394,6 +395,7 @@ function attachUserMessage(ctx) {
 
     var session = forcedSession || getSessionForWs(ws);
     if (!session) return true;
+    if (ws._clayUser && session.ownerId && ws._clayUser.id !== session.ownerId) session._mcpForeignInput = true;
     var pendingInternal = internal && internal.pendingConsumed ? internal : null;
     function finishPendingEarly(outcome, reason) {
       if (pendingInternal && typeof pendingInternal.complete === "function") pendingInternal.complete(outcome, reason);

package/lib/project.js

@@ -47,7 +47,6 @@ var { attachConnection } = require("./project-connection");
 var { attachProjectScheduledMessages } = require("./project-scheduled-messages");
 var { attachMcp } = require("./project-mcp");
 var { createSessionSkillCatalog } = require("./yoke/session-skill-catalog");
-var { createLocalMcp } = require("./mcp-local");
 var { attachEmail: attachEmailModule } = require("./project-email");
 var { attachSessionSpawn } = require("./project-session-spawn");
 var { attachDelegatedSession } = require("./project-delegated-session");
@@ -696,27 +695,30 @@ function createProjectContext(opts) {
   sm.defaultModelByVendor = sm.defaultModelByVendor || {};
   if (savedDefaultModel) sm.defaultModelByVendor[sm.defaultVendor || "claude"] = savedDefaultModel;
 
-  // --- Local MCP (direct process management for localhost clients) ---
-  var _localMcp = createLocalMcp();
-
-  // --- MCP bridge (remote MCP servers via Chrome Extension) ---
+  // Personal computer tools use the extension; remote URLs are owner-bound.
   var _mcp = attachMcp({
-    send: send,
-    sendTo: sendTo,
-    slug: slug,
-    isMate: isMate,
-    getExtensionWs: function () { return browserState._extensionWs; },
-    getExtensionId: function () { return browserState._extensionId || null; },
-    getEnabledMcpServers: function () {
-      return typeof opts.onGetProjectMcpServers === "function"
-        ? opts.onGetProjectMcpServers(slug) : [];
+    sendTo: sendTo, slug: slug, clients: clients,
+    root: require("./config").CONFIG_DIR,
+    isMultiUser: function () { return usersModule.isMultiUser(); },
+    canAccess: function (ws) { return _requestAccess.canAccessProject(ws, slug); },
+    canUseOwner: function (owner) {
+      if (!usersModule.isMultiUser()) return owner === "default";
+      var user = usersModule.findUserById(owner);
+      return !!user && _requestAccess.canAccessProject({ _clayUser: user }, slug);
     },
-    setEnabledMcpServers: function (servers) {
-      if (typeof opts.onSetProjectMcpServers === "function") {
-        opts.onSetProjectMcpServers(slug, servers);
-      }
+    canUseSession: function (session) {
+      if (!session || sm.sessions.get(session.localId) !== session) return false;
+      if (!usersModule.isMultiUser()) return true;
+      if (!require("./mcp-session-access").canUsePersonalConnections(session, sm.sessions)) return false;
+      var user = session.ownerId && usersModule.findUserById(session.ownerId);
+      return !!user && _requestAccess.canAccessProject({ _clayUser: user }, slug) &&
+        usersModule.canAccessSession(user.id, session, opts.getProjectAccess ? opts.getProjectAccess() : { visibility: "public" });
+    },
+    identity: function (ws) { return _requestAccess.osIdentity(ws); },
+    extensionId: function (ws) { return ws._clayMcpExtensionId || null; },
+    getEnabledMcpServers: function () {
+      return typeof opts.onGetProjectMcpServers === "function" ? opts.onGetProjectMcpServers(slug) : [];
     },
-    localMcp: _localMcp,
   });
 
   // --- Email module (delegated to project-email.js) ---
@@ -1372,7 +1374,7 @@ function createProjectContext(opts) {
     osUsers: osUsers,
     dangerouslySkipPermissions: dangerouslySkipPermissions,
     mcpServers: getLocalMcpServers,
-    getRemoteMcpServers: function () { return _mcp.getMcpServers(); },
+    getRemoteMcpServers: function (session) { return _mcp.getMcpServers(session); },
     clayPort: serverPort,
     clayTls: serverTls,
     clayAuthToken: serverAuthToken,
@@ -1706,14 +1708,6 @@ function createProjectContext(opts) {
   // --- WS connection handler (delegated to project-connection.js) ---
   function handleConnection(ws, wsUser) {
     _connection.handleConnection(ws, wsUser, handleMessage, handleDisconnection);
-
-    // Initialize local MCP when a localhost client connects
-    if (ws._clayLocal && _localMcp && !_localMcp.isReady()) {
-      _localMcp.initialize(function () {
-        // Rebuild proxy servers and broadcast state when local servers are ready
-        _mcp.rebuildAndBroadcast();
-      });
-    }
   }
 
   // --- WS message handler ---
@@ -2028,6 +2022,7 @@ function createProjectContext(opts) {
 
   // --- WS disconnection handler (delegated to project-connection.js) ---
   function handleDisconnection(ws) {
+    _mcp.handleExtensionDisconnect(ws);
     // Clean up extension WS reference if this was the extension client
     if (browserState._extensionWs === ws) {
       browserState._extensionWs = null;
@@ -2316,17 +2311,6 @@ function createProjectContext(opts) {
         && sm.sessions.get(boundSession.localId) === boundSession
         && Number(boundSession._sdkQueryGeneration || 0) === queryGeneration;
     }
-    // Build set of local MCP server names to exclude (Codex handles these natively)
-    var localMcpNames = {};
-    try {
-      var mcpLocalModule = require("./mcp-local");
-      var localConfig = mcpLocalModule.readMergedServers();
-      var lcNames = Object.keys(localConfig);
-      for (var li = 0; li < lcNames.length; li++) {
-        localMcpNames[lcNames[li]] = true;
-      }
-    } catch (e) { /* no local MCP config */ }
-
     return {
       listTools: function () {
         var tools = [];
@@ -2352,7 +2336,7 @@ function createProjectContext(opts) {
           var toolNames = Object.keys(server.instance._registeredTools);
           for (var j = 0; j < toolNames.length; j++) {
             var toolDef = server.instance._registeredTools[toolNames[j]];
-            var inputSchema = normalizeToolSchema(toolDef.inputSchema);
+            var inputSchema = toolDef._clayInputSchema || normalizeToolSchema(toolDef.inputSchema);
             tools.push({
               server: serverName,
               name: toolNames[j],
@@ -2459,13 +2443,11 @@ function createProjectContext(opts) {
           }
         }
 
-        // Remote MCP servers (extension-proxied only, skip local proxy servers)
-        var remoteServers = _mcp.getMcpServers();
+        // Personal computer and remote URL connections.
+        var remoteServers = _mcp.getMcpServers(boundSession);
         if (remoteServers) {
           var remoteNames = Object.keys(remoteServers);
           for (var ri = 0; ri < remoteNames.length; ri++) {
-            // Skip servers that Codex manages natively via Track 1
-            if (localMcpNames[remoteNames[ri]]) continue;
             extractServerTools(remoteNames[ri], remoteServers[remoteNames[ri]]);
           }
         }
@@ -2571,7 +2553,7 @@ function createProjectContext(opts) {
           }
         }
         // Try remote/local proxy servers
-        var remoteServers = _mcp.getMcpServers();
+        var remoteServers = _mcp.getMcpServers(boundSession);
         if (remoteServers && remoteServers[serverName]) {
           var rServer = remoteServers[serverName];
           if (rServer.instance && rServer.instance._registeredTools && rServer.instance._registeredTools[toolName]) {
@@ -2673,6 +2655,7 @@ function createProjectContext(opts) {
 
   // --- Destroy ---
   function destroy() {
+    _mcp.destroy();
     _sharedBrowser.destroy();
     _vendorLogin.destroy();
     if (_scheduledMessages) _scheduledMessages.shutdown();