claude-relay 2.2.4 → 2.3.0

package/lib/project.js

@@ -55,7 +55,7 @@ function safePath(base, requested) {
 
 /**
  * Create a project context — per-project state and handlers.
- * opts: { cwd, slug, title, pushModule, debug, currentVersion }
+ * opts: { cwd, slug, title, pushModule, debug, dangerouslySkipPermissions, currentVersion }
  */
 function createProjectContext(opts) {
   var cwd = opts.cwd;
@@ -64,7 +64,9 @@ function createProjectContext(opts) {
   var title = opts.title || null;
   var pushModule = opts.pushModule || null;
   var debug = opts.debug || false;
+  var dangerouslySkipPermissions = opts.dangerouslySkipPermissions || false;
   var currentVersion = opts.currentVersion;
+  var lanHost = opts.lanHost || null;
   var getProjectCount = opts.getProjectCount || function () { return 1; };
   var getProjectList = opts.getProjectList || function () { return []; };
   var latestVersion = null;
@@ -136,16 +138,69 @@ function createProjectContext(opts) {
     watchedPath = null;
   }
 
+  // --- Directory watcher ---
+  var dirWatchers = {};  // relPath -> { watcher, debounce }
+
+  function startDirWatch(relPath) {
+    if (dirWatchers[relPath]) return;
+    var absPath = safePath(cwd, relPath);
+    if (!absPath) return;
+    try {
+      var debounce = null;
+      var watcher = fs.watch(absPath, function () {
+        clearTimeout(debounce);
+        debounce = setTimeout(function () {
+          // Re-read directory and broadcast to all clients
+          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);
+          }
+        }, 300);
+      });
+      watcher.on("error", function () { stopDirWatch(relPath); });
+      dirWatchers[relPath] = { watcher: watcher, debounce: debounce };
+    } catch (e) {}
+  }
+
+  function stopDirWatch(relPath) {
+    var entry = dirWatchers[relPath];
+    if (entry) {
+      clearTimeout(entry.debounce);
+      try { entry.watcher.close(); } catch (e) {}
+      delete dirWatchers[relPath];
+    }
+  }
+
+  function stopAllDirWatches() {
+    var paths = Object.keys(dirWatchers);
+    for (var i = 0; i < paths.length; i++) {
+      stopDirWatch(paths[i]);
+    }
+  }
+
   // --- Session manager ---
   var sm = createSessionManager({ cwd: cwd, send: send });
 
   // --- SDK bridge ---
   var sdk = createSDKBridge({
     cwd: cwd,
+    slug: slug,
     sessionManager: sm,
     send: send,
     pushModule: pushModule,
     getSDK: getSDK,
+    dangerouslySkipPermissions: dangerouslySkipPermissions,
   });
 
   // --- Terminal manager ---
@@ -165,7 +220,7 @@ function createProjectContext(opts) {
     broadcastClientCount();
 
     // Send cached state
-    sendTo(ws, { type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, projectCount: getProjectCount(), projects: getProjectList() });
+    sendTo(ws, { type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, dangerouslySkipPermissions: dangerouslySkipPermissions, lanHost: lanHost, projectCount: getProjectCount(), projects: getProjectList() });
     if (latestVersion) {
       sendTo(ws, { type: "update_available", version: latestVersion });
     }
@@ -206,6 +261,7 @@ function createProjectContext(opts) {
       for (var i = fromIndex; i < total; i++) {
         sendTo(ws, active.history[i]);
       }
+      sendTo(ws, { type: "history_done" });
 
       if (active.isProcessing) {
         sendTo(ws, { type: "status", status: "processing" });
@@ -238,7 +294,7 @@ function createProjectContext(opts) {
   // --- WS message handler ---
   function handleMessage(ws, msg) {
     if (msg.type === "push_subscribe") {
-      if (pushModule && msg.subscription) pushModule.addSubscription(msg.subscription);
+      if (pushModule && msg.subscription) pushModule.addSubscription(msg.subscription, msg.replaceEndpoint);
       return;
     }
 
@@ -308,6 +364,31 @@ function createProjectContext(opts) {
       return;
     }
 
+    if (msg.type === "process_stats") {
+      var sessionCount = sm.sessions.size;
+      var processingCount = 0;
+      sm.sessions.forEach(function (s) {
+        if (s.isProcessing) processingCount++;
+      });
+      var mem = process.memoryUsage();
+      sendTo(ws, {
+        type: "process_stats",
+        pid: process.pid,
+        uptime: process.uptime(),
+        memory: {
+          rss: mem.rss,
+          heapUsed: mem.heapUsed,
+          heapTotal: mem.heapTotal,
+          external: mem.external,
+        },
+        sessions: sessionCount,
+        processing: processingCount,
+        clients: clients.size,
+        terminals: tm.list().length,
+      });
+      return;
+    }
+
     if (msg.type === "stop") {
       var session = sm.getActiveSession();
       if (session && session.abortController && session.isProcessing) {
@@ -357,34 +438,41 @@ function createProjectContext(opts) {
     if (msg.type === "rewind_execute") {
       var session = sm.getActiveSession();
       if (!session || !session.cliSessionId || !msg.uuid) return;
+      var mode = msg.mode || "both";
 
       (async function () {
         var result;
         try {
-          result = await sdk.getOrCreateRewindQuery(session);
-          await result.query.rewindFiles(msg.uuid, { dryRun: false });
-
-          var targetIdx = -1;
-          for (var i = 0; i < session.messageUUIDs.length; i++) {
-            if (session.messageUUIDs[i].uuid === msg.uuid) {
-              targetIdx = i;
-              break;
-            }
+          // File restoration (skip for chat-only mode)
+          if (mode !== "chat") {
+            result = await sdk.getOrCreateRewindQuery(session);
+            await result.query.rewindFiles(msg.uuid, { dryRun: false });
           }
 
-          if (targetIdx >= 0) {
-            var trimTo = session.messageUUIDs[targetIdx].historyIndex;
-            for (var k = trimTo - 1; k >= 0; k--) {
-              if (session.history[k].type === "user_message") {
-                trimTo = k;
+          // Conversation rollback (skip for files-only mode)
+          if (mode !== "files") {
+            var targetIdx = -1;
+            for (var i = 0; i < session.messageUUIDs.length; i++) {
+              if (session.messageUUIDs[i].uuid === msg.uuid) {
+                targetIdx = i;
                 break;
               }
             }
-            session.history = session.history.slice(0, trimTo);
-            session.messageUUIDs = session.messageUUIDs.slice(0, targetIdx);
-          }
 
-          session.lastRewindUuid = msg.uuid;
+            if (targetIdx >= 0) {
+              var trimTo = session.messageUUIDs[targetIdx].historyIndex;
+              for (var k = trimTo - 1; k >= 0; k--) {
+                if (session.history[k].type === "user_message") {
+                  trimTo = k;
+                  break;
+                }
+              }
+              session.history = session.history.slice(0, trimTo);
+              session.messageUUIDs = session.messageUUIDs.slice(0, targetIdx);
+            }
+
+            session.lastRewindUuid = msg.uuid;
+          }
 
           if (session.abortController) {
             try { session.abortController.abort(); } catch (e) {}
@@ -403,7 +491,7 @@ function createProjectContext(opts) {
 
           sm.saveSessionFile(session);
           sm.switchSession(session.localId);
-          sm.sendAndRecord(session, { type: "rewind_complete" });
+          sm.sendAndRecord(session, { type: "rewind_complete", mode: mode });
           sm.broadcastSessionList();
         } catch (err) {
           send({ type: "rewind_error", text: "Rewind failed: " + err.message });
@@ -482,6 +570,8 @@ function createProjectContext(opts) {
           });
         }
         sendTo(ws, { type: "fs_list_result", path: msg.path || ".", entries: entries });
+        // Auto-watch the directory for changes
+        startDirWatch(msg.path || ".");
       } catch (e) {
         sendTo(ws, { type: "fs_list_result", path: msg.path, entries: [], error: e.message });
       }
@@ -526,6 +616,197 @@ function createProjectContext(opts) {
       return;
     }
 
+    // --- 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;
+      }
+      var absHistPath = path.resolve(cwd, histPath);
+      var entries = [];
+
+      // Collect session edits
+      sm.sessions.forEach(function (session) {
+        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 = execFileSync(
+          "git", ["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's 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;
+    }
+
+    // --- 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;
+      }
+      try {
+        var diff;
+        if (hash2) {
+          diff = execFileSync("git", ["diff", hash, hash2, "--", diffPath],
+            { cwd: cwd, encoding: "utf8", timeout: 5000 });
+        } else {
+          diff = execFileSync("git", ["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;
+    }
+
+    // --- 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;
+      }
+      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 = execFileSync("git", ["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;
+    }
+
     // --- Web terminal ---
     if (msg.type === "term_create") {
       var t = tm.create(msg.cols || 80, msg.rows || 24);
@@ -627,7 +908,21 @@ function createProjectContext(opts) {
   function handleDisconnection(ws) {
     tm.detachAll(ws);
     clients.delete(ws);
-    if (clients.size === 0) stopFileWatch();
+    if (clients.size === 0) {
+      stopFileWatch();
+      stopAllDirWatches();
+      // Abort all running queries when no clients are connected
+      var aborted = 0;
+      sm.sessions.forEach(function (session) {
+        if (session.isProcessing && session.abortController) {
+          try { session.abortController.abort(); } catch (e) {}
+          aborted++;
+        }
+      });
+      if (aborted > 0) {
+        console.log("[project:" + slug + "] No clients connected, aborted " + aborted + " active queries");
+      }
+    }
     broadcastClientCount();
   }
 
@@ -635,8 +930,9 @@ function createProjectContext(opts) {
   function handleHTTP(req, res, urlPath) {
     // Push subscribe
     if (req.method === "POST" && urlPath === "/api/push-subscribe") {
-      parseJsonBody(req).then(function (sub) {
-        if (pushModule) pushModule.addSubscription(sub);
+      parseJsonBody(req).then(function (body) {
+        var sub = body.subscription || body;
+        if (pushModule) pushModule.addSubscription(sub, body.replaceEndpoint);
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end('{"ok":true}');
       }).catch(function () {
@@ -736,6 +1032,7 @@ function createProjectContext(opts) {
   // --- Destroy ---
   function destroy() {
     stopFileWatch();
+    stopAllDirWatches();
     // Abort all active sessions
     sm.sessions.forEach(function (session) {
       if (session.abortController) {
@@ -773,7 +1070,7 @@ function createProjectContext(opts) {
 
   function setTitle(newTitle) {
     title = newTitle || null;
-    send({ type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, projectCount: getProjectCount(), projects: getProjectList() });
+    send({ type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, lanHost: lanHost, projectCount: getProjectCount(), projects: getProjectList() });
   }
 
   return {