clay-server 2.47.0-beta.3 → 2.47.0-beta.4

package/lib/claude-hook-installer.js

@@ -43,7 +43,6 @@ var CLAY_MANAGED_ALLOW = [
   "mcp__clay-browser__browser_watch_tab",
   "mcp__clay-browser__browser_unwatch_tab",
   "mcp__clay-debate__propose_debate",
-  "mcp__clay-datastore__*",
   "mcp__clay-history__*",
   // Email: read-side only. Send / reply / mark_read still prompt.
   "mcp__clay-email__clay_read_email",

package/lib/project-session-spawn.js

@@ -0,0 +1,366 @@
+var yoke = require("./yoke");
+var sessionSpawnMcp = require("./session-spawn-mcp-server");
+var cliSessions = require("./cli-sessions");
+var os = require("os");
+var osUsers = require("./os-users");
+
+var MAX_SESSIONS_PER_CALL = 10;
+var MAX_CHILDREN_PER_PARENT = 20;
+var SPAWN_CONCURRENCY = 3;
+
+function parseBatch(raw) {
+  var parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error("sessions must be a valid JSON array");
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("sessions must be a valid JSON array");
+  }
+  if (parsed.length < 1 || parsed.length > MAX_SESSIONS_PER_CALL) {
+    throw new Error("sessions must contain between 1 and 10 entries");
+  }
+  var result = [];
+  for (var i = 0; i < parsed.length; i++) {
+    var entry = parsed[i];
+    if (!entry || typeof entry.prompt !== "string" || !entry.prompt.trim()) {
+      throw new Error("session " + (i + 1) + " must include a non-empty prompt");
+    }
+    var title = typeof entry.title === "string" ? entry.title.trim() : "";
+    result.push({
+      title: title || "Spawned task " + (i + 1),
+      prompt: entry.prompt.trim(),
+    });
+  }
+  return result;
+}
+
+function getSessionsArray(sessions) {
+  if (!sessions) return [];
+  if (typeof sessions.values === "function") return Array.from(sessions.values());
+  return sessions;
+}
+
+function assertSpawnAllowed(parent, sessions, requestedCount) {
+  if (!parent) throw new Error("no active parent session");
+  if (parent.spawn) throw new Error("spawned sessions cannot spawn further sessions");
+  var all = getSessionsArray(sessions);
+  var childCount = 0;
+  for (var i = 0; i < all.length; i++) {
+    if (all[i].spawn && all[i].spawn.parentId === parent.localId) childCount++;
+  }
+  if (childCount + requestedCount > MAX_CHILDREN_PER_PARENT) {
+    throw new Error("a parent session cannot have more than 20 children");
+  }
+  return childCount;
+}
+
+function validateVendor(vendor, adapters, linuxUser, getVendorInfo) {
+  if (!vendor || !adapters || !adapters[vendor]) {
+    throw new Error("vendor is not available: " + (vendor || "unknown"));
+  }
+  var lookup = getVendorInfo || yoke.getVendorInfo;
+  var info = lookup(vendor);
+  if (linuxUser && info && info.osUserIsolation === false) {
+    throw new Error((info.displayName || vendor) + " is not available for OS-isolated users");
+  }
+  return vendor;
+}
+
+function createSpawnQueue(concurrency) {
+  var limit = concurrency || SPAWN_CONCURRENCY;
+  var pending = [];
+  var running = [];
+
+  function startTask(task) {
+    task.state = "running";
+    running.push(task);
+    var finished = false;
+    function complete(err) {
+      if (finished) return;
+      finished = true;
+      var index = running.indexOf(task);
+      if (index !== -1) running.splice(index, 1);
+      task.state = err ? "error" : "done";
+      task.error = err || null;
+      pump();
+    }
+    try {
+      task.start(complete);
+    } catch (e) {
+      complete(e);
+    }
+  }
+
+  function pump() {
+    while (running.length < limit && pending.length > 0) {
+      var task = pending.shift();
+      startTask(task);
+    }
+  }
+
+  function add(tasks) {
+    for (var i = 0; i < tasks.length; i++) {
+      tasks[i].state = "queued";
+      pending.push(tasks[i]);
+    }
+    pump();
+    var queued = 0;
+    var active = 0;
+    for (var j = 0; j < tasks.length; j++) {
+      if (tasks[j].state === "queued") queued++;
+      if (tasks[j].state === "running") active++;
+    }
+    return { queued: queued, running: active };
+  }
+
+  return {
+    add: add,
+    get pendingCount() { return pending.length; },
+    get runningCount() { return running.length; },
+  };
+}
+
+function hasSessionError(session) {
+  var history = session.history || [];
+  var recent = history.slice(-3);
+  for (var i = 0; i < recent.length; i++) {
+    if (recent[i].type === "error" || (recent[i].type === "done" && recent[i].code === 1)) return true;
+  }
+  return false;
+}
+
+function toolResult(value) {
+  return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] });
+}
+
+function toolError(err) {
+  return Promise.resolve({
+    content: [{ type: "text", text: "Error: " + (err.message || err) }],
+    isError: true,
+  });
+}
+
+function rebuildMessageUUIDs(history) {
+  var messageUUIDs = [];
+  for (var i = 0; i < history.length; i++) {
+    if (history[i].type === "message_uuid") {
+      messageUUIDs.push({
+        uuid: history[i].uuid,
+        type: history[i].messageType,
+        historyIndex: i,
+      });
+    }
+  }
+  return messageUUIDs;
+}
+
+function attachSessionSpawn(ctx) {
+  var sm = ctx.sm;
+  var queue = createSpawnQueue(SPAWN_CONCURRENCY);
+  var adapters = ctx.adapters || {};
+  var readCliSessionHistory = ctx.readCliSessionHistory || cliSessions.readCliSessionHistory;
+
+  function resolveSessionHome(session) {
+    var linuxUser = ctx.getLinuxUserForSession(session);
+    if (linuxUser) {
+      try {
+        var info = osUsers.resolveOsUserInfo(linuxUser);
+        if (info && info.home) return info.home;
+      } catch (e) {}
+    }
+    return os.homedir();
+  }
+
+  function validateFork(parent, vendor, explicitVendor) {
+    if (!parent.cliSessionId) {
+      throw new Error("forkFromCurrent requires the calling session to have at least one completed turn");
+    }
+    var capabilities = sm.capabilitiesByVendor && sm.capabilitiesByVendor[vendor];
+    if (!capabilities || capabilities.fork !== true) {
+      throw new Error("forkFromCurrent is not supported by vendor: " + vendor);
+    }
+    var parentVendor = parent.vendor || sm.defaultVendor;
+    if (explicitVendor && explicitVendor !== parentVendor) {
+      throw new Error("forkFromCurrent children must use the parent's vendor");
+    }
+  }
+
+  function applyForkToTask(task, forkResult, history) {
+    task.session.cliSessionId = forkResult.sessionId;
+    task.session.history = history.slice();
+    task.session.messageUUIDs = rebuildMessageUUIDs(task.session.history);
+    sm.saveSessionFile(task.session);
+  }
+
+  function spawnOne(parent, spec, index, batchId, vendor, linuxUser) {
+    var create = typeof sm.createSessionRaw === "function" ? sm.createSessionRaw : sm.createSession;
+    var session = create.call(sm, {
+      ownerId: parent.ownerId || null,
+      sessionVisibility: parent.sessionVisibility || "shared",
+      vendor: vendor,
+    });
+    session.spawn = { parentId: parent.localId, index: index, batchId: batchId };
+    session.title = spec.title;
+    sm.saveSessionFile(session);
+
+    return {
+      session: session,
+      state: "created",
+      start: function (done) {
+        function finish(err) {
+          delete session.onQueryComplete;
+          delete session.singleTurn;
+          done(err);
+        }
+        var userMessage = { type: "user_message", text: spec.prompt };
+        session.history.push(userMessage);
+        sm.appendToSessionFile(session, userMessage);
+        session.isProcessing = true;
+        session.lastActivity = Date.now();
+        session.sentToolResults = {};
+        session.singleTurn = true;
+        session.onQueryComplete = function () {
+          finish(hasSessionError(session) ? new Error("child session failed") : null);
+        };
+        var sdk = ctx.getSdk();
+        if (!sdk || typeof sdk.startQuery !== "function") {
+          session.isProcessing = false;
+          finish(new Error("SDK bridge is not ready"));
+          return;
+        }
+        Promise.resolve(sdk.startQuery(session, spec.prompt, undefined, linuxUser)).then(function () {
+          if (!session.isProcessing && !session.queryInstance) {
+            finish(new Error("child session failed to start"));
+          }
+        }).catch(function (err) {
+          session.isProcessing = false;
+          session.history.push({ type: "error", text: err.message || String(err) });
+          finish(err);
+        });
+      },
+    };
+  }
+
+  async function spawn(args, caller) {
+    try {
+      // The caller is bound per query in getLocalMcpServers (project.js), so
+      // a child session resolving itself here is what makes the depth guard
+      // sound. Never fall back to sm.getActiveSession(): that is the
+      // project-global "last viewed" session and can belong to someone else.
+      var parent = caller;
+      if (!parent) throw new Error("spawn_sessions requires a session-bound tool server");
+      var specs = parseBatch(args.sessions);
+      assertSpawnAllowed(parent, sm.sessions, specs.length);
+      var explicitVendor = args.vendor && args.vendor.trim();
+      var vendor = explicitVendor || parent.vendor || sm.defaultVendor;
+      var linuxUser = ctx.getLinuxUserForSession(parent);
+      validateVendor(vendor, adapters, linuxUser);
+      var forkFromCurrent = args.forkFromCurrent === true;
+      if (forkFromCurrent) validateFork(parent, vendor, explicitVendor);
+      var batchId = "sp_" + Date.now().toString(36);
+      var tasks = [];
+      var spawned = [];
+      var failed = null;
+      var sdk = ctx.getSdk();
+      var lastMessage = parent.messageUUIDs && parent.messageUUIDs.length > 0
+        ? parent.messageUUIDs[parent.messageUUIDs.length - 1]
+        : null;
+      // Claude treats an omitted upToMessageId as a full-session fork;
+      // Codex forks the whole thread and ignores the UUID option.
+      var lastUuid = lastMessage ? lastMessage.uuid : undefined;
+      for (var i = 0; i < specs.length; i++) {
+        var forkResult = null;
+        var forkHistory = null;
+        if (forkFromCurrent) {
+          try {
+            if (!sdk || typeof sdk.forkSession !== "function") throw new Error("SDK bridge is not ready");
+            forkResult = await sdk.forkSession(parent, lastUuid);
+            if (!forkResult || !forkResult.sessionId) throw new Error("Fork returned no session id");
+            if (forkResult.useLocalHistory) {
+              forkHistory = parent.history.slice();
+            } else {
+              forkHistory = await readCliSessionHistory(
+                resolveSessionHome(parent), ctx.cwd, forkResult.sessionId
+              );
+            }
+          } catch (e) {
+            failed = { index: i, error: e.message || String(e) };
+            break;
+          }
+        }
+        var task = spawnOne(parent, specs[i], i, batchId, vendor, linuxUser);
+        if (forkResult) applyForkToTask(task, forkResult, forkHistory || []);
+        tasks.push(task);
+        spawned.push({ localId: task.session.localId, title: task.session.title });
+      }
+      var counts = queue.add(tasks);
+      if (tasks.length > 0) sm.broadcastSessionList();
+      var result = { spawned: spawned, queued: counts.queued, running: counts.running };
+      if (failed) result.failed = failed;
+      return toolResult(result);
+    } catch (e) {
+      return toolError(e);
+    }
+  }
+
+  function check(args, caller) {
+    try {
+      var parent = caller;
+      if (!parent) throw new Error("check_spawned_sessions requires a session-bound tool server");
+      var parentOnly = args.parentOnly !== false;
+      var all = getSessionsArray(sm.sessions);
+      var statuses = [];
+      for (var i = 0; i < all.length; i++) {
+        var session = all[i];
+        if (!session.spawn) continue;
+        if (parentOnly && session.spawn.parentId !== parent.localId) continue;
+        statuses.push({
+          localId: session.localId,
+          title: session.title || "New Session",
+          status: session.isProcessing ? "running" : (hasSessionError(session) ? "error" : "done"),
+          turnCount: session.turnCount || 0,
+          lastActivity: session.lastActivity || session.createdAt || 0,
+        });
+      }
+      return toolResult(statuses);
+    } catch (e) {
+      return toolError(e);
+    }
+  }
+
+  // boundSession: the session whose query this tool server instance is
+  // mounted into. Omitted for the static instance kept in the project's
+  // mcpServers map, which exists only so tool descriptors can be listed;
+  // its handlers fail closed if anything ever routes a call to them.
+  function createMcpServer(adapter, boundSession) {
+    if (ctx.isMate || !adapter || typeof adapter.createToolServer !== "function") return null;
+    return adapter.createToolServer({
+      name: "clay-sessions",
+      version: "1.0.0",
+      tools: sessionSpawnMcp.getToolDefs({
+        spawn: function (args) { return spawn(args, boundSession || null); },
+        check: function (args) { return check(args, boundSession || null); },
+      }),
+    });
+  }
+
+  return {
+    createMcpServer: createMcpServer,
+    spawnOne: spawnOne,
+  };
+}
+
+module.exports = {
+  MAX_SESSIONS_PER_CALL: MAX_SESSIONS_PER_CALL,
+  MAX_CHILDREN_PER_PARENT: MAX_CHILDREN_PER_PARENT,
+  SPAWN_CONCURRENCY: SPAWN_CONCURRENCY,
+  parseBatch: parseBatch,
+  assertSpawnAllowed: assertSpawnAllowed,
+  validateVendor: validateVendor,
+  createSpawnQueue: createSpawnQueue,
+  hasSessionError: hasSessionError,
+  rebuildMessageUUIDs: rebuildMessageUUIDs,
+  attachSessionSpawn: attachSessionSpawn,
+};

package/lib/project.js

@@ -28,9 +28,9 @@ var { attachSessions } = require("./project-sessions");
 var { attachUserMessage } = require("./project-user-message");
 var { attachConnection } = require("./project-connection");
 var { attachMcp } = require("./project-mcp");
-var { attachMateDatastore } = require("./project-mate-datastore");
 var { createLocalMcp } = require("./mcp-local");
 var { attachEmail: attachEmailModule } = require("./project-email");
+var { attachSessionSpawn } = require("./project-session-spawn");
 // project-notifications is attached globally in server.js, passed via opts.notificationsModule
 
 // --- Context Sources persistence ---
@@ -476,23 +476,34 @@ function createProjectContext(opts) {
     },
   });
 
-  // --- Mate datastore (Mate projects only) ---
-  var _mateDatastore = attachMateDatastore({
+  // The SDK bridge is created after local MCP servers. Session spawning uses
+  // a getter so tool handlers see the initialized bridge when they run.
+  var sdk = null;
+  var _sessionSpawn = attachSessionSpawn({
     cwd: cwd,
-    slug: slug,
-    isMate: isMate,
+    sm: sm,
+    getSdk: function () { return sdk; },
     send: send,
-    sendTo: sendTo,
-    clients: clients,
-    getSessionForWs: getSessionForWs,
+    isMate: isMate,
     usersModule: usersModule,
-    getProjectOwnerId: function () { return projectOwnerId; },
+    adapters: adapters,
+    getLinuxUserForSession: getLinuxUserForSession,
   });
 
   // --- MCP tool servers (created via YOKE adapter) ---
   var mcpServers = (function () {
     var servers = {};
 
+    // Agent-driven sibling session fan-out (main projects only).
+    if (!isMate) {
+      try {
+        var sessionSpawnMcpConfig = _sessionSpawn.createMcpServer(adapter);
+        if (sessionSpawnMcpConfig) servers[sessionSpawnMcpConfig.name || "clay-sessions"] = sessionSpawnMcpConfig;
+      } catch (e) {
+        console.error("[project] Failed to create session spawn MCP server:", e.message);
+      }
+    }
+
     // Debate MCP server (available to both mates and main project)
     try {
       var debateMcp = require("./debate-mcp-server");
@@ -643,15 +654,6 @@ function createProjectContext(opts) {
       console.error("[project] Failed to create email MCP server:", e.message);
     }
 
-    if (isMate) {
-      try {
-        var datastoreMcp = _mateDatastore.createMcpServer();
-        if (datastoreMcp) servers[datastoreMcp.name || "clay-datastore"] = datastoreMcp;
-      } catch (e) {
-        console.error("[project] Failed to create datastore MCP server:", e.message);
-      }
-    }
-
     return Object.keys(servers).length > 0 ? servers : undefined;
   })();
 
@@ -663,7 +665,12 @@ function createProjectContext(opts) {
   //
   //   clay-browser -> only when the Chrome extension is connected
   //   clay-email   -> only when the user has an account or server SMTP
-  function getLocalMcpServers() {
+  //
+  // forSession (optional): the session whose query these servers are mounted
+  // into. clay-sessions must know its caller (depth guard + child ownership),
+  // so it is re-instantiated bound to that session; the static instance in
+  // mcpServers only serves descriptor listing and fails closed on calls.
+  function getLocalMcpServers(forSession) {
     if (!mcpServers) return undefined;
     var extWs = browserState._extensionWs;
     var extConnected = !!(extWs && extWs.readyState === 1);
@@ -675,6 +682,15 @@ function createProjectContext(opts) {
       var name = keys[i];
       if (name === "clay-browser" && !extConnected) continue;
       if (name === "clay-email" && !emailAvailable) continue;
+      if (name === "clay-sessions" && forSession) {
+        try {
+          var boundSpawn = _sessionSpawn.createMcpServer(adapter, forSession);
+          if (boundSpawn) { filtered[name] = boundSpawn; hasAny = true; }
+        } catch (e) {
+          console.error("[project] Failed to bind session spawn MCP server:", e.message);
+        }
+        continue;
+      }
       filtered[name] = mcpServers[name];
       hasAny = true;
     }
@@ -682,7 +698,7 @@ function createProjectContext(opts) {
   }
 
   // --- SDK bridge ---
-  var sdk = createSDKBridge({
+  sdk = createSDKBridge({
     cwd: cwd,
     slug: slug,
     sessionManager: sm,
@@ -1028,9 +1044,6 @@ function createProjectContext(opts) {
     // --- MCP bridge (remote MCP servers via extension) ---
     if (_mcp.handleMcpMessage(ws, msg)) return;
 
-    // --- Mate datastore ---
-    if (_mateDatastore.handleMateDatastoreMessage(ws, msg)) return;
-
     // --- Knowledge file management (delegated to project-knowledge.js) ---
     if (_knowledge.handleKnowledgeMessage(ws, msg)) return;
 
@@ -1491,9 +1504,6 @@ function createProjectContext(opts) {
   function destroy() {
     _loop.stopTimer();
     _email.destroy();
-    if (_mateDatastore && typeof _mateDatastore.closeAllDatastores === "function") {
-      try { _mateDatastore.closeAllDatastores(); } catch (e) {}
-    }
     stopFileWatch();
     stopAllDirWatches();
     // Abort all active sessions and clean up mention sessions

package/lib/public/app.js

@@ -18,7 +18,6 @@ import {
   openMobileSheet, setMobileSheetMateData, refreshMobileChatSheet
 } from './modules/sidebar-mobile.js';
 import { initMateSidebar, showMateSidebar, hideMateSidebar, renderMateSessionList, updateMateSidebarProfile, handleMateSearchResults } from './modules/mate-sidebar.js';
-import { initMateDatastoreUI } from './modules/mate-datastore-ui.js';
 import { initMateKnowledge, requestKnowledgeList, renderKnowledgeList, handleKnowledgeContent, hideKnowledge } from './modules/mate-knowledge.js';
 import { initMateMemory, renderMemoryList, hideMemory } from './modules/mate-memory.js';
 import { initRewind, setRewindMode, showRewindModal, clearPendingRewindUuid, addRewindButton, onRewindComplete, onRewindError } from './modules/rewind.js';
@@ -416,7 +415,6 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
   initSidebar(sidebarCtx);
   var wsGetter = function () { return _getWsRef(); };
   initMateSidebar(wsGetter);
-  initMateDatastoreUI(wsGetter);
   initMateKnowledge(wsGetter);
   initMateMemory(wsGetter, { onShow: function () { hideKnowledge(); hideNotes(); } });
   initMateWizard(