clay-server 2.28.0-beta.1 → 2.28.0-beta.2

package/lib/project-mcp.js

@@ -0,0 +1,371 @@
+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.
+
+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 ----------
+
+  function handleMcpMessage(ws, msg) {
+    if (msg.type === "mcp_servers_available") {
+      handleServersAvailable(ws, msg);
+      return true;
+    }
+    if (msg.type === "mcp_tool_result") {
+      handleToolResult(msg);
+      return true;
+    }
+    if (msg.type === "mcp_tool_error") {
+      handleToolError(msg);
+      return true;
+    }
+    if (msg.type === "mcp_toggle_server") {
+      handleToggleServer(ws, msg);
+      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;
+    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;
+    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 () {
+          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 };
+
+        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;
+    }
+    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",
+        });
+      }
+    }
+
+    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();
+  }
+
+  function rebuildAndBroadcast() {
+    rebuildProxyServers();
+    broadcastMcpState();
+  }
+
+  return {
+    handleMcpMessage: handleMcpMessage,
+    getMcpServers: getMcpServers,
+    sendConnectionState: sendConnectionState,
+    handleExtensionDisconnect: handleExtensionDisconnect,
+    rebuildAndBroadcast: rebuildAndBroadcast,
+  };
+}
+
+module.exports = { attachMcp: attachMcp };

package/lib/project-user-message.js

@@ -210,6 +210,7 @@ function attachUserMessage(ctx) {
     // --- Browser Extension ---
     if (msg.type === "browser_tab_list") {
       browserState._extensionWs = ws; // Track which client has the extension
+      if (msg.extensionId) browserState._extensionId = msg.extensionId;
       var tabs = msg.tabs || [];
       browserState._browserTabList = {};
       for (var bti = 0; bti < tabs.length; bti++) {

package/lib/project.js

@@ -26,6 +26,8 @@ var { attachFilesystem } = require("./project-filesystem");
 var { attachSessions } = require("./project-sessions");
 var { attachUserMessage } = require("./project-user-message");
 var { attachConnection } = require("./project-connection");
+var { attachMcp } = require("./project-mcp");
+var { createLocalMcp } = require("./mcp-local");
 // project-notifications is attached globally in server.js, passed via opts.notificationsModule
 
 // --- Context Sources persistence ---
@@ -218,22 +220,24 @@ function createProjectContext(opts) {
   // --- Per-project clients ---
   var clients = new Set();
 
-  // --- Browser extension state ---
-  var _browserTabList = {}; // tabId -> { id, url, title, favIconUrl }
+  // --- Browser extension state (shared mutable object) ---
   var _pendingDebateProposals = {}; // proposalId -> { resolve, briefData }
-  var _extensionWs = null; // WebSocket of the client with the Chrome extension
   var _extToken = crypto.randomUUID(); // Auth token for MCP server bridge
-  var pendingExtensionRequests = {}; // requestId -> { resolve, timer }
+  var browserState = {
+    _browserTabList: {},
+    _extensionWs: null,
+    pendingExtensionRequests: {}
+  };
 
   function sendExtensionCommand(ws, command, args, timeout) {
     return new Promise(function(resolve) {
       var requestId = crypto.randomUUID();
       var ms = timeout || 3000;
       var timer = setTimeout(function() {
-        delete pendingExtensionRequests[requestId];
+        delete browserState.pendingExtensionRequests[requestId];
         resolve(null);
       }, ms);
-      pendingExtensionRequests[requestId] = { resolve: resolve, timer: timer };
+      browserState.pendingExtensionRequests[requestId] = { resolve: resolve, timer: timer };
       sendTo(ws, {
         type: "extension_command",
         command: command,
@@ -245,10 +249,10 @@ function createProjectContext(opts) {
 
   // Send extension command via the tracked extension client (for MCP bridge)
   function sendExtensionCommandAny(command, args, timeout) {
-    if (!_extensionWs || _extensionWs.readyState !== 1) {
+    if (!browserState._extensionWs || browserState._extensionWs.readyState !== 1) {
       return Promise.reject(new Error("Browser extension not connected"));
     }
-    return sendExtensionCommand(_extensionWs, command, args, timeout);
+    return sendExtensionCommand(browserState._extensionWs, command, args, timeout);
   }
 
   function requestTabContext(ws, tabId) {
@@ -405,6 +409,29 @@ function createProjectContext(opts) {
   // before the SDK has warmed up and fired system/init.
   if (sm._savedDefaultModel) sm.currentModel = sm._savedDefaultModel;
 
+  // --- Local MCP (direct process management for localhost clients) ---
+  var _localMcp = createLocalMcp();
+
+  // --- MCP bridge (remote MCP servers via Chrome Extension) ---
+  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) : [];
+    },
+    setEnabledMcpServers: function (servers) {
+      if (typeof opts.onSetProjectMcpServers === "function") {
+        opts.onSetProjectMcpServers(slug, servers);
+      }
+    },
+    localMcp: _localMcp,
+  });
+
   // --- SDK bridge ---
   var sdk = createSDKBridge({
     cwd: cwd,
@@ -445,7 +472,7 @@ function createProjectContext(opts) {
         try {
           var browserMcp = require("./browser-mcp-server");
           var mcpConfig = browserMcp.create(sendExtensionCommandAny, function () {
-            return Object.values(_browserTabList || {});
+            return Object.values(browserState._browserTabList || {});
           }, {
             watchTab: function (tabId) {
               var key = "tab:" + tabId;
@@ -479,6 +506,7 @@ function createProjectContext(opts) {
 
       return Object.keys(servers).length > 0 ? servers : undefined;
     })(),
+    getRemoteMcpServers: function () { return _mcp.getMcpServers(); },
     onProcessingChanged: onProcessingChanged,
     onTurnDone: isMate ? function (session, preview) {
       digestDmTurn(session, preview);
@@ -549,6 +577,14 @@ 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 ---
@@ -697,6 +733,9 @@ function createProjectContext(opts) {
       return;
     }
 
+    // --- MCP bridge (remote MCP servers via extension) ---
+    if (_mcp.handleMcpMessage(ws, msg)) return;
+
     // --- Knowledge file management (delegated to project-knowledge.js) ---
     if (_knowledge.handleKnowledgeMessage(ws, msg)) return;
 
@@ -910,7 +949,7 @@ function createProjectContext(opts) {
     imagesDir: imagesDir,
     onProcessingChanged: onProcessingChanged,
     _loop: _loop,
-    browserState: { _browserTabList: _browserTabList, _extensionWs: _extensionWs, pendingExtensionRequests: pendingExtensionRequests },
+    browserState: browserState,
     sendExtensionCommandAny: sendExtensionCommandAny,
     requestTabContext: requestTabContext,
     scheduleMessage: scheduleMessage,
@@ -964,7 +1003,7 @@ function createProjectContext(opts) {
     getOsUserInfoForReq: getOsUserInfoForReq,
     sendExtensionCommandAny: sendExtensionCommandAny,
     _extToken: _extToken,
-    _browserTabList: _browserTabList,
+    _browserTabList: browserState._browserTabList,
   });
   var handleHTTP = _http.handleHTTP;
 
@@ -986,6 +1025,7 @@ function createProjectContext(opts) {
     sendTo: sendTo,
     opts: opts,
     _loop: _loop,
+    _mcp: _mcp,
     _notifications: _notifications,
     hydrateImageRefs: hydrateImageRefs,
     broadcastClientCount: broadcastClientCount,

package/lib/public/app.js

@@ -33,6 +33,7 @@ import { initTools, resetToolState, saveToolState, restoreToolState, renderAskUs
 import { initServerSettings, updateSettingsStats, updateSettingsModels, updateDaemonConfig, handleSetPinResult, handleKeepAwakeChanged, handleAutoContinueChanged, handleRestartResult, handleShutdownResult, handleSharedEnv, handleSharedEnvSaved, handleGlobalClaudeMdRead, handleGlobalClaudeMdWrite } from './modules/server-settings.js';
 import { initProjectSettings, handleInstructionsRead, handleInstructionsWrite, handleProjectEnv, handleProjectEnvSaved, isProjectSettingsOpen, handleProjectSharedEnv, handleProjectSharedEnvSaved, handleProjectOwnerChanged } from './modules/project-settings.js';
 import { initSkills, handleSkillInstalled, handleSkillUninstalled } from './modules/skills.js';
+import { initMcp } from './modules/mcp-ui.js';
 import { initScheduler, resetScheduler, handleLoopRegistryUpdated, handleScheduleRunStarted, handleScheduleRunFinished, handleLoopScheduled, openSchedulerToTab, isSchedulerOpen, closeScheduler, enterCraftingMode, exitCraftingMode, handleLoopRegistryFiles, getUpcomingSchedules } from './modules/scheduler.js';
 import { initAsciiLogo, startLogoAnimation, stopLogoAnimation } from './modules/ascii-logo.js';
 import { initPlaybook, openPlaybook, getPlaybooks, getPlaybookForTip, isCompleted as isPlaybookCompleted } from './modules/playbook.js';
@@ -1080,6 +1081,9 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
 
   // --- Ralph Preview Modal (delegated to app-loop-ui.js) ---
 
+  // --- MCP Servers ---
+  initMcp();
+
   // --- Skills ---
   initSkills({
     get ws() { return ws; },