clay-server 2.27.1 → 2.28.0-beta.2

package/lib/daemon.js

@@ -597,6 +597,27 @@ var relay = createServer({
     }
     return { ok: false, error: "Project not found" };
   },
+  onGetProjectMcpServers: function (slug) {
+    for (var i = 0; i < config.projects.length; i++) {
+      if (config.projects[i].slug === slug) {
+        return config.projects[i].enabledMcpServers || [];
+      }
+    }
+    return [];
+  },
+  onSetProjectMcpServers: function (slug, servers) {
+    for (var i = 0; i < config.projects.length; i++) {
+      if (config.projects[i].slug === slug) {
+        if (servers && servers.length > 0) {
+          config.projects[i].enabledMcpServers = servers;
+        } else {
+          delete config.projects[i].enabledMcpServers;
+        }
+        saveConfig(config);
+        return;
+      }
+    }
+  },
   onGetServerDefaultMode: function () {
     return { mode: config.defaultMode || null };
   },

package/lib/mcp-local.js

@@ -0,0 +1,355 @@
+// mcp-local.js - Local MCP process manager
+// Spawns and manages MCP stdio processes directly on the Clay server machine.
+// Used when the client connects from localhost (no Native Host needed).
+
+var child_process = require("child_process");
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+
+var CLAY_CONFIG_PATH = path.join(os.homedir(), ".clay", "mcp.json");
+
+function createLocalMcp() {
+  var _configCache = {};    // name -> { command, args, env, url }
+  var _processes = {};      // name -> { proc, buffer, ready, tools, pendingInit }
+  var _pendingRequests = {}; // rpcId -> { callId, resolve, reject, timer }
+  var _initCallbacks = {};  // rpcId -> { name, phase }
+  var _jsonRpcId = 1;
+  var _initialized = false;
+  var _onServersReady = null; // callback when server list changes
+
+  // ---------- Config ----------
+
+  function ensureConfig() {
+    var dir = path.dirname(CLAY_CONFIG_PATH);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(CLAY_CONFIG_PATH)) {
+      fs.writeFileSync(CLAY_CONFIG_PATH, JSON.stringify({ mcpServers: {}, include: [] }, null, 2));
+    }
+  }
+
+  function readConfig() {
+    ensureConfig();
+    try {
+      return JSON.parse(fs.readFileSync(CLAY_CONFIG_PATH, "utf8"));
+    } catch (e) {
+      return { mcpServers: {}, include: [] };
+    }
+  }
+
+  function writeConfig(config) {
+    ensureConfig();
+    fs.writeFileSync(CLAY_CONFIG_PATH, JSON.stringify(config, null, 2));
+  }
+
+  function getMergedServers() {
+    var config = readConfig();
+    var merged = Object.assign({}, config.mcpServers || {});
+
+    var includes = config.include || [];
+    for (var i = 0; i < includes.length; i++) {
+      var resolved = includes[i].replace(/^~/, os.homedir());
+      try {
+        var ext = JSON.parse(fs.readFileSync(resolved, "utf8"));
+        var extServers = ext.mcpServers || {};
+        var names = Object.keys(extServers);
+        for (var j = 0; j < names.length; j++) {
+          if (!merged[names[j]]) merged[names[j]] = extServers[names[j]];
+        }
+      } catch (e) {
+        // Skip unreadable files
+      }
+    }
+
+    _configCache = merged;
+    return merged;
+  }
+
+  // ---------- Process Spawning ----------
+
+  function spawnServer(name) {
+    if (_processes[name]) return;
+    var cfg = _configCache[name];
+    if (!cfg || cfg.url || !cfg.command) return;
+
+    var env = Object.assign({}, process.env, cfg.env || {});
+    var proc;
+    try {
+      proc = child_process.spawn(cfg.command, cfg.args || [], {
+        env: env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+      });
+    } catch (e) {
+      return;
+    }
+
+    var entry = {
+      proc: proc,
+      buffer: "",
+      ready: false,
+      tools: [],
+    };
+    _processes[name] = entry;
+
+    proc.stdout.on("data", function (chunk) {
+      entry.buffer += chunk.toString("utf8");
+      drainJsonRpc(name, entry);
+    });
+
+    proc.stderr.on("data", function () {
+      // Ignore stderr
+    });
+
+    proc.on("error", function () {
+      delete _processes[name];
+    });
+
+    proc.on("exit", function () {
+      delete _processes[name];
+    });
+
+    // MCP initialize handshake
+    var initId = _jsonRpcId++;
+    _initCallbacks[initId] = { name: name, phase: "initialize" };
+    proc.stdin.write(JSON.stringify({
+      jsonrpc: "2.0",
+      id: initId,
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "clay-mcp-local", version: "1.0.0" },
+      },
+    }) + "\n");
+  }
+
+  function killServer(name) {
+    var entry = _processes[name];
+    if (!entry) return;
+    entry.proc.kill("SIGTERM");
+    setTimeout(function () {
+      if (entry.proc && !entry.proc.killed) entry.proc.kill("SIGKILL");
+    }, 3000);
+    delete _processes[name];
+  }
+
+  // ---------- JSON-RPC Parser ----------
+
+  function drainJsonRpc(name, entry) {
+    var lines = entry.buffer.split("\n");
+    entry.buffer = lines.pop();
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      if (!line) continue;
+      try {
+        var msg = JSON.parse(line);
+        handleMcpResponse(name, msg);
+      } catch (e) {
+        // Skip unparseable
+      }
+    }
+  }
+
+  function handleMcpResponse(name, msg) {
+    // Init handshake responses
+    if (msg.id !== undefined && _initCallbacks[msg.id]) {
+      var cb = _initCallbacks[msg.id];
+      delete _initCallbacks[msg.id];
+
+      if (cb.phase === "initialize") {
+        var entry = _processes[name];
+        if (entry) {
+          // Send initialized notification
+          entry.proc.stdin.write(JSON.stringify({
+            jsonrpc: "2.0",
+            method: "notifications/initialized",
+          }) + "\n");
+
+          // Request tools/list
+          var toolsId = _jsonRpcId++;
+          _initCallbacks[toolsId] = { name: name, phase: "tools_list" };
+          entry.proc.stdin.write(JSON.stringify({
+            jsonrpc: "2.0",
+            id: toolsId,
+            method: "tools/list",
+            params: {},
+          }) + "\n");
+        }
+        return;
+      }
+
+      if (cb.phase === "tools_list") {
+        var tools = (msg.result && msg.result.tools) || [];
+        var entry2 = _processes[name];
+        if (entry2) {
+          entry2.tools = tools;
+          entry2.ready = true;
+        }
+        if (_onServersReady) _onServersReady();
+        return;
+      }
+    }
+
+    // Tool call responses
+    if (msg.id !== undefined && _pendingRequests[msg.id]) {
+      var req = _pendingRequests[msg.id];
+      delete _pendingRequests[msg.id];
+      if (req.timer) clearTimeout(req.timer);
+
+      if (msg.error) {
+        req.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+      } else {
+        req.resolve(msg.result);
+      }
+      return;
+    }
+  }
+
+  // ---------- Tool Call Relay ----------
+
+  function callTool(serverName, toolName, args) {
+    return new Promise(function (resolve, reject) {
+      var entry = _processes[serverName];
+      if (!entry || !entry.ready) {
+        reject(new Error("MCP server not running: " + serverName));
+        return;
+      }
+
+      var rpcId = _jsonRpcId++;
+      _pendingRequests[rpcId] = {
+        resolve: resolve,
+        reject: reject,
+        timer: setTimeout(function () {
+          delete _pendingRequests[rpcId];
+          reject(new Error("Tool call timed out after 30s"));
+        }, 30000),
+      };
+
+      entry.proc.stdin.write(JSON.stringify({
+        jsonrpc: "2.0",
+        id: rpcId,
+        method: "tools/call",
+        params: { name: toolName, arguments: args || {} },
+      }) + "\n");
+    });
+  }
+
+  // ---------- Public API ----------
+
+  function initialize(onReady) {
+    if (_initialized) return;
+    _initialized = true;
+    _onServersReady = onReady || null;
+
+    getMergedServers();
+    var names = Object.keys(_configCache);
+    for (var i = 0; i < names.length; i++) {
+      spawnServer(names[i]);
+    }
+  }
+
+  function shutdown() {
+    var names = Object.keys(_processes);
+    for (var i = 0; i < names.length; i++) {
+      killServer(names[i]);
+    }
+    _processes = {};
+    _initialized = false;
+  }
+
+  function getAvailableServers() {
+    var servers = [];
+    var names = Object.keys(_configCache);
+    for (var i = 0; i < names.length; i++) {
+      var name = names[i];
+      var cfg = _configCache[name];
+      var entry = _processes[name];
+      servers.push({
+        name: name,
+        transport: cfg.url ? "http" : "stdio",
+        ready: !!(entry && entry.ready),
+        tools: entry ? entry.tools : [],
+        toolCount: entry ? entry.tools.length : 0,
+        source: "local",
+      });
+    }
+    return servers;
+  }
+
+  function isReady() {
+    return _initialized;
+  }
+
+  function addServer(name, command, args, env) {
+    var config = readConfig();
+    config.mcpServers = config.mcpServers || {};
+    config.mcpServers[name] = { command: command, args: args || [], env: env || {} };
+    writeConfig(config);
+    _configCache[name] = config.mcpServers[name];
+    spawnServer(name);
+  }
+
+  function removeServer(name) {
+    var config = readConfig();
+    if (config.mcpServers && config.mcpServers[name]) {
+      delete config.mcpServers[name];
+      writeConfig(config);
+    }
+    killServer(name);
+    delete _configCache[name];
+  }
+
+  function addImport(filePath) {
+    var resolved = filePath.replace(/^~/, os.homedir());
+    try {
+      var ext = JSON.parse(fs.readFileSync(resolved, "utf8"));
+      var count = Object.keys(ext.mcpServers || {}).length;
+      if (count === 0) return { error: "No mcpServers found in " + filePath };
+    } catch (e) {
+      return { error: "Cannot read file: " + e.message };
+    }
+
+    var config = readConfig();
+    config.include = config.include || [];
+    if (config.include.indexOf(filePath) === -1) {
+      config.include.push(filePath);
+      writeConfig(config);
+    }
+
+    // Re-merge and spawn new servers
+    getMergedServers();
+    var names = Object.keys(_configCache);
+    for (var i = 0; i < names.length; i++) {
+      if (!_processes[names[i]]) spawnServer(names[i]);
+    }
+
+    return { ok: true, count: count };
+  }
+
+  function removeImport(filePath) {
+    var config = readConfig();
+    config.include = (config.include || []).filter(function (p) { return p !== filePath; });
+    writeConfig(config);
+  }
+
+  function getImports() {
+    var config = readConfig();
+    return config.include || [];
+  }
+
+  return {
+    initialize: initialize,
+    shutdown: shutdown,
+    callTool: callTool,
+    getAvailableServers: getAvailableServers,
+    isReady: isReady,
+    addServer: addServer,
+    removeServer: removeServer,
+    addImport: addImport,
+    removeImport: removeImport,
+    getImports: getImports,
+  };
+}
+
+module.exports = { createLocalMcp: createLocalMcp };

package/lib/project-connection.js

@@ -34,6 +34,7 @@ function attachConnection(ctx) {
   var sendTo = ctx.sendTo;
   var opts = ctx.opts;
   var _loop = ctx._loop;
+  var _mcp = ctx._mcp;
   var _notifications = ctx._notifications;
   var hydrateImageRefs = ctx.hydrateImageRefs;
   var broadcastClientCount = ctx.broadcastClientCount;
@@ -98,6 +99,7 @@ function attachConnection(ctx) {
     sendTo(ws, { type: "notes_list", notes: nm.list() });
     sendTo(ws, { type: "loop_registry_updated", records: getHubSchedules() });
     _loop.sendConnectionState(ws);
+    if (_mcp) _mcp.sendConnectionState(ws);
     if (_notifications) _notifications.sendConnectionState(ws, sendTo);
 
     // Session list (filtered for access control)

package/lib/project-loop.js

@@ -269,50 +269,56 @@ function attachLoop(ctx) {
 
   // --- Loop Registry (unified one-off + scheduled) ---
   var activeRegistryId = null; // track which registry record triggered current loop
+  var pendingTriggers = []; // queue for deferred triggers when skipIfRunning=false
+
+  function triggerFromQueue(record) {
+    // For schedule records, resolve the linked task to get loop files
+    var loopFilesId = record.id;
+    if (record.source === "schedule") {
+      if (!record.linkedTaskId) {
+        console.error("[loop-registry] Schedule has no linked task: " + record.name);
+        return;
+      }
+      loopFilesId = record.linkedTaskId;
+      console.log("[loop-registry] Schedule triggered: " + record.name + " -> linked task " + loopFilesId);
+    }
+
+    // Verify the loop directory and PROMPT.md exist
+    var recDir = path.join(cwd, ".claude", "loops", loopFilesId);
+    try {
+      fs.accessSync(path.join(recDir, "PROMPT.md"));
+    } catch (e) {
+      console.error("[loop-registry] PROMPT.md missing for " + loopFilesId);
+      return;
+    }
+    // Set the loopId to the schedule's own id (not the linked task) so sidebar groups correctly
+    loopState.loopId = record.id;
+    loopState.loopFilesId = loopFilesId;
+    // Restore loopMode from LOOP.json so simple loops work correctly on trigger
+    var _triggerCfg = {};
+    try { _triggerCfg = JSON.parse(fs.readFileSync(path.join(recDir, "LOOP.json"), "utf8")); } catch (e) {}
+    loopState.wizardData = { loopMode: _triggerCfg.loopMode || "judge" };
+    activeRegistryId = record.id;
+    console.log("[loop-registry] Auto-starting loop: " + record.name + " (" + loopState.loopId + ")");
+    send({ type: "schedule_run_started", recordId: record.id });
+    startLoop({ maxIterations: record.maxIterations, name: record.name });
+  }
 
   var loopRegistry = createLoopRegistry({
     cwd: cwd,
     onTrigger: function (record) {
-      // Skip trigger if a loop is already active and skipIfRunning is enabled
+      // Skip or queue trigger if a loop is already active
       if (loopState.active || loopState.phase === "executing") {
         if (record.skipIfRunning !== false) {
           console.log("[loop-registry] Skipping trigger for " + record.name + " — loop already active (skipIfRunning)");
           return;
         }
-        console.log("[loop-registry] Loop active but skipIfRunning disabled for " + record.name + "; deferring");
+        console.log("[loop-registry] Loop active, queuing trigger for " + record.name);
+        pendingTriggers.push(record);
         return;
       }
 
-      // For schedule records, resolve the linked task to get loop files
-      var loopFilesId = record.id;
-      if (record.source === "schedule") {
-        if (!record.linkedTaskId) {
-          console.error("[loop-registry] Schedule has no linked task: " + record.name);
-          return;
-        }
-        loopFilesId = record.linkedTaskId;
-        console.log("[loop-registry] Schedule triggered: " + record.name + " → linked task " + loopFilesId);
-      }
-
-      // Verify the loop directory and PROMPT.md exist
-      var recDir = path.join(cwd, ".claude", "loops", loopFilesId);
-      try {
-        fs.accessSync(path.join(recDir, "PROMPT.md"));
-      } catch (e) {
-        console.error("[loop-registry] PROMPT.md missing for " + loopFilesId);
-        return;
-      }
-      // Set the loopId to the schedule's own id (not the linked task) so sidebar groups correctly
-      loopState.loopId = record.id;
-      loopState.loopFilesId = loopFilesId;
-      // Restore loopMode from LOOP.json so simple loops work correctly on trigger
-      var _triggerCfg = {};
-      try { _triggerCfg = JSON.parse(fs.readFileSync(path.join(recDir, "LOOP.json"), "utf8")); } catch (e) {}
-      loopState.wizardData = { loopMode: _triggerCfg.loopMode || "judge" };
-      activeRegistryId = record.id;
-      console.log("[loop-registry] Auto-starting loop: " + record.name + " (" + loopState.loopId + ")");
-      send({ type: "schedule_run_started", recordId: record.id });
-      startLoop({ maxIterations: record.maxIterations, name: record.name });
+      triggerFromQueue(record);
     },
     onChange: function () {
       send({ type: "loop_registry_updated", records: getHubSchedules() });
@@ -383,6 +389,7 @@ function attachLoop(ctx) {
     loopState.results = [];
     loopState.stopping = false;
     loopState.name = loopOpts.name || null;
+    loopState.settings = loopConfig.settings || null;
     loopState.startedAt = Date.now();
     saveLoopState();
 
@@ -500,6 +507,7 @@ function attachLoop(ctx) {
     sendToSession(session.localId, { type: "status", status: "processing" });
     session.acceptEditsAfterStart = true;
     session.singleTurn = true;
+    if (loopState.settings) session.loopSettings = loopState.settings;
     sdk.startQuery(session, loopState.promptText, undefined, getLinuxUserForSession(session));
   }
 
@@ -616,6 +624,7 @@ function attachLoop(ctx) {
     judgeSession.sentToolResults = {};
     judgeSession.acceptEditsAfterStart = true;
     judgeSession.singleTurn = true;
+    if (loopState.settings) judgeSession.loopSettings = loopState.settings;
     sdk.startQuery(judgeSession, judgePrompt, undefined, getLinuxUserForSession(judgeSession));
   }
 
@@ -643,6 +652,16 @@ function attachLoop(ctx) {
 
   function finishLoop(reason) {
     console.log("[ralph-loop] finishLoop called, reason: " + reason + ", iteration: " + loopState.iteration);
+
+    // Unlock the last coder session so users can continue interacting with it
+    if (loopState.currentSessionId) {
+      var lastCoderSession = sm.sessions.get(loopState.currentSessionId);
+      if (lastCoderSession) {
+        lastCoderSession.singleTurn = false;
+        lastCoderSession.loop.active = false;
+      }
+    }
+
     loopState.active = false;
     loopState.phase = "done";
     loopState.stopping = false;
@@ -690,6 +709,15 @@ function attachLoop(ctx) {
         sessionId: loopState.currentSessionId,
       });
     }
+
+    // Process next queued trigger if any
+    if (pendingTriggers.length > 0) {
+      var next = pendingTriggers.shift();
+      console.log("[loop-registry] Processing queued trigger: " + next.name);
+      setTimeout(function () {
+        triggerFromQueue(next);
+      }, 1000);
+    }
   }
 
   function resumeLoop() {
@@ -774,6 +802,17 @@ function attachLoop(ctx) {
         send({ type: "loop_scheduled", recordId: loopState.loopId, cron: loopState.wizardData.cron });
         return true;
       }
+      // Save per-loop settings to LOOP.json if provided
+      if (msg.settings && Object.keys(msg.settings).length > 0) {
+        var lDir3 = loopDir();
+        if (lDir3) {
+          var ljPath = path.join(lDir3, "LOOP.json");
+          var lj = {};
+          try { lj = JSON.parse(fs.readFileSync(ljPath, "utf8")); } catch (e) {}
+          lj.settings = msg.settings;
+          fs.writeFileSync(ljPath, JSON.stringify(lj, null, 2), "utf8");
+        }
+      }
       startLoop({ maxIterations: msg.maxIterations });
       return true;
     }
@@ -789,6 +828,7 @@ function attachLoop(ctx) {
       var wizardCron = wData.cron || null;
       var newLoopId = generateLoopId();
       loopState.loopId = newLoopId;
+      var recordSource = wData.source === "task" ? null : "ralph";
       loopState.wizardData = {
         name: wData.name || wData.task || "Untitled",
         task: wData.task || "",
@@ -797,13 +837,13 @@ function attachLoop(ctx) {
         loopMode: wData.loopMode || "judge",
         promptAuthor: wData.promptAuthor || "clay",
         judgeAuthor: wData.judgeAuthor || null,
+        source: recordSource,
       };
       loopState.phase = "crafting";
       loopState.startedAt = Date.now();
       saveLoopState();
 
       // Register in loop registry
-      var recordSource = wData.source === "task" ? null : "ralph";
       loopRegistry.register({
         id: newLoopId,
         name: loopState.wizardData.name,
@@ -963,17 +1003,59 @@ function attachLoop(ctx) {
       var lDir = path.join(cwd, ".claude", "loops", recId);
       var promptContent = "";
       var judgeContent = "";
+      var loopSettings = null;
       try { promptContent = fs.readFileSync(path.join(lDir, "PROMPT.md"), "utf8"); } catch (e) {}
       try { judgeContent = fs.readFileSync(path.join(lDir, "JUDGE.md"), "utf8"); } catch (e) {}
+      try {
+        var loopJson = JSON.parse(fs.readFileSync(path.join(lDir, "LOOP.json"), "utf8"));
+        loopSettings = loopJson.settings || null;
+      } catch (e) {}
       send({
         type: "loop_registry_files_content",
         id: recId,
         prompt: promptContent,
         judge: judgeContent,
+        settings: loopSettings,
       });
       return true;
     }
 
+    if (msg.type === "loop_registry_save_files") {
+      var recId2 = msg.id;
+      var lDir2 = path.join(cwd, ".claude", "loops", recId2);
+      try {
+        fs.mkdirSync(lDir2, { recursive: true });
+        if (msg.prompt !== undefined) {
+          fs.writeFileSync(path.join(lDir2, "PROMPT.md"), msg.prompt, "utf8");
+        }
+        if (msg.judge !== undefined) {
+          fs.writeFileSync(path.join(lDir2, "JUDGE.md"), msg.judge, "utf8");
+        }
+        if (msg.settings !== undefined) {
+          var loopJsonPath2 = path.join(lDir2, "LOOP.json");
+          var loopJson2 = {};
+          try { loopJson2 = JSON.parse(fs.readFileSync(loopJsonPath2, "utf8")); } catch (e) {}
+          loopJson2.settings = msg.settings;
+          fs.writeFileSync(loopJsonPath2, JSON.stringify(loopJson2, null, 2), "utf8");
+        }
+        send({ type: "loop_registry_save_files_result", id: recId2, ok: true });
+        // Re-send updated content so the UI refreshes
+        var updatedPrompt = "";
+        var updatedJudge = "";
+        var updatedSettings = null;
+        try { updatedPrompt = fs.readFileSync(path.join(lDir2, "PROMPT.md"), "utf8"); } catch (e) {}
+        try { updatedJudge = fs.readFileSync(path.join(lDir2, "JUDGE.md"), "utf8"); } catch (e) {}
+        try {
+          var uj = JSON.parse(fs.readFileSync(path.join(lDir2, "LOOP.json"), "utf8"));
+          updatedSettings = uj.settings || null;
+        } catch (e) {}
+        send({ type: "loop_registry_files_content", id: recId2, prompt: updatedPrompt, judge: updatedJudge, settings: updatedSettings });
+      } catch (e) {
+        send({ type: "loop_registry_save_files_result", id: recId2, ok: false, error: e.message });
+      }
+      return true;
+    }
+
     if (msg.type === "ralph_preview_files") {
       var promptContent = "";
       var judgeContent = "";
@@ -1174,7 +1256,7 @@ function attachLoop(ctx) {
 
     // Ralph phase state
     // Derive source from wizardData for reconnect (so client can distinguish ralph vs task)
-    var _connSource = (loopState.wizardData && loopState.wizardData.source === "task") ? null : "ralph";
+    var _connSource = loopState.wizardData ? (loopState.wizardData.source || null) : null;
     sendTo(ws, {
       type: "ralph_phase",
       phase: loopState.phase,