clay-server 2.47.0-beta.2 → 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/codex-defaults.js

@@ -1,12 +1,20 @@
 var CODEX_DEFAULTS = {
-  approval: "on-failure",
+  approval: "on-request",
   sandbox: "danger-full-access",
   webSearch: "live",
 };
 
+var CODEX_APPROVAL_POLICIES = ["untrusted", "on-request", "granular", "never"];
+
+function normalizeCodexApproval(value) {
+  if (value === "on-failure") return CODEX_DEFAULTS.approval;
+  if (CODEX_APPROVAL_POLICIES.indexOf(value) === -1) return CODEX_DEFAULTS.approval;
+  return value;
+}
+
 function getCodexConfig(sm) {
   return {
-    approval: (sm && sm.codexApproval) || CODEX_DEFAULTS.approval,
+    approval: normalizeCodexApproval(sm && sm.codexApproval),
     sandbox: (sm && sm.codexSandbox) || CODEX_DEFAULTS.sandbox,
     webSearch: (sm && sm.codexWebSearch) || CODEX_DEFAULTS.webSearch,
   };
@@ -14,5 +22,7 @@ function getCodexConfig(sm) {
 
 module.exports = {
   CODEX_DEFAULTS: CODEX_DEFAULTS,
+  CODEX_APPROVAL_POLICIES: CODEX_APPROVAL_POLICIES,
+  normalizeCodexApproval: normalizeCodexApproval,
   getCodexConfig: getCodexConfig,
 };

package/lib/project-connection.js

@@ -4,6 +4,7 @@ var usersModule = require("./users");
 var userPresence = require("./user-presence");
 var emailAccounts = require("./email-accounts");
 var { getCodexConfig } = require("./codex-defaults");
+var yoke = require("./yoke");
 
 /**
  * Attach connection/disconnection handlers to a project context.
@@ -132,7 +133,7 @@ function attachConnection(ctx) {
     var restoredActive = restoredState.active;
     var initialVendor = (restoredActive && restoredActive.vendor) || sm.defaultVendor || "claude";
     var initialModels = (sm.modelsByVendor && sm.modelsByVendor[initialVendor]) || sm.availableModels || [];
-    sendTo(ws, { type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, dangerouslySkipPermissions: dangerouslySkipPermissions, osUsers: osUsers, lanHost: lanHost, projectCount: _filteredProjects.length, projects: _filteredProjects, projectOwnerId: projectOwnerId, ownerLocked: ownerLocked });
+    sendTo(ws, { type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, dangerouslySkipPermissions: dangerouslySkipPermissions, osUsers: osUsers, lanHost: lanHost, projectCount: _filteredProjects.length, projects: _filteredProjects, projectOwnerId: projectOwnerId, ownerLocked: ownerLocked, vendors: yoke.VENDOR_REGISTRY });
     // Update notifications are pushed on a scheduled interval (see
     // scheduleUpdateBroadcast). We no longer push on connect to avoid
     // re-triggering the banner on every page refresh.

package/lib/project-notifications.js

@@ -5,6 +5,7 @@
 var fs = require("fs");
 var path = require("path");
 var config = require("./config");
+var yoke = require("./yoke");
 
 var NOTIF_FILE = path.join(config.CONFIG_DIR, "notifications.json");
 var REMINDER_INTERVAL = 60 * 60 * 1000; // 1 hour
@@ -21,7 +22,8 @@ function generateId() {
 var formatters = {
   auth_required: function (data) {
     var vendor = data.vendor || "claude";
-    var title = data.title || ((vendor === "codex" ? "Codex" : (vendor === "kiro" ? "Kiro CLI" : "Claude Code")) + " is not logged in");
+    var vendorInfo = yoke.getVendorInfo(vendor);
+    var title = data.title || (((vendorInfo && vendorInfo.displayName) || "Claude Code") + " is not logged in");
     return {
       type: "auth_required",
       title: title,

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-sessions.js

@@ -3,6 +3,12 @@ var path = require("path");
 var crypto = require("crypto");
 var { execFileSync } = require("child_process");
 var { CODEX_DEFAULTS, getCodexConfig } = require("./codex-defaults");
+var yoke = require("./yoke");
+
+function vendorSupportsTui(vendor) {
+  var info = yoke.getVendorInfo(vendor);
+  return !!(info && info.sessionModes.indexOf("tui") !== -1);
+}
 
 // Format a user's answer to an ask_user_questions card as a plain user
 // message so the MCP path can feed it back to the agent on the next turn.
@@ -274,6 +280,8 @@ function attachSessions(ctx) {
     var sid = session.cliSessionId;
     var localId = session.localId;
     var resumeSkip = session.dangerouslySkipPermissions ? " --dangerously-skip-permissions" : "";
+    // Command construction is Claude-specific. Generalize this before any
+    // other vendor declares "tui" in the YOKE registry.
     var cmd = "claude --resume " + sid + resumeSkip + "; exit\n";
     var term = tm.create(80, 24, getOsUserInfoForWs(ws), ws, {
       initialInput: cmd,
@@ -346,7 +354,7 @@ function attachSessions(ctx) {
   // born-TUI session shows the same read-only + Resume view as a fresh click.
   function resolveSessionForView(session, ws) {
     if (!session) return;
-    if (session.vendor && session.vendor !== "claude") { session.tuiSuspended = false; return; }
+    if (session.vendor && !vendorSupportsTui(session.vendor)) { session.tuiSuspended = false; return; }
     var pref = getClaudeOpenModeForWs(ws);
     // A LIVE runtime always wins over the viewer's claudeOpenMode pref:
     // another user (or this user in another tab) may be in the session right
@@ -424,13 +432,13 @@ function attachSessions(ctx) {
       if (ws._clayUser && usersModule.isMultiUser()) sessionOpts.ownerId = ws._clayUser.id;
       if (msg.sessionVisibility) sessionOpts.sessionVisibility = msg.sessionVisibility;
       if (msg.vendor) sessionOpts.vendor = msg.vendor;
-      // Mode resolution: codex and kiro sessions are always GUI (no TUI adapter).
-      // Claude sessions honor the explicit msg.mode if provided, otherwise
+      // Mode resolution: vendors without a TUI session mode are always GUI.
+      // TUI-capable sessions honor the explicit msg.mode if provided, otherwise
       // fall back to the user's claudeOpenMode preference. This is what
       // makes the sidebar's "Claude" icon button create the right kind of
       // session without the client needing to know the preference.
       var requestedMode;
-      if (msg.vendor === "codex" || msg.vendor === "kiro") {
+      if (msg.vendor && !vendorSupportsTui(msg.vendor)) {
         requestedMode = "gui";
       } else if (msg.mode === "tui" || msg.mode === "gui") {
         requestedMode = msg.mode;
@@ -625,7 +633,7 @@ function attachSessions(ctx) {
         // for every viewer; only cold sessions follow the clicker's
         // claudeOpenMode pref. Nothing is spawned here.
         var xmTarget = sm.sessions.get(msg.id);
-        if (xmTarget && (xmTarget.vendor === "claude" || !xmTarget.vendor)) {
+        if (xmTarget && (!xmTarget.vendor || vendorSupportsTui(xmTarget.vendor))) {
           // Single source of truth: live runtime wins (tui stays tui, gui stays
           // gui); only cold sessions follow the viewer's pref. No PTY is spawned
           // on switch - born-TUI resumes lazily via the Resume bar
@@ -678,7 +686,7 @@ function attachSessions(ctx) {
     if (msg.type === "resume_tui_session") {
       if (msg.id && sm.sessions.has(msg.id)) {
         var rtTarget = sm.sessions.get(msg.id);
-        var rtOk = rtTarget && (rtTarget.vendor === "claude" || !rtTarget.vendor) &&
+        var rtOk = rtTarget && (!rtTarget.vendor || vendorSupportsTui(rtTarget.vendor)) &&
                    rtTarget.cliSessionId && tm;
         if (rtOk) {
           if (usersModule.isMultiUser() && ws._clayUser &&
@@ -706,7 +714,7 @@ function attachSessions(ctx) {
     if (msg.type === "suspend_tui_session") {
       if (msg.id && sm.sessions.has(msg.id)) {
         var stTarget = sm.sessions.get(msg.id);
-        var stOk = stTarget && (stTarget.vendor === "claude" || !stTarget.vendor);
+        var stOk = stTarget && (!stTarget.vendor || vendorSupportsTui(stTarget.vendor));
         if (stOk && (!usersModule.isMultiUser() || !ws._clayUser ||
             usersModule.canAccessSession(ws._clayUser.id, stTarget, { visibility: "public" }))) {
           if (tm) {
@@ -737,7 +745,7 @@ function attachSessions(ctx) {
       var tprId = msg.id;
       var tprSess = (tprId && sm.sessions.has(tprId)) ? sm.sessions.get(tprId) : null;
       if (!tprSess || !tprSess.cliSessionId || tprSess.mode !== "tui") return true;
-      if (tprSess.vendor && tprSess.vendor !== "claude") return true;
+      if (tprSess.vendor && !vendorSupportsTui(tprSess.vendor)) return true;
       if (usersModule.isMultiUser() && ws._clayUser
           && !usersModule.canAccessSession(ws._clayUser.id, tprSess, { visibility: "public" })) {
         return true;
@@ -1084,7 +1092,7 @@ function attachSessions(ctx) {
 
     // Codex-specific settings (stored on sessionManager, passed to adapter via adapterOptions)
     if (msg.type === "set_codex_approval") {
-      sm.codexApproval = msg.approval || CODEX_DEFAULTS.approval;
+      sm.codexApproval = getCodexConfig({ codexApproval: msg.approval }).approval;
       send(Object.assign({ type: "codex_config" }, getCodexConfig(sm)));
       return true;
     }