clay-server 4.0.0-beta.1 → 4.0.0-beta.11

package/lib/notes.js

@@ -3,6 +3,7 @@ var path = require("path");
 var crypto = require("crypto");
 var config = require("./config");
 var utils = require("./utils");
+var lifecycle = require("./notes-lifecycle");
 
 function createNotesManager(opts) {
   var cwd = opts.cwd;
@@ -19,11 +20,14 @@ function createNotesManager(opts) {
     return "n_" + Date.now() + "_" + crypto.randomBytes(3).toString("hex");
   }
 
+  // Legacy files are normalized on load, never on read. Nothing is rewritten
+  // just because a note was looked at; the projected fields reach disk the next
+  // time some other write happens.
   function loadFromDisk() {
     try {
       var data = fs.readFileSync(notesFile, "utf8");
       var parsed = JSON.parse(data);
-      return parsed.notes || [];
+      return lifecycle.normalizeAll(parsed.notes || []).notes;
     } catch (e) {
       return [];
     }
@@ -56,6 +60,10 @@ function createNotesManager(opts) {
       color: data.color || "purple",
       opacity: typeof data.opacity === "number" ? data.opacity : 0.64,
       minimized: false,
+      // A new note is always an open attention item.
+      state: lifecycle.STATE_OPEN,
+      closedAt: null,
+      closedBy: null,
       zIndex: notes.length + 1,
       createdAt: now,
       updatedAt: now,
@@ -74,13 +82,20 @@ function createNotesManager(opts) {
   function update(id, changes) {
     for (var i = 0; i < notes.length; i++) {
       if (notes[i].id === id) {
-        var allowed = ["text", "x", "y", "w", "h", "color", "minimized", "hidden", "zIndex", "opacity"];
+        var allowed = ["text", "x", "y", "w", "h", "color", "minimized", "zIndex", "opacity"];
         for (var j = 0; j < allowed.length; j++) {
           var key = allowed[j];
           if (changes[key] !== undefined) {
             notes[i][key] = changes[key];
           }
         }
+        // `hidden` is the legacy spelling of the lifecycle. Route it through the
+        // transitions so state, hidden, and the close provenance can never
+        // disagree, and so an old client cannot half-apply a close.
+        if (changes.hidden !== undefined) {
+          if (changes.hidden === true) lifecycle.applyClose(notes[i], changes.actor || null, Date.now());
+          else lifecycle.applyReopen(notes[i]);
+        }
         notes[i].updatedAt = Date.now();
         saveToDisk();
         return notes[i];
@@ -89,6 +104,44 @@ function createNotesManager(opts) {
     return null;
   }
 
+  // Close a note. This is what completion means: the record stays and only its
+  // place on the active canvas changes. Idempotent.
+  function close(id, actor) {
+    for (var i = 0; i < notes.length; i++) {
+      if (notes[i].id !== id) continue;
+      if (lifecycle.applyClose(notes[i], actor || null, Date.now())) {
+        notes[i].updatedAt = Date.now();
+        saveToDisk();
+      }
+      return notes[i];
+    }
+    return null;
+  }
+
+  // Reopen a closed note. Idempotent.
+  function reopen(id) {
+    for (var i = 0; i < notes.length; i++) {
+      if (notes[i].id !== id) continue;
+      if (lifecycle.applyReopen(notes[i])) {
+        notes[i].updatedAt = Date.now();
+        saveToDisk();
+      }
+      return notes[i];
+    }
+    return null;
+  }
+
+  function openList() {
+    return lifecycle.openNotes(notes);
+  }
+
+  function closedList() {
+    return lifecycle.closedNotes(notes);
+  }
+
+  // Permanent deletion. Deliberately not reachable from any WebSocket message,
+  // MCP tool, or UI control: completion closes, it never erases. Retained only
+  // for maintenance callers that must truly discard a record.
   function remove(id) {
     for (var i = 0; i < notes.length; i++) {
       if (notes[i].id === id) {
@@ -123,7 +176,7 @@ function createNotesManager(opts) {
   function getActiveNotesText() {
     var active = [];
     for (var i = 0; i < notes.length; i++) {
-      if (!notes[i].hidden && notes[i].text) active.push(notes[i]);
+      if (lifecycle.isOpen(notes[i]) && notes[i].text) active.push(notes[i]);
     }
     if (active.length === 0) return "";
     var lines = [];
@@ -137,8 +190,12 @@ function createNotesManager(opts) {
 
   return {
     list: list,
+    openList: openList,
+    closedList: closedList,
     create: create,
     update: update,
+    close: close,
+    reopen: reopen,
     remove: remove,
     bringToFront: bringToFront,
     getActiveNotesText: getActiveNotesText,

package/lib/project-connection.js

@@ -78,6 +78,7 @@ function attachConnection(ctx) {
   var _mcp = ctx._mcp;
   var _notifications = ctx._notifications;
   var _splitGroups = ctx._splitGroups;
+  var _vendorLogin = ctx._vendorLogin;
   var hydrateImageRefs = ctx.hydrateImageRefs;
   var resolveSessionForView = ctx.resolveSessionForView;
   var broadcastClientCount = ctx.broadcastClientCount;
@@ -191,6 +192,9 @@ function attachConnection(ctx) {
     sendTo(ws, { type: "last_vendor", vendor: sm.lastVendor || "" });
     sendTo(ws, Object.assign({ type: "codex_config" }, getCodexConfig(sm)));
     sendTo(ws, { type: "term_list", terminals: tm.list() });
+    // Any login flow already running in this project, so a reconnecting client
+    // re-attaches to the existing login terminal instead of starting another.
+    if (_vendorLogin) _vendorLogin.sendStateTo(ws);
     // Context sources sent after session is resolved (per-session storage)
     // Send email accounts list for context sources picker
     var emailUserId = (wsUser && wsUser.id) || "default";
@@ -346,9 +350,22 @@ function attachConnection(ctx) {
     broadcastPresence();
   }
 
+  // Keep-alive for the project socket, mirroring the `/ws` global handler.
+  //
+  // A reverse proxy resets its upstream read timeout on data flowing back from
+  // the server, so a client ping is only useful if the server answers it. This
+  // reads nothing, mutates nothing, and reveals nothing about the connection:
+  // it is a fixed reply on a fixed message type.
+  function handleKeepaliveMessage(ws, msg) {
+    if (!msg || typeof msg !== "object" || msg.type !== "ping") return false;
+    sendTo(ws, { type: "pong" });
+    return true;
+  }
+
   return {
     handleConnection: handleConnection,
     handleDisconnection: handleDisconnection,
+    handleKeepaliveMessage: handleKeepaliveMessage,
   };
 }
 

package/lib/project-http.js

@@ -730,7 +730,7 @@ function attachHTTP(ctx) {
     }
 
     // Git panel status and actions
-    var isGitPanelRequest = urlPath === "/api/git/status" ||
+    var isGitPanelRequest = urlPath === "/api/git/status" || urlPath === "/api/git/summary" ||
       urlPath === "/api/git/action" || urlPath.indexOf("/api/git/file-diff?") === 0 ||
       urlPath.indexOf("/api/git/session-diff?") === 0;
     if (isGitPanelRequest && usersModule.isMultiUser()) {
@@ -768,6 +768,20 @@ function attachHTTP(ctx) {
       return true;
     }
 
+    // Compact repository placard data for the always-visible sidebar block.
+    // Same permission gate as the panel, but no file payload and no path.
+    if (req.method === "GET" && urlPath === "/api/git/summary") {
+      try {
+        var gitSummary = gitCli.getSummary(cwd, getOsUserInfoForReq(req));
+        res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+        res.end(JSON.stringify(gitSummary));
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message || "Unable to read Git summary" }));
+      }
+      return true;
+    }
+
     if (req.method === "GET" && urlPath.indexOf("/api/git/file-diff?") === 0) {
       var gitDiffParams = new URLSearchParams(urlPath.slice(urlPath.indexOf("?")));
       var gitDiffPath = gitDiffParams.get("path");

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;

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,
+};