clay-server 2.34.0-beta.1 → 2.34.0-beta.10

package/lib/sessions.js

@@ -96,6 +96,7 @@ function createSessionManager(opts) {
       if (session.vendor) metaObj.vendor = session.vendor;
       if (session.sessionVisibility) metaObj.sessionVisibility = session.sessionVisibility;
       if (session.bookmarked) metaObj.bookmarked = true;
+      if (typeof session.favoriteOrder === "number") metaObj.favoriteOrder = session.favoriteOrder;
       if (session.lastRewindUuid) metaObj.lastRewindUuid = session.lastRewindUuid;
       if (session.loop) metaObj.loop = session.loop;
       if (session.debateState) metaObj.debateState = session.debateState;
@@ -202,6 +203,7 @@ function createSessionManager(opts) {
       if (m.ownerId) session.ownerId = m.ownerId;
       session.sessionVisibility = m.sessionVisibility || "shared";
       session.bookmarked = !!m.bookmarked;
+      session.favoriteOrder = typeof m.favoriteOrder === "number" ? m.favoriteOrder : null;
       sessions.set(localId, session);
     }
   }
@@ -241,6 +243,7 @@ function createSessionManager(opts) {
       ownerId: s.ownerId || null,
       sessionVisibility: s.sessionVisibility || "shared",
       bookmarked: !!s.bookmarked,
+      favoriteOrder: typeof s.favoriteOrder === "number" ? s.favoriteOrder : null,
       unread: unreadMap[s.localId] || 0,
       vendor: s.vendor || null,
     };
@@ -303,6 +306,7 @@ function createSessionManager(opts) {
       ownerId: (sessionOpts && sessionOpts.ownerId) || null,
       sessionVisibility: (sessionOpts && sessionOpts.sessionVisibility) || "shared",
       bookmarked: false,
+      favoriteOrder: null,
       vendor: (sessionOpts && sessionOpts.vendor) || null,
     };
     sessions.set(localId, session);
@@ -334,6 +338,7 @@ function createSessionManager(opts) {
       ownerId: (sessionOpts && sessionOpts.ownerId) || null,
       sessionVisibility: (sessionOpts && sessionOpts.sessionVisibility) || "shared",
       bookmarked: false,
+      favoriteOrder: null,
       vendor: (sessionOpts && sessionOpts.vendor) || null,
     };
     sessions.set(localId, session);
@@ -525,6 +530,38 @@ function createSessionManager(opts) {
     sessions.delete(localId);
   }
 
+  function deleteSessionsBulk(localIds, targetWs) {
+    if (!Array.isArray(localIds) || localIds.length === 0) return;
+
+    var seen = {};
+    var ids = [];
+    for (var i = 0; i < localIds.length; i++) {
+      var id = localIds[i];
+      if (typeof id !== "number" || seen[id] || !sessions.has(id)) continue;
+      seen[id] = true;
+      ids.push(id);
+    }
+    if (ids.length === 0) return;
+
+    var deletedActive = false;
+    for (var j = 0; j < ids.length; j++) {
+      if (ids[j] === activeSessionId) deletedActive = true;
+      deleteSessionQuiet(ids[j]);
+    }
+
+    if (sessions.size === 0) {
+      createSession(null, targetWs);
+      return;
+    }
+
+    if (deletedActive) {
+      var remaining = [...sessions.keys()];
+      switchSession(remaining[remaining.length - 1], targetWs);
+    } else {
+      broadcastSessionList();
+    }
+  }
+
   function doSendToSession(session, obj) {
     // Send to active clients without recording to history/disk (ephemeral data)
     if (sendEach) {
@@ -622,6 +659,7 @@ function createSessionManager(opts) {
       history: cliHistory,
       messageUUIDs: [],
       bookmarked: false,
+      favoriteOrder: null,
     };
     sessions.set(localId, session);
     saveSessionFile(session);
@@ -680,35 +718,82 @@ function createSessionManager(opts) {
     var session = sessions.get(localId);
     if (!session) return { hits: [], total: 0 };
     var q = query.toLowerCase();
+    var qLen = query.length;
     var history = session.history;
     var hits = [];
-    var lastAssistantHitTurn = -1; // track current assistant turn to deduplicate delta hits
-    var currentTurnStart = -1;
+
+    // Assistant turns can consist of many streaming deltas (especially Codex,
+    // where agentMessage/delta fragments arrive in small chunks). We accumulate
+    // delta text per turn, scan for ALL occurrences of the query across the
+    // accumulated buffer, then map each occurrence back to the historyIndex of
+    // the delta that contains its starting offset. This catches multiple
+    // matches within a single turn and also matches that straddle delta
+    // boundaries.
+    var turnBuffer = "";
+    var turnSegments = []; // [{ start, end, historyIndex, ts }]
+
+    function pushScalarHits(text, historyIndex, role, ts) {
+      if (!text) return;
+      var lower = text.toLowerCase();
+      var from = 0;
+      while (true) {
+        var idx = lower.indexOf(q, from);
+        if (idx === -1) break;
+        var s = Math.max(0, idx - 15);
+        var e = Math.min(text.length, idx + qLen + 15);
+        var snippet = (s > 0 ? "\u2026" : "") + text.substring(s, e) + (e < text.length ? "\u2026" : "");
+        hits.push({ historyIndex: historyIndex, snippet: snippet, role: role, ts: ts });
+        from = idx + qLen;
+      }
+    }
+
+    function flushTurn() {
+      if (!turnBuffer || turnSegments.length === 0) {
+        turnBuffer = "";
+        turnSegments = [];
+        return;
+      }
+      var lowerBuf = turnBuffer.toLowerCase();
+      var from = 0;
+      var segCursor = 0;
+      while (true) {
+        var idx = lowerBuf.indexOf(q, from);
+        if (idx === -1) break;
+        // Advance segCursor to the segment containing idx.
+        while (segCursor < turnSegments.length - 1 && turnSegments[segCursor].end <= idx) {
+          segCursor++;
+        }
+        var seg = turnSegments[segCursor];
+        var s = Math.max(0, idx - 15);
+        var e = Math.min(turnBuffer.length, idx + qLen + 15);
+        var snippet = (s > 0 ? "\u2026" : "") + turnBuffer.substring(s, e) + (e < turnBuffer.length ? "\u2026" : "");
+        hits.push({ historyIndex: seg.historyIndex, snippet: snippet, role: "assistant", ts: seg.ts });
+        from = idx + qLen;
+      }
+      turnBuffer = "";
+      turnSegments = [];
+    }
+
     for (var i = 0; i < history.length; i++) {
       var entry = history[i];
-      if (entry.type === "user_message" || entry.type === "mention_user") {
-        currentTurnStart = i;
-        lastAssistantHitTurn = -1;
-      }
-      if ((entry.type === "delta" || entry.type === "user_message" || entry.type === "mention_user" || entry.type === "mention_response" || entry.type === "debate_turn_done" || entry.type === "debate_comment_injected") && entry.text) {
-        // Skip duplicate delta hits within the same assistant turn
-        if (entry.type === "delta" && currentTurnStart === lastAssistantHitTurn) continue;
-        var text = entry.text;
-        var lowerText = text.toLowerCase();
-        var idx = lowerText.indexOf(q);
-        if (idx === -1) continue;
-        var start = Math.max(0, idx - 15);
-        var end = Math.min(text.length, idx + query.length + 15);
-        var snippet = (start > 0 ? "\u2026" : "") + text.substring(start, end) + (end < text.length ? "\u2026" : "");
-        if (entry.type === "delta") lastAssistantHitTurn = currentTurnStart;
-        hits.push({
+      var t = entry.type;
+      if (t === "user_message" || t === "mention_user") {
+        flushTurn();
+        pushScalarHits(entry.text, i, t === "user_message" ? "user" : "assistant", entry._ts || null);
+      } else if (t === "delta" && entry.text) {
+        turnSegments.push({
+          start: turnBuffer.length,
+          end: turnBuffer.length + entry.text.length,
           historyIndex: i,
-          snippet: snippet,
-          role: entry.type === "user_message" ? "user" : "assistant",
           ts: entry._ts || null,
         });
+        turnBuffer += entry.text;
+      } else if ((t === "mention_response" || t === "debate_turn_done" || t === "debate_comment_injected") && entry.text) {
+        flushTurn();
+        pushScalarHits(entry.text, i, "assistant", entry._ts || null);
       }
     }
+    flushTurn();
     return { hits: hits, total: history.length };
   }
 
@@ -796,6 +881,7 @@ function createSessionManager(opts) {
     switchSession: switchSession,
     deleteSession: deleteSession,
     deleteSessionQuiet: deleteSessionQuiet,
+    deleteSessionsBulk: deleteSessionsBulk,
     resumeSession: resumeSession,
     broadcastSessionList: broadcastSessionList,
     getTotalUnread: function (ws) {
@@ -829,10 +915,61 @@ function createSessionManager(opts) {
       var session = sessions.get(localId);
       if (!session) return { error: "Session not found" };
       session.bookmarked = !!bookmarked;
+      if (session.bookmarked) {
+        var maxOrder = -1;
+        sessions.forEach(function (s) {
+          if (s.bookmarked && typeof s.favoriteOrder === "number" && s.favoriteOrder > maxOrder) {
+            maxOrder = s.favoriteOrder;
+          }
+        });
+        session.favoriteOrder = maxOrder + 1;
+      } else {
+        session.favoriteOrder = null;
+      }
       saveSessionFile(session);
       broadcastSessionList();
       return { ok: true };
     },
+    reorderBookmarkedSessions: function (sourceId, targetId, insertBefore) {
+      var source = sessions.get(sourceId);
+      var target = sessions.get(targetId);
+      if (!source || !target) return { error: "Session not found" };
+      if (!source.bookmarked || !target.bookmarked) return { error: "Only favorites can be reordered" };
+
+      var favorites = [];
+      sessions.forEach(function (s) {
+        if (s.bookmarked) favorites.push(s);
+      });
+      favorites.sort(function (a, b) {
+        var ao = typeof a.favoriteOrder === "number" ? a.favoriteOrder : Number.MAX_SAFE_INTEGER;
+        var bo = typeof b.favoriteOrder === "number" ? b.favoriteOrder : Number.MAX_SAFE_INTEGER;
+        if (ao !== bo) return ao - bo;
+        return (b.lastActivity || 0) - (a.lastActivity || 0);
+      });
+
+      var reordered = [];
+      for (var i = 0; i < favorites.length; i++) {
+        if (favorites[i].localId !== sourceId) reordered.push(favorites[i]);
+      }
+
+      var targetIdx = -1;
+      for (var j = 0; j < reordered.length; j++) {
+        if (reordered[j].localId === targetId) {
+          targetIdx = j;
+          break;
+        }
+      }
+      if (targetIdx === -1) return { error: "Target favorite not found" };
+      if (!insertBefore) targetIdx++;
+      reordered.splice(targetIdx, 0, source);
+
+      for (var k = 0; k < reordered.length; k++) {
+        reordered[k].favoriteOrder = k;
+        saveSessionFile(reordered[k]);
+      }
+      broadcastSessionList();
+      return { ok: true };
+    },
     setSessionOwner: function (localId, ownerId) {
       var session = sessions.get(localId);
       if (!session) return { error: "Session not found" };

package/lib/ws-schema.js

@@ -21,6 +21,8 @@ var schema = {
   "delete_session":           { direction: "c2s", handler: "lib/project-sessions.js", description: "Delete a session by ID" },
   "rename_session":           { direction: "c2s", handler: "lib/project-sessions.js", description: "Rename a session" },
   "set_session_bookmark":     { direction: "c2s", handler: "lib/project-sessions.js", description: "Bookmark or unbookmark a session in the sidebar" },
+  "reorder_session_bookmarks": { direction: "c2s", handler: "lib/project-sessions.js", description: "Reorder favorited sessions within the favorites area" },
+  "bulk_delete_sessions":    { direction: "c2s", handler: "lib/project-sessions.js", description: "Delete a group of sessions at once" },
   "resume_session":           { direction: "c2s", handler: "lib/project-sessions.js", description: "Resume a CLI session by its CLI session ID" },
   "set_session_visibility":   { direction: "c2s", handler: "lib/project-sessions.js", description: "Show or hide a session in the sidebar" },
   "search_sessions":          { direction: "c2s", handler: "lib/project-sessions.js", description: "Search session titles" },

package/lib/yoke/adapters/claude-worker.js

@@ -16,6 +16,7 @@ try { require("fs").writeSync(2, "[sdk-worker] BOOT pid=" + process.pid + " uid=
 var net = require("net");
 var crypto = require("crypto");
 var path = require("path");
+var fs = require("fs");
 
 var socketPath = process.argv[2];
 if (!socketPath) {
@@ -31,6 +32,7 @@ var abortController = null;
 var pendingPermissions = {};  // requestId -> resolve
 var pendingAskUser = {};      // toolUseId -> resolve
 var pendingElicitations = {}; // requestId -> resolve
+var pendingMcpToolCalls = {}; // requestId -> { resolve, reject }
 var conn = null;
 var buffer = "";
 
@@ -81,6 +83,90 @@ function getSDK() {
   return sdkModule;
 }
 
+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 key = keys[i];
+    var prop = props[key];
+    var field;
+
+    if (prop.type === "number" || prop.type === "integer") {
+      field = z.number();
+    } else if (prop.type === "boolean") {
+      field = z.boolean();
+    } else if (prop.type === "array") {
+      field = z.array(z.any());
+    } else if (prop.type === "object") {
+      field = z.record(z.any());
+    } else if (prop.enum) {
+      field = z.enum(prop.enum);
+    } else {
+      field = z.string();
+    }
+
+    if (prop.description) field = field.describe(prop.description);
+    if (required.indexOf(key) === -1) field = field.optional();
+    shape[key] = field;
+  }
+
+  return shape;
+}
+
+function createWorkerMcpToolHandler(serverName, toolName) {
+  return function(args) {
+    var requestId = crypto.randomUUID();
+    sendToDaemon({
+      type: "mcp_tool_call",
+      requestId: requestId,
+      serverName: serverName,
+      toolName: toolName,
+      args: args || {},
+    });
+    return new Promise(function(resolve, reject) {
+      pendingMcpToolCalls[requestId] = { resolve: resolve, reject: reject };
+    });
+  };
+}
+
+function buildMcpServersFromDescriptors(descriptors, sdk) {
+  if (!descriptors || !descriptors.length) return null;
+  var z;
+  try { z = require("zod").z; } catch (e) {
+    try { z = require("zod"); } catch (e2) { return null; }
+  }
+
+  var servers = {};
+  for (var i = 0; i < descriptors.length; i++) {
+    var descriptor = descriptors[i];
+    if (!descriptor || !descriptor.serverName || !descriptor.tools || !descriptor.tools.length) continue;
+    var tools = [];
+    for (var j = 0; j < descriptor.tools.length; j++) {
+      var toolDescriptor = descriptor.tools[j];
+      if (!toolDescriptor || !toolDescriptor.name) continue;
+      tools.push(sdk.tool(
+        toolDescriptor.name,
+        toolDescriptor.description || toolDescriptor.name,
+        buildZodShape(z, toolDescriptor.inputSchema),
+        createWorkerMcpToolHandler(descriptor.serverName, toolDescriptor.name)
+      ));
+    }
+    if (tools.length > 0) {
+      servers[descriptor.serverName] = sdk.createSdkMcpServer({
+        name: descriptor.serverName,
+        version: "1.0.0",
+        tools: tools,
+      });
+    }
+  }
+
+  return Object.keys(servers).length > 0 ? servers : null;
+}
+
 // --- IPC helpers ---
 function sendToDaemon(msg) {
   if (!conn || conn.destroyed) return;
@@ -127,6 +213,9 @@ function handleMessage(msg) {
     case "elicitation_response":
       handleElicitationResponse(msg);
       break;
+    case "mcp_tool_result":
+      handleMcpToolResult(msg);
+      break;
     case "warmup":
       handleWarmup(msg);
       break;
@@ -208,6 +297,17 @@ function handleElicitationResponse(msg) {
   }
 }
 
+function handleMcpToolResult(msg) {
+  var pending = pendingMcpToolCalls[msg.requestId];
+  if (!pending) return;
+  delete pendingMcpToolCalls[msg.requestId];
+  if (msg.error) {
+    pending.reject(new Error(msg.error));
+    return;
+  }
+  pending.resolve(msg.result);
+}
+
 // --- Query handling ---
 async function handleQueryStart(msg) {
   var t0 = msg._perfT0 || Date.now();
@@ -238,6 +338,15 @@ async function handleQueryStart(msg) {
   options.abortController = abortController;
   options.debug = true;
   options.debugFile = "/tmp/clay-cli-debug-" + process.pid + ".log";
+  if (options.mcpServerDescriptors && options.mcpServerDescriptors.length) {
+    try {
+      var mcpServers = buildMcpServersFromDescriptors(options.mcpServerDescriptors, sdk);
+      if (mcpServers) options.mcpServers = mcpServers;
+    } catch (e) {
+      console.error("[sdk-worker] Failed to build MCP servers:", e.message || e);
+    }
+    delete options.mcpServerDescriptors;
+  }
   // Override CLI subprocess spawn to inject NODE_OPTIONS for IPv4-first DNS.
   // The SDK constructs its own env for the CLI process, so worker env vars
   // like NODE_OPTIONS are not inherited. We intercept the spawn to fix this.
@@ -247,8 +356,11 @@ async function handleQueryStart(msg) {
     // This is needed because the CLI's Axios-based HTTP client ignores
     // NODE_OPTIONS dns flags and still attempts IPv6 connections via its
     // custom TLS agent, causing 5-10s timeouts on IPv6-less servers.
-    var preloadScript = require("path").join(__dirname, "ipv4-only.js");
-    var extraOpts = " --require " + JSON.stringify(preloadScript);
+    var preloadScript = path.join(__dirname, "..", "..", "ipv4-only.js");
+    var extraOpts = "";
+    if (fs.existsSync(preloadScript)) {
+      extraOpts += " --require " + JSON.stringify(preloadScript);
+    }
     extraOpts += " --dns-result-order=ipv4first --no-network-family-autoselection";
     spawnOpts.env.NODE_OPTIONS = (spawnOpts.env.NODE_OPTIONS || "") + extraOpts;
     console.log("[sdk-worker] spawnClaudeCodeProcess called, command=" + spawnOpts.command);

package/lib/yoke/adapters/claude.js

@@ -600,7 +600,7 @@ function spawnWorker(linuxUser, workerScriptPath, cwd) {
   worker.send = function(msg) {
     if (!worker.connection || worker.connection.destroyed) return;
     try {
-      worker.connection.write(JSON.stringify(msg) + "\n");
+      worker.connection.write(JSON.stringify(serializeWorkerValue(msg)) + "\n");
     } catch (e) {
       console.error("[yoke/claude] Failed to send to worker:", e.message);
     }
@@ -643,12 +643,45 @@ function cleanupWorker(worker) {
   worker.ready = false;
 }
 
+function serializeWorkerValue(value, seen) {
+  if (value == null) return value;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "function" || typeof value === "symbol" || typeof value === "undefined") return undefined;
+  if (value instanceof Date) return value.toISOString();
+  if (Buffer.isBuffer(value)) return value.toString("base64");
+
+  if (!seen) seen = new WeakSet();
+  if (typeof value === "object") {
+    if (seen.has(value)) return undefined;
+    seen.add(value);
+  }
+
+  if (Array.isArray(value)) {
+    var arr = [];
+    for (var i = 0; i < value.length; i++) {
+      var item = serializeWorkerValue(value[i], seen);
+      if (item !== undefined) arr.push(item);
+    }
+    return arr;
+  }
+
+  var out = {};
+  var keys = Object.keys(value);
+  for (var j = 0; j < keys.length; j++) {
+    var key = keys[j];
+    var child = serializeWorkerValue(value[key], seen);
+    if (child !== undefined) out[key] = child;
+  }
+  return out;
+}
+
 // --- Worker QueryHandle ---
 // Wraps worker IPC into the same async iterable + control interface as the
 // in-process QueryHandle. This allows processQueryStream to iterate a worker
 // query identically to an in-process query.
 
-function createWorkerQueryHandle(worker, canUseTool, onElicitation) {
+function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool) {
   // Async iterable state
   var iterQueue = [];
   var iterWaiting = null;
@@ -741,6 +774,20 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation) {
         }
         break;
 
+      case "mcp_tool_call":
+        if (callMcpTool) {
+          callMcpTool(msg.serverName, msg.toolName, msg.args || {}).then(function(result) {
+            worker.send({ type: "mcp_tool_result", requestId: msg.requestId, result: result });
+          }).catch(function(e) {
+            worker.send({
+              type: "mcp_tool_result",
+              requestId: msg.requestId,
+              error: (e && e.message) ? e.message : String(e),
+            });
+          });
+        }
+        break;
+
       case "context_usage":
       case "model_changed":
       case "effort_changed":
@@ -943,6 +990,7 @@ function createClaudeAdapter(opts) {
         cwd: (initOpts && initOpts.cwd) || _cwd,
         settingSources: ["user", "project", "local"],
         abortController: ac,
+        settings: { disableAllHooks: true },
       };
       if (_claudeBinaryPath) warmupOptions.pathToClaudeCodeExecutable = _claudeBinaryPath;
 
@@ -1102,6 +1150,7 @@ function createClaudeAdapter(opts) {
       if (co.permissionMode) sdkOptions.permissionMode = co.permissionMode;
       if (co.allowDangerouslySkipPermissions) sdkOptions.allowDangerouslySkipPermissions = true;
       if (co.resumeSessionAt) sdkOptions.resumeSessionAt = co.resumeSessionAt;
+      if (co.settings) sdkOptions.settings = co.settings;
 
       var rawQuery = sdk.query({ prompt: mq, options: sdkOptions });
       return createQueryHandle(rawQuery, mq, ac);
@@ -1229,7 +1278,7 @@ function createClaudeAdapter(opts) {
     }
 
     // Create the worker query handle (sets up message handler on worker)
-    var handle = createWorkerQueryHandle(worker, queryOpts.canUseTool, queryOpts.onElicitation);
+    var handle = createWorkerQueryHandle(worker, queryOpts.canUseTool, queryOpts.onElicitation, queryOpts.callMcpTool);
 
     // Wait for worker to be ready before sending query_start
     if (!reusingWorker) {
@@ -1250,8 +1299,9 @@ function createClaudeAdapter(opts) {
     if (claudeOpts.betas && claudeOpts.betas.length > 0) queryOptions.betas = claudeOpts.betas;
     if (claudeOpts.permissionMode) queryOptions.permissionMode = claudeOpts.permissionMode;
     if (claudeOpts.allowDangerouslySkipPermissions) queryOptions.allowDangerouslySkipPermissions = true;
+    if (claudeOpts.settings) queryOptions.settings = claudeOpts.settings;
 
-    if (queryOpts.toolServers) queryOptions.mcpServers = queryOpts.toolServers;
+    if (queryOpts.toolServerDescriptors) queryOptions.mcpServerDescriptors = queryOpts.toolServerDescriptors;
     if (queryOpts.model) queryOptions.model = queryOpts.model;
     if (queryOpts.effort) queryOptions.effort = queryOpts.effort;
     if (queryOpts.resumeSessionId) queryOptions.resume = queryOpts.resumeSessionId;
@@ -1356,6 +1406,7 @@ function createClaudeAdapter(opts) {
         cwd: (initOpts && initOpts.cwd) || _cwd,
         settingSources: ["user", "project", "local"],
         abortController: ac,
+        settings: { disableAllHooks: true },
       };
       if (_claudeBinaryPath) warmupOptions.pathToClaudeCodeExecutable = _claudeBinaryPath;
 
@@ -1430,7 +1481,7 @@ function createClaudeAdapter(opts) {
       throw new Error("Warmup worker failed to connect: " + (e.message || e));
     }
 
-    var warmupOptions = { cwd: workerCwd, settingSources: ["user", "project", "local"] };
+    var warmupOptions = { cwd: workerCwd, settingSources: ["user", "project", "local"], settings: { disableAllHooks: true } };
     if (_claudeBinaryPath) warmupOptions.pathToClaudeCodeExecutable = _claudeBinaryPath;
     if (initOpts && initOpts.dangerouslySkipPermissions) {
       warmupOptions.permissionMode = "bypassPermissions";