clay-server 4.0.0-beta.23 → 4.0.0-beta.25

package/lib/project-connection.js

@@ -342,6 +342,7 @@ function attachConnection(ctx) {
     tm.detachAll(ws);
     clients.delete(ws);
     stopFileWatch(ws);
+    stopAllDirWatches(ws);
     if (clients.size === 0) {
       stopFileWatch();
       stopAllDirWatches();

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

package/lib/project-file-watch.js

@@ -5,7 +5,7 @@ var path = require("path");
  * Attach file/directory watcher engine to a project context.
  *
  * ctx fields:
- *   cwd, send, sendTo, safePath, BINARY_EXTS, FS_MAX_SIZE, IGNORED_DIRS
+ *   cwd, send, sendTo, safePath, BINARY_EXTS, FS_MAX_SIZE, IGNORED_DIRS, requestAccess, fsAsUser
  */
 function attachFileWatch(ctx) {
   var cwd = ctx.cwd;
@@ -15,6 +15,19 @@ function attachFileWatch(ctx) {
   var BINARY_EXTS = ctx.BINARY_EXTS;
   var FS_MAX_SIZE = ctx.FS_MAX_SIZE;
   var IGNORED_DIRS = ctx.IGNORED_DIRS;
+  var access = ctx.requestAccess;
+
+  function identityFor(client) {
+    if (!access) return null;
+    if (!access.canUseFiles(client)) throw new Error("File browser access is not permitted");
+    return access.osIdentity(client);
+  }
+
+  function checkedPath(relPath) {
+    var resolved = safePath(cwd, relPath);
+    if (!resolved) throw new Error("Access denied");
+    return resolved;
+  }
 
   // --- File watcher ---
   // One open file per websocket client. A project-wide singleton watcher made
@@ -47,18 +60,21 @@ function attachFileWatch(ctx) {
     }
   }
 
-  function readFileSnapshot(absPath) {
-    var stat = fs.statSync(absPath);
+  function readFileSnapshot(client, relPath) {
+    var identity = identityFor(client);
+    var absPath = checkedPath(relPath);
+    var stat = identity ? ctx.fsAsUser("stat", { file: absPath }, identity) : fs.statSync(absPath);
     var ext = path.extname(absPath).toLowerCase();
     if (stat.size > FS_MAX_SIZE || BINARY_EXTS.has(ext)) return null;
+    if (identity) return ctx.fsAsUser("read", { file: absPath, readContent: true }, identity);
     return { content: fs.readFileSync(absPath, "utf8"), size: stat.size };
   }
 
-  function publishFileChanged(key, client, relPath, absPath) {
+  function publishFileChanged(key, client, relPath) {
     var latest = fileWatchers.get(key);
     if (!latest || latest.relPath !== relPath) return;
     try {
-      var snapshot = readFileSnapshot(absPath);
+      var snapshot = readFileSnapshot(client, relPath);
       if (!snapshot) return;
       if (latest.hasSnapshot && latest.content === snapshot.content && latest.size === snapshot.size) return;
       latest.hasSnapshot = true;
@@ -97,7 +113,9 @@ function attachFileWatch(ctx) {
     var parentPath = path.dirname(absPath);
     var baseName = path.basename(absPath);
     var initialSnapshot = null;
-    try { initialSnapshot = readFileSnapshot(absPath); } catch (e) {}
+    try { initialSnapshot = readFileSnapshot(client, relPath); } catch (e) {
+      return Promise.resolve(false);
+    }
     try {
       var watcher = fs.watch(parentPath, function (eventType, filename) {
         if (filename && String(filename) !== baseName) return;
@@ -105,7 +123,7 @@ function attachFileWatch(ctx) {
         if (!active || active.relPath !== relPath) return;
         clearTimeout(active.debounce);
         active.debounce = setTimeout(function () {
-          publishFileChanged(key, client, relPath, absPath);
+          publishFileChanged(key, client, relPath);
         }, 200);
       });
       var resolveReady = null;
@@ -127,7 +145,7 @@ function attachFileWatch(ctx) {
       // drop them under load. Periodic content reconciliation is the source of
       // truth and also survives atomic replacements with identical metadata.
       entry.pollTimer = setInterval(function () {
-        publishFileChanged(key, client, relPath, absPath);
+        publishFileChanged(key, client, relPath);
       }, 1000);
       // fs.watch has no readiness event. Reconcile once on the next event-loop
       // turn so a change between the initial read and native watcher activation
@@ -135,7 +153,7 @@ function attachFileWatch(ctx) {
       entry.reconcile = setImmediate(function () {
         var active = fileWatchers.get(key);
         if (active) active.reconcile = null;
-        publishFileChanged(key, client, relPath, absPath);
+        publishFileChanged(key, client, relPath);
         if (fileWatchers.get(key) === entry) settleFileWatchReady(entry, true);
       });
       watcher.on("error", function () { closeFileWatch(key); });
@@ -155,55 +173,65 @@ function attachFileWatch(ctx) {
     for (var i = 0; i < keys.length; i++) closeFileWatch(keys[i]);
   }
 
-  // --- Directory watcher ---
-  var dirWatchers = {};  // relPath -> { watcher, debounce }
+  // Directory subscriptions are private to the requesting socket.
+  var dirWatchers = new Map();
 
-  function startDirWatch(relPath) {
-    if (dirWatchers[relPath]) return;
-    var absPath = safePath(cwd, relPath);
-    if (!absPath) return;
+  function readDirectory(client, relPath) {
+    var identity = identityFor(client);
+    var absPath = checkedPath(relPath);
+    var items = identity ? ctx.fsAsUser("list", { dir: absPath }, identity) :
+      fs.readdirSync(absPath, { withFileTypes: true }).map(function (item) {
+        return { name: item.name, isDir: item.isDirectory() };
+      });
+    return items.filter(function (item) {
+      return !item.isDir || !IGNORED_DIRS.has(item.name);
+    }).map(function (item) {
+      return { name: item.name, type: item.isDir ? "dir" : "file",
+        path: path.relative(cwd, path.join(absPath, item.name)).split(path.sep).join("/") };
+    });
+  }
+
+  function startDirWatch(client, relPath) {
+    var subscriptions = dirWatchers.get(client);
+    if (!subscriptions) { subscriptions = new Map(); dirWatchers.set(client, subscriptions); }
+    if (subscriptions.has(relPath)) return;
     try {
-      var debounce = null;
-      var watcher = fs.watch(absPath, function () {
-        clearTimeout(debounce);
-        debounce = setTimeout(function () {
-          // Re-read directory and broadcast to all clients
+      readDirectory(client, relPath);
+      var entry = { watcher: null, debounce: null };
+      entry.watcher = fs.watch(checkedPath(relPath), function () {
+        clearTimeout(entry.debounce);
+        entry.debounce = setTimeout(function () {
           try {
-            var items = fs.readdirSync(absPath, { withFileTypes: true });
-            var entries = [];
-            for (var i = 0; i < items.length; i++) {
-              if (items[i].isDirectory() && IGNORED_DIRS.has(items[i].name)) continue;
-              entries.push({
-                name: items[i].name,
-                type: items[i].isDirectory() ? "dir" : "file",
-                path: path.relative(cwd, path.join(absPath, items[i].name)).split(path.sep).join("/"),
-              });
-            }
-            send({ type: "fs_dir_changed", path: relPath, entries: entries });
-          } catch (e) {
-            stopDirWatch(relPath);
-          }
+            var entries = readDirectory(client, relPath);
+            sendTo(client, { type: "fs_dir_changed", path: relPath, entries: entries });
+          } catch (e) { stopDirWatch(client, relPath); }
         }, 300);
       });
-      watcher.on("error", function () { stopDirWatch(relPath); });
-      dirWatchers[relPath] = { watcher: watcher, debounce: debounce };
-    } catch (e) {}
+      entry.watcher.on("error", function () { stopDirWatch(client, relPath); });
+      subscriptions.set(relPath, entry);
+    } catch (e) {
+      if (!subscriptions.size) dirWatchers.delete(client);
+    }
   }
 
-  function stopDirWatch(relPath) {
-    var entry = dirWatchers[relPath];
-    if (entry) {
-      clearTimeout(entry.debounce);
-      try { entry.watcher.close(); } catch (e) {}
-      delete dirWatchers[relPath];
-    }
+  function stopDirWatch(client, relPath) {
+    var subscriptions = dirWatchers.get(client);
+    var entry = subscriptions && subscriptions.get(relPath);
+    if (!entry) return;
+    clearTimeout(entry.debounce);
+    try { entry.watcher.close(); } catch (e) {}
+    subscriptions.delete(relPath);
+    if (!subscriptions.size) dirWatchers.delete(client);
   }
 
-  function stopAllDirWatches() {
-    var paths = Object.keys(dirWatchers);
-    for (var i = 0; i < paths.length; i++) {
-      stopDirWatch(paths[i]);
-    }
+  function stopAllDirWatches(client) {
+    var clients = arguments.length ? [client] : Array.from(dirWatchers.keys());
+    clients.forEach(function (key) {
+      var subscriptions = dirWatchers.get(key);
+      if (subscriptions) Array.from(subscriptions.keys()).forEach(function (relPath) {
+        stopDirWatch(key, relPath);
+      });
+    });
   }
 
   return {