clay-server 3.8.1 → 4.0.0-beta.10

package/lib/project-delegated-follow-up.js

@@ -0,0 +1,84 @@
+function hasEntries(value) {
+  return !!(value && Object.keys(value).length > 0);
+}
+
+function unsafeReason(session, isPaired) {
+  if (!session || session.hidden) return "Target session is unavailable.";
+  if (!session.cliSessionId) return "Target session must have a durable session reference.";
+  if (session.sessionVisibility !== "private") return "Target session must be private.";
+  if (session.isProcessing || session._queryStarting || session._awaitingTurnResult) return "Target session must be idle.";
+  if (hasEntries(session.pendingPermissions) || hasEntries(session.pendingAskUser) || hasEntries(session.pendingElicitations) || hasEntries(session.pendingUserDialogs)) return "Target session is waiting for user input.";
+  if ((session.mode && session.mode !== "gui") || (session.runtimeMode && session.runtimeMode !== "gui") || session.terminalId != null || session.runtimeTerminalId != null || session.tuiSuspended) return "Terminal sessions cannot receive project follow-ups.";
+  if (session.homeDebatePlanning || session.homeDebatePhase || session.debateSetupMode || session.debateState || session._debate) return "Debate sessions cannot receive project follow-ups.";
+  if (session.loop || session.spawn || session.handoff || session.assignment || session.singleTurn || session._pairDelegation || isPaired) return "Orchestrated sessions cannot receive project follow-ups.";
+  if (session.dangerouslySkipPermissions || session.permissionMode === "bypassPermissions") return "Full-access sessions cannot receive project follow-ups.";
+  if (session.destroying || session.scheduledMessage || session.rateLimitAutoContinuePending || session.taskStopRequested || session._runtimeRefreshRequested || session.pendingPush && session.pendingPush.length) return "Target session is not safely resumable right now.";
+  return "";
+}
+
+function attachDelegatedFollowUp(ctx) {
+  var sm = ctx.sm;
+
+  function inspect(principal, targetSessionRef) {
+    if (!principal || typeof targetSessionRef !== "string" || targetSessionRef.indexOf("session:") !== 0) {
+      throw new Error("A durable opaque targetSessionRef is required.");
+    }
+    var session = null;
+    sm.sessions.forEach(function (candidate) {
+      if (!session && ctx.sessionRef(candidate) === targetSessionRef) session = candidate;
+    });
+    if (!session) throw new Error("Target session was not found in this project.");
+    if (ctx.isMultiUser()) {
+      if (!principal.userId || session.ownerId !== principal.userId) throw new Error("Target session access denied.");
+    } else if (session.ownerId) {
+      throw new Error("Target session access denied.");
+    }
+    var paired = !!(ctx.isPairedSession && ctx.isPairedSession(session));
+    var reason = unsafeReason(session, paired);
+    if (reason) throw new Error(reason);
+    if (!ctx.canResumeVendor(session.vendor)) throw new Error("Target session provider cannot safely resume this conversation.");
+    return { session: session, sessionRef: targetSessionRef, title: session.title || "Existing session" };
+  }
+
+  async function dispatch(principal, targetSessionRef, task, metadata, onReady) {
+    var resolved = inspect(principal, targetSessionRef);
+    var session = resolved.session;
+    var sdk = ctx.getSdk();
+    if (!sdk || typeof sdk.pushMessage !== "function" || typeof sdk.startQuery !== "function") {
+      throw new Error("Target project runtime is unavailable.");
+    }
+    if (typeof onReady === "function") onReady(session);
+    sm.sendAndRecord(session, {
+      type: "delegated_follow_up",
+      text: task,
+      assignmentId: metadata.assignmentId,
+      sourceMateId: metadata.sourceMateId,
+      sourceProjectSlug: metadata.sourceProjectSlug,
+      sourceSessionRef: metadata.sourceSessionRef,
+    });
+    session.isProcessing = true;
+    session.lastActivity = Date.now();
+    session.sentToolResults = {};
+    if (ctx.onProcessingChanged) ctx.onProcessingChanged();
+    sm.broadcastSessionList();
+    try {
+      var delivered = sdk.pushMessage(session, task);
+      if (!delivered) await sdk.startQuery(session, task, undefined, ctx.getLinuxUserForSession(session));
+    } catch (error) {
+      session.isProcessing = false;
+      sm.sendAndRecord(session, {
+        type: "error",
+        text: "Delegated follow-up could not start: " + (error.message || String(error)),
+        assignmentId: metadata.assignmentId,
+      });
+      if (ctx.onProcessingChanged) ctx.onProcessingChanged();
+      sm.broadcastSessionList();
+      throw error;
+    }
+    return session;
+  }
+
+  return { inspectDelegatedFollowUp: inspect, dispatchDelegatedFollowUp: dispatch };
+}
+
+module.exports = { attachDelegatedFollowUp: attachDelegatedFollowUp, unsafeReason: unsafeReason };

package/lib/project-delegated-session.js

@@ -0,0 +1,53 @@
+function attachDelegatedSession(ctx) {
+  var sm = ctx.sm;
+
+  async function createDelegatedSession(principal, task, metadata, onCreated) {
+    if (!principal || !task) throw new Error("A bound owner and task are required.");
+    var selection = await ctx.resolveModel(principal);
+    if (!selection || selection.status !== "ready" || !selection.vendor || !selection.model) {
+      throw new Error(selection && selection.error ? selection.error : "No configured model is available in the target project.");
+    }
+    var sdk = ctx.getSdk();
+    if (!sdk || typeof sdk.startQuery !== "function") throw new Error("Target project runtime is unavailable.");
+    var create = typeof sm.createSessionRaw === "function" ? sm.createSessionRaw : sm.createSession;
+    var session = create.call(sm, {
+      ownerId: principal.userId || null,
+      sessionVisibility: "private",
+      vendor: selection.vendor,
+      model: selection.model,
+    });
+    session.title = metadata.title;
+    session.assignment = {
+      assignmentId: metadata.assignmentId,
+      sourceMateId: metadata.sourceMateId,
+      sourceProjectSlug: metadata.sourceProjectSlug,
+      sourceSessionRef: metadata.sourceSessionRef,
+      delegated: true,
+    };
+    session.singleTurn = true;
+    if (typeof onCreated === "function") onCreated(session);
+    sm.sendAndRecord(session, {
+      type: "delegated_work",
+      text: task,
+      assignmentId: metadata.assignmentId,
+      sourceMateId: metadata.sourceMateId,
+      sourceProjectSlug: metadata.sourceProjectSlug,
+      sourceSessionRef: metadata.sourceSessionRef,
+    });
+    session.isProcessing = true;
+    session.lastActivity = Date.now();
+    session.sentToolResults = {};
+    sm.broadcastSessionList();
+    try {
+      await Promise.resolve(sdk.startQuery(session, task, undefined, ctx.getLinuxUserForSession(session)));
+    } catch (error) {
+      session.isProcessing = false;
+      sm.sendAndRecord(session, { type: "error", text: error.message || String(error) });
+    }
+    return session;
+  }
+
+  return { createDelegatedSession: createDelegatedSession };
+}
+
+module.exports = { attachDelegatedSession: attachDelegatedSession };

package/lib/project-filesystem.js

@@ -13,7 +13,7 @@ var execFileSync = require("child_process").execFileSync;
  *   getOsUserInfoForWs (function)
  *   startFileWatch, stopFileWatch, startDirWatch (from _fileWatch)
  *   usersModule, fsAsUser
- *   validateEnvString (function)
+ *   validateEnvString, onEnvironmentChanged (functions)
  *   opts (for onGetProjectEnv, onSetProjectEnv, onGetSharedEnv, onSetSharedEnv callbacks)
  *   IGNORED_DIRS, BINARY_EXTS, IMAGE_EXTS, FS_MAX_SIZE (constants)
  */
@@ -33,6 +33,7 @@ function attachFilesystem(ctx) {
   var usersModule = ctx.usersModule;
   var fsAsUser = ctx.fsAsUser;
   var validateEnvString = ctx.validateEnvString;
+  var onEnvironmentChanged = ctx.onEnvironmentChanged || function () {};
   var opts = ctx.opts;
   var IGNORED_DIRS = ctx.IGNORED_DIRS;
   var BINARY_EXTS = ctx.BINARY_EXTS;
@@ -234,16 +235,11 @@ function attachFilesystem(ctx) {
     // --- Project environment variables ---
     if (msg.type === "get_project_env") {
       var envrc = "";
-      var hasEnvrc = false;
       if (typeof opts.onGetProjectEnv === "function") {
         var envResult = opts.onGetProjectEnv(msg.slug);
         envrc = envResult.envrc || "";
       }
-      try {
-        var envrcPath = path.join(cwd, ".envrc");
-        hasEnvrc = fs.existsSync(envrcPath);
-      } catch (e) {}
-      sendTo(ws, { type: "project_env_result", slug: msg.slug, envrc: envrc, hasEnvrc: hasEnvrc });
+      sendTo(ws, { type: "project_env_result", slug: msg.slug, envrc: envrc });
       return true;
     }
 
@@ -255,7 +251,8 @@ function attachFilesystem(ctx) {
           return true;
         }
         var setResult = opts.onSetProjectEnv(msg.slug, msg.envrc || "");
-        sendTo(ws, { type: "set_project_env_result", ok: setResult.ok, slug: msg.slug, error: setResult.error });
+        if (setResult.ok) onEnvironmentChanged();
+        sendTo(ws, { type: "set_project_env_result", ok: setResult.ok, slug: msg.slug, error: setResult.error, timing: setResult.ok ? "Applies to newly created coding-agent processes. Active processes keep their current environment." : undefined });
       } else {
         sendTo(ws, { type: "set_project_env_result", ok: false, error: "Not supported" });
       }
@@ -308,7 +305,8 @@ function attachFilesystem(ctx) {
           return true;
         }
         var sharedSetResult = opts.onSetSharedEnv(msg.envrc || "");
-        sendTo(ws, { type: "set_shared_env_result", ok: sharedSetResult.ok, error: sharedSetResult.error });
+        if (sharedSetResult.ok) onEnvironmentChanged();
+        sendTo(ws, { type: "set_shared_env_result", ok: sharedSetResult.ok, error: sharedSetResult.error, timing: sharedSetResult.ok ? "Applies to newly created coding-agent processes. Active processes keep their current environment." : undefined });
       } else {
         sendTo(ws, { type: "set_shared_env_result", ok: false, error: "Not supported" });
       }

package/lib/project-knowledge.js

@@ -1,5 +1,6 @@
 var fs = require("fs");
 var path = require("path");
+var mateSync = require("./mate-knowledge-sync");
 
 /**
  * Attach knowledge file management to a project context.
@@ -75,6 +76,23 @@ function attachKnowledge(ctx) {
     return files;
   }
 
+  // Mirror a Mate-owned knowledge file into the Clay-wide Knowledge backend
+  // after the legacy write has already succeeded. The legacy file stays
+  // authoritative; this only keeps the new scope from going stale.
+  function mirrorMateSource(ws, fileName) {
+    if (!isMate) return;
+    var user = (ws && ws._clayUser) || null;
+    mateSync.syncQuietly({
+      mateDir: cwd,
+      fileName: fileName,
+      actor: {
+        type: user ? "user" : "system",
+        userId: user ? user.id : null,
+        displayName: user ? (user.displayName || user.username) : null,
+      },
+    });
+  }
+
   function handleKnowledgeMessage(ws, msg) {
     if (msg.type === "knowledge_list") {
       sendTo(ws, { type: "knowledge_list", files: listKnowledgeFiles() });
@@ -111,6 +129,7 @@ function attachKnowledge(ctx) {
       var knowledgeDir = path.join(cwd, "knowledge");
       fs.mkdirSync(knowledgeDir, { recursive: true });
       fs.writeFileSync(path.join(knowledgeDir, safeName), msg.content);
+      mirrorMateSource(ws, safeName);
       sendTo(ws, { type: "knowledge_saved", name: safeName });
       sendTo(ws, { type: "knowledge_list", files: listKnowledgeFilesBasic() });
       return true;
@@ -121,6 +140,9 @@ function attachKnowledge(ctx) {
       var safeName = path.basename(msg.name);
       var filePath = path.join(cwd, "knowledge", safeName);
       try { fs.unlinkSync(filePath); } catch (e) {}
+      // Reconciling after the unlink appends a tombstone, so a deleted file
+      // does not stay live in the new backend.
+      mirrorMateSource(ws, safeName);
       sendTo(ws, { type: "knowledge_deleted", name: safeName });
       sendTo(ws, { type: "knowledge_list", files: listKnowledgeFilesBasic() });
       return true;
@@ -155,6 +177,7 @@ function attachKnowledge(ctx) {
 
   return {
     handleKnowledgeMessage: handleKnowledgeMessage,
+    listKnowledgeFiles: listKnowledgeFiles,
   };
 }
 

package/lib/project-logs-comments.js

@@ -0,0 +1,137 @@
+// Comment and review projection for Project Logs.
+//
+// Split from project-logs-store.js so the store stays inside the module size
+// limit.
+//
+// A user comment is a revision proposal, never an automatic canonical
+// mutation. It starts `pending` and stays that way until the project's own
+// Driver session reviews it. Reviews are append-only records that reference a
+// comment id; nothing is ever edited in place, and a comment written before
+// reviews existed simply projects as `pending`.
+
+var STATUS_PENDING = "pending";
+var STATUS_CLARIFICATION = "clarification-needed";
+var STATUS_INCORPORATED = "incorporated";
+var STATUS_DECLINED = "declined";
+
+var STATUSES = [STATUS_PENDING, STATUS_CLARIFICATION, STATUS_INCORPORATED, STATUS_DECLINED];
+
+// Actions the Driver may take. `incorporate` is the only one that produces a
+// canonical revision.
+var ACTIONS = ["incorporate", "clarify", "decline"];
+
+var ACTION_STATUS = {
+  incorporate: STATUS_INCORPORATED,
+  clarify: STATUS_CLARIFICATION,
+  decline: STATUS_DECLINED,
+};
+
+// Waiting on the Driver. Only an unreviewed comment qualifies.
+//
+// A clarification is deliberately NOT Driver work: the Driver has already
+// answered, and the ball is with the user. Because a comment is settled once
+// and never re-reviewed, counting a clarification as pending would leave it in
+// the queue forever with no way out. The user's reply is a new comment, which
+// is pending in its own right and can be incorporated or declined.
+function isPendingReview(status) {
+  return status === STATUS_PENDING;
+}
+
+// Answered by the Driver and now waiting on the person who commented. Shown
+// permanently on the original comment; never counted as Driver work.
+function isAwaitingUser(status) {
+  return status === STATUS_CLARIFICATION;
+}
+
+function isAction(value) {
+  return ACTIONS.indexOf(value) !== -1;
+}
+
+// Project the comment thread of one entry, folding review records onto the
+// comments they resolve. `revisionForRecordId` maps an incorporating review
+// record id to the canonical revision number it produced, so an incorporated
+// comment can point at its result.
+function comments(chain, options) {
+  var settings = options || {};
+  var maxComments = settings.maxComments || 200;
+  var revisionForRecordId = settings.revisionForRecordId || {};
+  var byId = {};
+  var order = [];
+
+  var i;
+  for (i = 0; i < chain.length; i++) {
+    var record = chain[i];
+    if (record.op !== "comment") continue;
+    if (order.length >= maxComments) break;
+    var comment = {
+      id: record.id,
+      body: record.body || "",
+      at: record.at || 0,
+      author: record.author || null,
+      // A comment with no review yet is pending, which is also how every
+      // comment written before reviews existed projects.
+      status: STATUS_PENDING,
+      review: null,
+    };
+    byId[record.id] = comment;
+    order.push(comment);
+  }
+
+  for (i = 0; i < chain.length; i++) {
+    var review = chain[i];
+    if (review.op !== "review") continue;
+    var target = byId[review.commentId];
+    if (!target) continue;
+    if (!isAction(review.action)) continue;
+    // Append-only: the first review of a comment settles it. A later review of
+    // the same comment is ignored rather than silently overwriting the record
+    // of what was decided.
+    if (target.review) continue;
+    target.status = ACTION_STATUS[review.action];
+    target.review = {
+      action: review.action,
+      response: typeof review.response === "string" ? review.response : "",
+      at: review.at || 0,
+      reviewer: review.author || null,
+      revision: review.action === "incorporate"
+        ? (revisionForRecordId[review.id] || null)
+        : null,
+    };
+  }
+
+  return order;
+}
+
+// How many comments are still waiting on the Driver. Used for the ledger row
+// count and for the system-prompt signal, neither of which carries any body.
+function pendingReviewCount(list) {
+  var count = 0;
+  for (var i = 0; i < (list || []).length; i++) {
+    if (isPendingReview(list[i].status)) count++;
+  }
+  return count;
+}
+
+function pendingReviewComments(list) {
+  var out = [];
+  for (var i = 0; i < (list || []).length; i++) {
+    if (isPendingReview(list[i].status)) out.push(list[i]);
+  }
+  return out;
+}
+
+module.exports = {
+  STATUS_PENDING: STATUS_PENDING,
+  STATUS_CLARIFICATION: STATUS_CLARIFICATION,
+  STATUS_INCORPORATED: STATUS_INCORPORATED,
+  STATUS_DECLINED: STATUS_DECLINED,
+  STATUSES: STATUSES,
+  ACTIONS: ACTIONS,
+  ACTION_STATUS: ACTION_STATUS,
+  isPendingReview: isPendingReview,
+  isAwaitingUser: isAwaitingUser,
+  isAction: isAction,
+  comments: comments,
+  pendingReviewCount: pendingReviewCount,
+  pendingReviewComments: pendingReviewComments,
+};