clay-server 4.1.0-beta.6 → 4.1.0-beta.7

package/lib/project-user-message.js

@@ -21,6 +21,7 @@ var fs = require("fs");
  *   sendExtensionCommandAny, requestTabContext,
  *   startFileWatch, stopFileWatch,
  *   scheduleMessage, cancelScheduledMessage,
+ *   pendingMessageQueue,
  *   loadContextSources, saveContextSources,
  *   digestDmTurn, gateMemory,
  *   adapter            - YOKE adapter instance
@@ -42,7 +43,7 @@ function attachUserMessage(ctx) {
   var sendTo = ctx.sendTo;
   var sendToSession = ctx.sendToSession;
   var sendToSessionOthers = ctx.sendToSessionOthers;
-  var messageDelivery = createProjectMessageDelivery(sendTo);
+  var messageDelivery = createProjectMessageDelivery(sendTo, slug);
 
   var clients = ctx.clients;
   var opts = ctx.opts;
@@ -71,6 +72,7 @@ function attachUserMessage(ctx) {
   var scheduleMessage = ctx.scheduleMessage;
   var cancelScheduledMessage = ctx.cancelScheduledMessage;
   var sendScheduledMessageNow = ctx.sendScheduledMessageNow;
+  var pendingMessageQueue = ctx.pendingMessageQueue;
 
   var loadContextSources = ctx.loadContextSources;
   var saveContextSources = ctx.saveContextSources;
@@ -99,7 +101,27 @@ function attachUserMessage(ctx) {
 
   // --------------- Main handler ---------------
 
-  function handleUserMessage(ws, msg) {
+  function handleUserMessage(ws, msg, forcedSession, internal) {
+    if (msg.type === "pending_message_get" || msg.type === "pending_message_edit" || msg.type === "pending_message_cancel" || msg.type === "pending_message_reorder" || msg.type === "pending_message_resume") {
+      var queueSession = forcedSession || getSessionForWs(ws);
+      if (!queueSession || !pendingMessageQueue) return true;
+      var queueActor = ws && ws._clayUser;
+      var queueResult;
+      if (msg.projectSlug !== slug) queueResult = { ok: false, error: "Project changed", sessionId: queueSession.localId, projectSlug: slug };
+      else if (msg.type === "pending_message_resume") {
+        queueResult = pendingMessageQueue.resume(queueSession, queueActor, msg.revision, msg.sessionId);
+        if (queueResult.ok && !queueResult.paused) {
+          queueSession._pendingMessageDrainPaused = false;
+          setImmediate(function () { consumePendingMessage(queueSession); });
+        }
+      }
+      else if (msg.type === "pending_message_get") queueResult = pendingMessageQueue.hydrate(queueSession, queueActor);
+      else if (msg.type === "pending_message_edit") queueResult = pendingMessageQueue.edit(queueSession, queueActor, msg.id, msg.revision, msg.sessionId, msg.message || {});
+      else if (msg.type === "pending_message_cancel") queueResult = pendingMessageQueue.cancel(queueSession, queueActor, msg.id, msg.revision, msg.sessionId);
+      else queueResult = pendingMessageQueue.reorder(queueSession, queueActor, msg.ids || [], msg.revision, msg.sessionId);
+      sendTo(ws, { type: "pending_message_result", requestId: msg.requestId || null, result: queueResult });
+      return true;
+    }
     // --- Sticky notes ---
     if (msg.type === "note_create") {
       var note = nm.create(msg);
@@ -303,17 +325,29 @@ function attachUserMessage(ctx) {
     if (msg.type !== "message") return false;
     if (!msg.text && (!msg.images || msg.images.length === 0) && (!msg.pastes || msg.pastes.length === 0)) return true;
 
-    var session = getSessionForWs(ws);
+    var session = forcedSession || getSessionForWs(ws);
     if (!session) return true;
+    var pendingInternal = internal && internal.pendingConsumed ? internal : null;
+    function finishPendingEarly(outcome, reason) {
+      if (pendingInternal && typeof pendingInternal.complete === "function") pendingInternal.complete(outcome, reason);
+    }
 
     if (session.loopInterviewHandoff && session.loopInterviewHandoff.state === "starting") {
       sendTo(ws, { type: "error", text: "Wait for the approved Loop handoff to finish." });
+      finishPendingEarly("release", "Loop handoff is still starting");
       return true;
     }
 
+    var queuedReplay = pendingMessageQueue && pendingMessageQueue.inspect(session, ws && ws._clayUser, msg.clientMessageId);
+    if (!pendingInternal && queuedReplay) {
+      messageDelivery.acknowledge(ws, { clientMessageId: queuedReplay.clientMessageId }, null, session);
+      sendTo(ws, { type: "message_queued", clientMessageId: queuedReplay.clientMessageId, sessionId: session.localId, projectSlug: slug, state: queuedReplay.state, paused: pendingMessageQueue.isPaused(session), revision: pendingMessageQueue.getRevision() });
+      return true;
+    }
     var deliveryReceipt = messageDelivery.inspect(ws, session, msg);
     if (deliveryReceipt.duplicate) {
-      messageDelivery.acknowledge(ws, deliveryReceipt, hydrateImageRefs(deliveryReceipt.recordedMessage));
+      messageDelivery.acknowledge(ws, deliveryReceipt, hydrateImageRefs(deliveryReceipt.recordedMessage), session);
+      finishPendingEarly(true);
       return true;
     }
 
@@ -330,23 +364,37 @@ function attachUserMessage(ctx) {
         type: "error",
         text: "This Split Worker is controlled by its Driver. Send the instruction to the Driver session instead.",
       });
+      finishPendingEarly(false, "Pending messages cannot be delivered to a Driver-operated Split Worker");
+      return true;
+    }
+    if (!pendingInternal && pendingMessageQueue && (pendingMessageQueue.hasActive(session) || session.isProcessing || session._queryStarting || session._awaitingTurnResult)) {
+      var queuedResult = pendingMessageQueue.admit(session, msg, ws && ws._clayUser);
+      if (queuedResult.ok) {
+        messageDelivery.acknowledge(ws, deliveryReceipt, null, session);
+        sendTo(ws, { type: "message_queued", clientMessageId: msg.clientMessageId || null, sessionId: session.localId, projectSlug: slug, state: "pending", paused: pendingMessageQueue.isPaused(session), revision: pendingMessageQueue.getRevision() });
+      } else {
+        sendTo(ws, { type: "error", text: queuedResult.error || "Unable to queue message" });
+      }
       return true;
     }
+    if (!pendingInternal) session._pendingMessageDrainPaused = false;
     if (msg.autonomousRunToken) {
       if (!ctx.autonomousRun || !ctx.autonomousRun.consume(session, msg)) {
         sendTo(ws, { type: "error", text: "This Until complete submission is stale or no longer armed." });
+        finishPendingEarly(false, "Until complete submission is stale or no longer armed");
         return true;
       }
     } else if (session.autonomousRun && session.autonomousRun.state === "armed") {
       sendTo(ws, { type: "error", text: "Until complete is still being armed. Wait for its acknowledgement before sending." });
+      finishPendingEarly("release", "Until complete is still being armed");
       return true;
     } else if (ctx.autonomousRun) {
       ctx.autonomousRun.onHumanMessage(session, msg);
     }
     var autonomousDeliveryMeta = session.autonomousRun && ["running", "reviewing", "waiting-worker", "waiting-user"].indexOf(session.autonomousRun.state) !== -1
       ? { autonomousRunId: session.autonomousRun.id } : undefined;
-    if (typeof ctx.beginHumanPairTurn === "function") ctx.beginHumanPairTurn(session);
-    if (gitAttribution) gitAttribution.beginTurn(session);
+    if (!pendingInternal && typeof ctx.beginHumanPairTurn === "function") ctx.beginHumanPairTurn(session);
+    if (!pendingInternal && gitAttribution) gitAttribution.beginTurn(session);
 
     // Bind vendor to session on first message (if not already set)
     if (!session.vendor && msg.vendor) {
@@ -363,7 +411,7 @@ function attachUserMessage(ctx) {
 
     // Keep any pending scheduled message alive when user sends a regular message
 
-    var userMsg2 = { type: "user_message", text: msg.text || "" };
+    var userMsg2 = { type: "user_message", text: msg.text || "", projectSlug: slug, sessionId: session.localId };
     // Attach sender info for multi-user attribution (backward-compatible: old clients ignore these)
     if (ws._clayUser) {
       userMsg2.from = ws._clayUser.id;
@@ -391,24 +439,51 @@ function attachUserMessage(ctx) {
     }
     if (deliveryReceipt.clientMessageId) userMsg2.clientMessageId = deliveryReceipt.clientMessageId;
     if (!userMsg2._ts) userMsg2._ts = Date.now();
-    session.history.push(userMsg2);
-    sm.appendToSessionFile(session, userMsg2);
-    messageDelivery.markRecorded(session, deliveryReceipt, userMsg2);
-    messageDelivery.acknowledge(ws, deliveryReceipt, hydrateImageRefs(userMsg2));
-    sendToSessionOthers(ws, session.localId, hydrateImageRefs(userMsg2));
-
-    if (!session.title) {
-      session.title = (msg.text || "Image").substring(0, 50);
-      sm.saveSessionFile(session);
-      sm.broadcastSessionList();
-      // Sync auto-title to SDK
-      if (session.cliSessionId) {
-        adapter.renameSession(session.cliSessionId, session.title, { dir: cwd }).catch(function(e) {
-          console.error("[project] SDK renameSession failed:", e.message);
-        });
+    var transcriptRecorded = false;
+    var pendingContextPreviews = [];
+    function recordTranscript() {
+      if (transcriptRecorded) return;
+      transcriptRecorded = true;
+      if (pendingInternal && typeof ctx.beginHumanPairTurn === "function") ctx.beginHumanPairTurn(session);
+      if (pendingInternal && gitAttribution) gitAttribution.beginTurn(session);
+      session.history.push(userMsg2);
+      sm.appendToSessionFile(session, userMsg2);
+      messageDelivery.markRecorded(session, deliveryReceipt, userMsg2);
+      if (!pendingInternal) messageDelivery.acknowledge(ws, deliveryReceipt, hydrateImageRefs(userMsg2), session);
+      sendToSessionOthers(pendingInternal ? null : ws, session.localId, hydrateImageRefs(userMsg2));
+      for (var previewIndex = 0; previewIndex < pendingContextPreviews.length; previewIndex++) recordContextPreview(pendingContextPreviews[previewIndex]);
+      recordSessionTitle();
+    }
+    if (!pendingInternal) recordTranscript();
+
+    function recordSessionTitle() {
+      if (!session.title) {
+        session.title = (msg.text || "Image").substring(0, 50);
+        sm.saveSessionFile(session);
+        sm.broadcastSessionList();
+        // Sync auto-title to SDK
+        if (session.cliSessionId) {
+          adapter.renameSession(session.cliSessionId, session.title, { dir: cwd }).catch(function(e) {
+            console.error("[project] SDK renameSession failed:", e.message);
+          });
+        }
       }
     }
 
+    function recordContextPreview(previewEntry) {
+      session.history.push(previewEntry);
+      sendToSession(session.localId, {
+        type: "context_preview",
+        tab: {
+          title: previewEntry.tab.title,
+          url: previewEntry.tab.url,
+          favIconUrl: previewEntry.tab.favIconUrl,
+          screenshotUrl: "/p/" + slug + "/images/" + previewEntry.tab.screenshotFile,
+        },
+      });
+      sm.saveSessionFile(session);
+    }
+
     var fullText = msg.text || "";
     // Prepend saved image paths so Claude can copy/save them
     if (savedImagePaths.length > 0) {
@@ -423,16 +498,20 @@ function attachUserMessage(ctx) {
     }
 
     // Inject pending @mention context so the current agent sees the exchange
+    var pendingMentionCount = 0;
     if (session.pendingMentionContexts && session.pendingMentionContexts.length > 0) {
       var mentionPrefix = session.pendingMentionContexts.join("\n\n");
-      session.pendingMentionContexts = [];
+      pendingMentionCount = session.pendingMentionContexts.length;
+      if (!pendingInternal) session.pendingMentionContexts = [];
       fullText = mentionPrefix + "\n\n" + fullText;
     }
 
     // Inject one-shot shell results captured from the composer command mode.
+    var pendingShellCount = 0;
     if (session.pendingShellContexts && session.pendingShellContexts.length > 0) {
       var shellPrefix = session.pendingShellContexts.join("\n\n");
-      session.pendingShellContexts = [];
+      pendingShellCount = session.pendingShellContexts.length;
+      if (!pendingInternal) session.pendingShellContexts = [];
       fullText = shellPrefix + "\n\n" + fullText;
     }
     if (msg.shellCommandResponse) {
@@ -444,6 +523,7 @@ function attachUserMessage(ctx) {
     var TERM_HEAD_SIZE = 2048;   // keep first 2KB for error context
     var TERM_TAIL_SIZE = 6144;   // keep last 6KB for recent state
     var ctxSources = loadContextSources(slug, session.localId);
+    var pendingTermCursors = {};
     if (ctxSources.length > 0) {
       if (!session._termContextCursors) session._termContextCursors = {};
       var termContextParts = [];
@@ -463,7 +543,8 @@ function attachUserMessage(ctx) {
               lastCursor = Math.max(0, sb.totalBytesWritten - TERM_CONTEXT_MAX);
             }
             var newBytes = sb.totalBytesWritten - lastCursor;
-            session._termContextCursors[termId] = sb.totalBytesWritten;
+            if (pendingInternal) pendingTermCursors[termId] = sb.totalBytesWritten;
+            else session._termContextCursors[termId] = sb.totalBytesWritten;
             if (newBytes <= 0) continue;
             // Build timestamped delta from chunks
             var deltaChunks = [];
@@ -543,10 +624,51 @@ function attachUserMessage(ctx) {
       return !!_browserTabList[tid];
     });
 
+    function pendingBlockReason() {
+      if (!pendingInternal) return null;
+      if (!pendingMessageQueue.isClaimed(session, pendingInternal.item.id)) return "Pending message was cancelled";
+      if (pendingMessageQueue.isPaused(session) || session._pendingMessageDrainPaused || session.taskStopRequested) return "Pending message dispatch paused";
+      if (typeof ctx.authorizePendingDispatch !== "function" || !ctx.authorizePendingDispatch(session, ws && ws._clayUser, pendingInternal.item)) return "Pending message authorization changed";
+      return null;
+    }
+
+    function pendingStillAuthorized() {
+      return !pendingBlockReason();
+    }
+
+    function acceptPendingDispatch() {
+      if (!pendingInternal) return true;
+      var blockReason = pendingBlockReason();
+      if (blockReason) {
+        rejectPendingDispatch(blockReason);
+        return false;
+      }
+      if (pendingMentionCount && Array.isArray(session.pendingMentionContexts)) session.pendingMentionContexts.splice(0, pendingMentionCount);
+      if (pendingShellCount && Array.isArray(session.pendingShellContexts)) session.pendingShellContexts.splice(0, pendingShellCount);
+      Object.keys(pendingTermCursors).forEach(function (termId) { session._termContextCursors[termId] = pendingTermCursors[termId]; });
+      recordTranscript();
+      pendingInternal.complete(true);
+      return true;
+    }
+
+    function rejectPendingDispatch(error) {
+      if (!pendingInternal) return;
+      var reason = error && error.message ? error.message : error || "Pending message dispatch was rejected";
+      if (reason === "Pending message dispatch paused") pendingInternal.complete("release", reason);
+      else pendingInternal.complete(false, reason);
+    }
+
     function startFreshQuery(finalText) {
       session._queryStartTs = Date.now();
       console.log("[PERF] project.js: startQuery called, localId=" + session.localId + " t=0ms");
-      sdk.startQuery(session, finalText, msg.images, ensureProjectAccessForSession(session));
+      var started = sdk.startQuery(session, finalText, msg.images, ensureProjectAccessForSession(session), function () {
+        var blockReason = pendingBlockReason();
+        if (blockReason) rejectPendingDispatch(blockReason);
+        return !blockReason;
+      }, acceptPendingDispatch);
+      if (pendingInternal && started && typeof started.then === "function") started.then(function (accepted) {
+        if (accepted === false) rejectPendingDispatch("Pending message dispatch was rejected");
+      }).catch(rejectPendingDispatch);
     }
 
     function dispatchToSdk(finalText) {
@@ -565,16 +687,18 @@ function attachUserMessage(ctx) {
           // which used to leave the processing indicator bouncing with no
           // response until the user sent the message again.
           startFreshQuery(finalText);
-        }
+        } else acceptPendingDispatch();
       } else if (!sdk.pushMessage(session, finalText, msg.images, autonomousDeliveryMeta)) {
         // isProcessing was stuck true with no live query: same recovery.
         startFreshQuery(finalText);
-      }
+      } else acceptPendingDispatch();
       sm.broadcastSessionList();
     }
 
     // Wait for email context, then proceed with browser tab context and dispatch
     emailContextPromise.then(function (emailCtxText) {
+      var emailBlockReason = pendingBlockReason();
+      if (emailBlockReason) { rejectPendingDispatch(emailBlockReason); return; }
       if (emailCtxText) {
         fullText = emailCtxText + "\n\n" + fullText;
       }
@@ -586,6 +710,8 @@ function attachUserMessage(ctx) {
         return requestTabContext(tabId);
       });
       Promise.all(tabPromises).then(function(results) {
+        var tabBlockReason = pendingBlockReason();
+        if (tabBlockReason) { rejectPendingDispatch(tabBlockReason); return; }
         var tabContextParts = [];
         var screenshotImages = [];
 
@@ -703,38 +829,48 @@ function attachUserMessage(ctx) {
                 screenshotFile: ss.file
               }
             };
-            session.history.push(previewEntry);
-            // Send context card to all clients
-            sendToSession(session.localId, {
-              type: "context_preview",
-              tab: {
-                title: ss.tabTitle || "",
-                url: ss.tabUrl || "",
-                favIconUrl: ss.tabFavIconUrl || "",
-                screenshotUrl: "/p/" + slug + "/images/" + ss.file
-              }
-            });
+            if (pendingInternal) pendingContextPreviews.push(previewEntry);
+            else recordContextPreview(previewEntry);
             // Add to SDK images for multimodal
             msg.images.push({ mediaType: ss.mediaType, data: ss.data });
           }
-          sm.saveSessionFile(session);
         }
 
         dispatchToSdk(fullText);
-      });
+      }).catch(rejectPendingDispatch);
     } else {
       dispatchToSdk(fullText);
     }
 
-    }); // emailContextPromise.then
+    }).catch(rejectPendingDispatch); // emailContextPromise.then
 
     return true;
   }
 
+  function consumePendingMessage(session) {
+    if (!pendingMessageQueue) return false;
+    var consumed = pendingMessageQueue.consumeOne(session, function (item, complete) {
+      var actor = item.actorId && usersModule.findUserById(item.actorId);
+      if ((!actor && item.actorId !== "default") || typeof ctx.authorizePendingDispatch !== "function" || !ctx.authorizePendingDispatch(session, actor || null, item)) {
+        complete(false, "Pending message authorization changed");
+        return true;
+      }
+      var source = { _clayUser: actor || null, readyState: 1, send: function () {} };
+      handleUserMessage(source, copyMessage(item.message), session, { pendingConsumed: true, item: item, complete: complete });
+      return true;
+    });
+    return !!consumed;
+  }
+
   return {
     handleUserMessage: handleUserMessage,
+    consumePendingMessage: consumePendingMessage,
     syncNotesKnowledge: syncNotesKnowledge,
   };
 }
 
+function copyMessage(message) {
+  return JSON.parse(JSON.stringify(message || {}));
+}
+
 module.exports = { attachUserMessage: attachUserMessage };

package/lib/project-workspace-query.js

@@ -31,6 +31,7 @@ function attachProjectWorkspaceQuery(ctx) {
   function createMcpServer(adapter, session) {
     if (!service || isMate !== true) return null;
     var bound = session ? binding(session) : null;
+    if (session && !bound) return null;
     var projectBound = binding(null);
     if (!projectBound) return null;
     return workspaceMcp.createMcpServer(adapter, bound, projectBound.isClay);
@@ -39,6 +40,7 @@ function attachProjectWorkspaceQuery(ctx) {
   function createHistoryMcpServer(adapter, session) {
     if (!adapter || typeof adapter.createToolServer !== "function") return null;
     var bound = session ? binding(session) : null;
+    if (session && !bound) return null;
     var projectBound = binding(null);
     if (!projectBound || projectBound.isClay !== true) return null;
     return adapter.createToolServer({
@@ -48,6 +50,28 @@ function attachProjectWorkspaceQuery(ctx) {
     });
   }
 
+  function getLateSessionMcpServers(adapter, session, startupServers, boundServers) {
+    var servers = {};
+    if (!session) return servers;
+    if (isMate && !Object.prototype.hasOwnProperty.call(startupServers || {}, "clay-workspace") && !boundServers["clay-workspace"]) {
+      try {
+        var workspace = createMcpServer(adapter, session);
+        if (workspace) servers["clay-workspace"] = workspace;
+      } catch (e) {
+        console.error("[project-workspace-query] Failed to late-bind clay-workspace MCP server:", e.message);
+      }
+    }
+    if (isMate && !Object.prototype.hasOwnProperty.call(startupServers || {}, "clay-history") && !boundServers["clay-history"]) {
+      try {
+        var history = createHistoryMcpServer(adapter, session);
+        if (history) servers["clay-history"] = history;
+      } catch (e) {
+        console.error("[project-workspace-query] Failed to late-bind clay-history MCP server:", e.message);
+      }
+    }
+    return servers;
+  }
+
   function isAuthoritativeClay() {
     var bound = binding(null);
     return !!(bound && bound.isClay === true);
@@ -130,6 +154,7 @@ function attachProjectWorkspaceQuery(ctx) {
   return {
     createMcpServer: createMcpServer,
     createHistoryMcpServer: createHistoryMcpServer,
+    getLateSessionMcpServers: getLateSessionMcpServers,
     isAuthoritativeClay: isAuthoritativeClay,
     getBridgeTools: getBridgeTools,
     getHistoryBridgeTools: getHistoryBridgeTools,