clay-server 4.0.0-beta.9 → 4.0.0

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/os-users.js

@@ -161,7 +161,9 @@ function fsAsUser(op, args, osUserInfo) {
       "var fs = require('fs');",
       "var f = " + JSON.stringify(args.file) + ";",
       "var content = " + JSON.stringify(args.content || "") + ";",
-      "fs.writeFileSync(f, content, 'utf8');",
+      "var flag = " + JSON.stringify(args.flag === "wx" ? "wx" : "w") + ";",
+      "var mode = " + JSON.stringify(typeof args.mode === "number" ? args.mode : 0o666) + ";",
+      "fs.writeFileSync(f, content, { encoding: 'utf8', flag: flag, mode: mode });",
       "process.stdout.write(JSON.stringify({ ok: true }));",
     ].join(" ");
   } else if (op === "mkdir") {

package/lib/project-capsule-catalog.js

@@ -1,4 +1,12 @@
 // Bounded progressive-disclosure catalog for Capsules visible to a Mate.
+//
+// Skills are gated by Display: a Capsule the human cannot operate by hand is a
+// Capsule no Mate may reach either, so an entry appears here only while its
+// declarative Display floor validates. The gate reads the Capsule's own tree,
+// carried alongside each manifest, and fails closed on a scan error, a missing
+// ID, or a missing or invalid Display.
+
+var capsuleFloor = require("./capsule-display-floor");
 
 var MAX_NAME_LENGTH = 80;
 var MAX_DESCRIPTION_LENGTH = 240;
@@ -35,7 +43,7 @@ function discoveryEntry(manifest) {
 function buildCapsuleCatalogPrompt(manifests) {
   if (!Array.isArray(manifests) || manifests.length === 0) return "";
   var sorted = manifests.filter(function (manifest) {
-    return manifest && !manifest.error && manifest.id;
+    return capsuleFloor.hasUsableFloor(manifest);
   }).slice().sort(function (a, b) {
     var first = String(a.id);
     var second = String(b.id);

package/lib/project-capsule-turn.js

@@ -0,0 +1,96 @@
+// Delivers a Capsule turn prompt into this Mate project.
+//
+// A Capsule game against a Mate needs the Mate to actually take its turns:
+// when Logic passes the turn to the mate seat, this module wakes the Mate
+// with a prompt telling it to snapshot the game and act. One session hosts
+// the whole game (found again by session.capsuleGame.toolId), so the user
+// watches a single running conversation of the Mate playing rather than a
+// new session per turn. The prompt is recorded as an internal user message,
+// the same shape the debate engine uses, so the transcript shows the nudge
+// without pretending the human typed it.
+//
+// This module only carries words to the Mate. Every actual game mutation the
+// Mate then makes goes through the same clay_tool_act pipeline as always.
+
+function attachCapsuleTurn(ctx) {
+  var sm = ctx.sm;
+
+  function ownsSession(session, principal) {
+    if (ctx.isMultiUser()) return !!principal.userId && session.ownerId === principal.userId;
+    return !session.ownerId;
+  }
+
+  function findGameSession(principal, toolId) {
+    var found = null;
+    sm.sessions.forEach(function (session) {
+      if (found || !session || session.hidden || session.destroying) return;
+      if (!session.capsuleGame || session.capsuleGame.toolId !== toolId) return;
+      if (!ownsSession(session, principal)) return;
+      found = session;
+    });
+    return found;
+  }
+
+  async function createGameSession(principal, options) {
+    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 for the Mate.");
+    }
+    var create = typeof sm.createSessionRaw === "function" ? sm.createSessionRaw : sm.createSession;
+    var session = create.call(sm, {
+      ownerId: principal.userId || null,
+      vendor: selection.vendor,
+      model: selection.model,
+    });
+    session.title = (options.toolName || options.toolId) + " game";
+    session.capsuleGame = { toolId: options.toolId };
+    return session;
+  }
+
+  async function deliverCapsuleTurn(principal, options) {
+    if (!principal || !options || !options.toolId || !options.text) {
+      throw new Error("A bound owner, toolId, and turn text are required.");
+    }
+    var sdk = ctx.getSdk();
+    if (!sdk || typeof sdk.startQuery !== "function") throw new Error("Mate project runtime is unavailable.");
+    var session = findGameSession(principal, options.toolId);
+    var created = false;
+    if (!session) {
+      session = await createGameSession(principal, options);
+      created = true;
+    }
+    // Recorded as a dedicated event, not a user message: the transcript shows
+    // a short system note (see historyToHomeChat) instead of pretending the
+    // human typed the delivery prompt. The full prompt still reaches the
+    // model through the query below.
+    sm.sendAndRecord(session, {
+      type: "capsule_turn",
+      text: options.text,
+      toolId: options.toolId,
+      toolName: options.toolName || options.toolId,
+      kind: options.kind || "turn",
+    });
+    session.isProcessing = true;
+    session.lastActivity = Date.now();
+    sm.broadcastSessionList();
+    try {
+      var delivered = typeof sdk.pushMessage === "function" ? sdk.pushMessage(session, options.text) : false;
+      if (!delivered) await Promise.resolve(sdk.startQuery(session, options.text, undefined, ctx.getLinuxUserForSession(session)));
+    } catch (error) {
+      session.isProcessing = false;
+      sm.sendAndRecord(session, { type: "error", text: "Capsule turn could not start: " + (error && error.message ? error.message : String(error)) });
+      sm.broadcastSessionList();
+      throw error;
+    }
+    // The reference shape the home chat surface opens sessions by.
+    return {
+      session: session,
+      created: created,
+      reference: (typeof session.cliSessionId === "string" && session.cliSessionId) || "local:" + session.localId,
+    };
+  }
+
+  return { deliverCapsuleTurn: deliverCapsuleTurn };
+}
+
+module.exports = { attachCapsuleTurn: attachCapsuleTurn };

package/lib/project-connection.js

@@ -233,7 +233,7 @@ function attachConnection(ctx) {
     // so vendor badges showed Claude until the next broadcast).
     sendTo(ws, {
       type: "session_list",
-      sessions: allSessions.map(function (s) { return sm.mapSessionForClient(s); }),
+      sessions: sm.mapSessionsForClient(allSessions),
     });
     if (_splitGroups) _splitGroups.sendConnectionState(ws);
 
@@ -342,6 +342,7 @@ function attachConnection(ctx) {
     tm.detachAll(ws);
     clients.delete(ws);
     stopFileWatch(ws);
+    stopAllDirWatches(ws);
     if (clients.size === 0) {
       stopFileWatch();
       stopAllDirWatches();
@@ -350,9 +351,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-file-history.js

@@ -0,0 +1,223 @@
+var path = require("path");
+var execFileSync = require("child_process").execFileSync;
+var wrapSpawnAsUser = require("./os-users").wrapSpawnAsUser;
+
+function attachFileHistory(ctx, access) {
+  var cwd = ctx.cwd;
+  var sm = ctx.sm;
+  var sendTo = ctx.sendTo;
+
+  function runGit(ws, args, options) {
+    options = Object.assign({}, options, { stdio: ["ignore", "pipe", "pipe"] });
+    var identity = access.osIdentity(ws);
+    if (identity) options = Object.assign({}, options, { uid: identity.uid, gid: identity.gid });
+    var command = wrapSpawnAsUser("git", args, options);
+    return execFileSync(command.command, command.args, command.options);
+  }
+
+  function handleFileHistory(ws, msg) {
+    if (!/^fs_(file_history|git_diff|file_at)$/.test(msg.type)) return false;
+    if (typeof msg.path !== "string" || !msg.path || path.isAbsolute(msg.path) ||
+        path.relative(cwd, path.resolve(cwd, msg.path)).split(path.sep).indexOf("..") !== -1 ||
+        (msg.hash && !/^[a-fA-F0-9]{4,64}$/.test(msg.hash)) ||
+        (msg.hash2 && !/^[a-fA-F0-9]{4,64}$/.test(msg.hash2))) {
+      sendTo(ws, { type: msg.type + "_result", path: msg.path, error: "Invalid file history request" });
+      return true;
+    }
+    // --- File edit history ---
+    if (msg.type === "fs_file_history") {
+      var histPath = msg.path;
+      if (!histPath) {
+        sendTo(ws, { type: "fs_file_history_result", path: histPath, entries: [] });
+        return true;
+      }
+      var absHistPath = path.resolve(cwd, histPath);
+      var entries = [];
+
+      // Collect session edits
+      sm.sessions.forEach(function (session) {
+        if (!access.canReadSession(ws, session)) return;
+        var sessionLocalId = session.localId;
+        var sessionTitle = session.title || "Untitled";
+        var histLen = session.history.length || 1;
+
+        for (var hi = 0; hi < session.history.length; hi++) {
+          var entry = session.history[hi];
+          if (entry.type !== "tool_executing") continue;
+          if (entry.name !== "Edit" && entry.name !== "Write") continue;
+          if (!entry.input || !entry.input.file_path) continue;
+          if (entry.input.file_path !== absHistPath) continue;
+
+          // Find parent assistant UUID + message snippet by scanning backwards
+          var assistantUuid = null;
+          var uuidIndex = -1;
+          for (var hj = hi - 1; hj >= 0; hj--) {
+            if (session.history[hj].type === "message_uuid" && session.history[hj].messageType === "assistant") {
+              assistantUuid = session.history[hj].uuid;
+              uuidIndex = hj;
+              break;
+            }
+          }
+
+          // Find user prompt by scanning backwards from the assistant uuid
+          var messageSnippet = "";
+          var searchFrom = uuidIndex >= 0 ? uuidIndex : hi;
+          for (var hk = searchFrom - 1; hk >= 0; hk--) {
+            if (session.history[hk].type === "user_message" && session.history[hk].text) {
+              messageSnippet = session.history[hk].text.trim().substring(0, 100);
+              break;
+            }
+          }
+
+          // Collect Claude's explanation: scan backwards from tool_executing
+          // to find the nearest delta text block (skipping tool_start).
+          // If no delta found immediately before this tool, scan past
+          // intervening tool blocks to find the last delta text within
+          // the same assistant turn.
+          var assistantSnippet = "";
+          var deltaChunks = [];
+          for (var hd = hi - 1; hd >= 0; hd--) {
+            var hEntry = session.history[hd];
+            if (hEntry.type === "tool_start") continue;
+            if (hEntry.type === "delta" && hEntry.text) {
+              deltaChunks.unshift(hEntry.text);
+            } else {
+              break;
+            }
+          }
+          if (deltaChunks.length === 0) {
+            // No delta immediately before; scan past tool blocks
+            // to find the nearest preceding delta in the same turn
+            for (var hd2 = hi - 1; hd2 >= 0; hd2--) {
+              var hEntry2 = session.history[hd2];
+              if (hEntry2.type === "tool_start" || hEntry2.type === "tool_executing" || hEntry2.type === "tool_result") continue;
+              if (hEntry2.type === "delta" && hEntry2.text) {
+                // Found a delta before an earlier tool in the same turn.
+                // Collect this contiguous block of deltas.
+                for (var hd3 = hd2; hd3 >= 0; hd3--) {
+                  var hEntry3 = session.history[hd3];
+                  if (hEntry3.type === "tool_start") continue;
+                  if (hEntry3.type === "delta" && hEntry3.text) {
+                    deltaChunks.unshift(hEntry3.text);
+                  } else {
+                    break;
+                  }
+                }
+                break;
+              } else {
+                // Hit message_uuid, user_message, etc. Stop.
+                break;
+              }
+            }
+          }
+          assistantSnippet = deltaChunks.join("").trim().substring(0, 150);
+
+          // Approximate timestamp: interpolate between session creation and last activity
+          var tStart = session.createdAt || 0;
+          var tEnd = session.lastActivity || tStart;
+          var ts = tStart + Math.floor((hi / histLen) * (tEnd - tStart));
+
+          var editRecord = {
+            source: "session",
+            timestamp: ts,
+            sessionLocalId: sessionLocalId,
+            sessionTitle: sessionTitle,
+            assistantUuid: assistantUuid,
+            toolId: entry.id,
+            messageSnippet: messageSnippet,
+            assistantSnippet: assistantSnippet,
+            toolName: entry.name,
+          };
+
+          if (entry.name === "Edit") {
+            editRecord.old_string = entry.input.old_string || "";
+            editRecord.new_string = entry.input.new_string || "";
+          } else {
+            editRecord.isFullWrite = true;
+          }
+
+          entries.push(editRecord);
+        }
+      });
+
+      // Collect git commits
+      try {
+        var gitLog = runGit(ws,
+          ["log", "--format=%H|%at|%an|%s", "--follow", "--", histPath],
+          { cwd: cwd, encoding: "utf8", timeout: 5000 }
+        );
+        var gitLines = gitLog.trim().split("\n");
+        for (var gi = 0; gi < gitLines.length; gi++) {
+          if (!gitLines[gi]) continue;
+          var parts = gitLines[gi].split("|");
+          if (parts.length < 4) continue;
+          entries.push({
+            source: "git",
+            hash: parts[0],
+            timestamp: parseInt(parts[1], 10) * 1000,
+            author: parts[2],
+            message: parts.slice(3).join("|"),
+          });
+        }
+      } catch (e) {
+        // Not a git repo or file not tracked, that is fine
+      }
+
+      // Sort by timestamp descending (newest first)
+      entries.sort(function (a, b) { return b.timestamp - a.timestamp; });
+
+      sendTo(ws, { type: "fs_file_history_result", path: histPath, entries: entries });
+      return true;
+    }
+
+    // --- Git diff for file history ---
+    if (msg.type === "fs_git_diff") {
+      var diffPath = msg.path;
+      var hash = msg.hash;
+      var hash2 = msg.hash2 || null;
+      if (!diffPath || !hash) {
+        sendTo(ws, { type: "fs_git_diff_result", hash: hash, path: diffPath, diff: "", error: "Missing params" });
+        return true;
+      }
+      try {
+        var diff;
+        if (hash2) {
+          diff = runGit(ws, ["diff", hash, hash2, "--", diffPath],
+            { cwd: cwd, encoding: "utf8", timeout: 5000 });
+        } else {
+          diff = runGit(ws, ["show", hash, "--format=", "--", diffPath],
+            { cwd: cwd, encoding: "utf8", timeout: 5000 });
+        }
+        sendTo(ws, { type: "fs_git_diff_result", hash: hash, hash2: hash2, path: diffPath, diff: diff || "" });
+      } catch (e) {
+        sendTo(ws, { type: "fs_git_diff_result", hash: hash, hash2: hash2, path: diffPath, diff: "", error: e.message });
+      }
+      return true;
+    }
+
+    // --- File content at a git commit ---
+    if (msg.type === "fs_file_at") {
+      var atPath = msg.path;
+      var atHash = msg.hash;
+      if (!atPath || !atHash) {
+        sendTo(ws, { type: "fs_file_at_result", hash: atHash, path: atPath, content: "", error: "Missing params" });
+        return true;
+      }
+      try {
+        // Convert to repo-relative path (git show requires hash:relative/path)
+        var atAbsPath = path.resolve(cwd, atPath);
+        var atRelPath = path.relative(cwd, atAbsPath);
+        var content = runGit(ws, ["show", atHash + ":" + atRelPath],
+          { cwd: cwd, encoding: "utf8", timeout: 5000 });
+        sendTo(ws, { type: "fs_file_at_result", hash: atHash, path: atPath, content: content });
+      } catch (e) {
+        sendTo(ws, { type: "fs_file_at_result", hash: atHash, path: atPath, content: "", error: e.message });
+      }
+      return true;
+    }
+
+    return false;
+  }
+  return { handleFileHistory: handleFileHistory };
+}
+module.exports = { attachFileHistory: attachFileHistory };