clay-server 2.5.0

package/lib/cli-sessions.js

@@ -0,0 +1,270 @@
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var readline = require("readline");
+
+/**
+ * Compute the encoded project directory name used by the Claude CLI.
+ * Replaces all "/" with "-", e.g. "/Users/foo/project" -> "-Users-foo-project"
+ */
+function encodeCwd(cwd) {
+  return cwd.replace(/\//g, "-");
+}
+
+/**
+ * Parse the first ~20 lines of a CLI session JSONL file to extract metadata.
+ * Returns null if the file can't be parsed or has no user messages.
+ */
+function parseSessionFile(filePath, maxLines) {
+  if (maxLines == null) maxLines = 20;
+  return new Promise(function (resolve) {
+    var sessionId = path.basename(filePath, ".jsonl");
+    var result = {
+      sessionId: sessionId,
+      firstPrompt: "",
+      model: null,
+      gitBranch: null,
+      startTime: null,
+      lastActivity: null,
+    };
+
+    var lineCount = 0;
+    var foundUser = false;
+    var stream;
+    try {
+      stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    } catch (e) {
+      return resolve(null);
+    }
+
+    var rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+    rl.on("line", function (line) {
+      lineCount++;
+      if (lineCount > maxLines) {
+        rl.close();
+        stream.destroy();
+        return;
+      }
+
+      var obj;
+      try { obj = JSON.parse(line); } catch (e) { return; }
+
+      // Skip file-history-snapshot, queue-operation, and other non-message records
+      if (obj.type === "user" && obj.message && obj.message.role === "user") {
+        if (!foundUser) {
+          foundUser = true;
+          result.sessionId = obj.sessionId || sessionId;
+          result.gitBranch = obj.gitBranch || null;
+          if (obj.timestamp) result.startTime = obj.timestamp;
+          var content = obj.message.content || "";
+          if (typeof content === "string") {
+            result.firstPrompt = content.substring(0, 100);
+          } else if (Array.isArray(content)) {
+            for (var i = 0; i < content.length; i++) {
+              if (content[i].type === "text" && content[i].text) {
+                result.firstPrompt = content[i].text.substring(0, 100);
+                break;
+              }
+            }
+          }
+        }
+        // Track latest user timestamp for lastActivity
+        if (obj.timestamp) result.lastActivity = obj.timestamp;
+      }
+
+      // Extract model from first assistant message
+      if (!result.model && obj.message && obj.message.role === "assistant" && obj.message.model) {
+        result.model = obj.message.model;
+      }
+    });
+
+    rl.on("close", function () {
+      if (!foundUser) return resolve(null);
+
+      // Use file mtime as fallback for lastActivity, or as a better proxy
+      // since we only read the first ~20 lines
+      try {
+        var stat = fs.statSync(filePath);
+        var mtime = stat.mtime.toISOString();
+        // File mtime is always more accurate for "last activity" since we
+        // don't read the entire file
+        result.lastActivity = mtime;
+      } catch (e) {}
+
+      resolve(result);
+    });
+
+    rl.on("error", function () {
+      resolve(null);
+    });
+
+    stream.on("error", function () {
+      rl.close();
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * List CLI sessions for a given project directory.
+ * Reads ~/.claude/projects/{encoded-cwd}/ and parses JSONL metadata.
+ * Returns array sorted by lastActivity descending (most recent first).
+ */
+function listCliSessions(cwd) {
+  var encoded = encodeCwd(cwd);
+  var projectDir = path.join(os.homedir(), ".claude", "projects", encoded);
+
+  return new Promise(function (resolve) {
+    fs.readdir(projectDir, { withFileTypes: true }, function (err, entries) {
+      if (err) return resolve([]);
+
+      var jsonlFiles = [];
+      for (var i = 0; i < entries.length; i++) {
+        if (entries[i].isFile() && entries[i].name.endsWith(".jsonl")) {
+          jsonlFiles.push(path.join(projectDir, entries[i].name));
+        }
+      }
+
+      if (jsonlFiles.length === 0) return resolve([]);
+
+      var pending = jsonlFiles.length;
+      var results = [];
+
+      for (var j = 0; j < jsonlFiles.length; j++) {
+        parseSessionFile(jsonlFiles[j]).then(function (session) {
+          if (session) results.push(session);
+          pending--;
+          if (pending === 0) {
+            results.sort(function (a, b) {
+              var ta = a.lastActivity || "";
+              var tb = b.lastActivity || "";
+              return ta < tb ? 1 : ta > tb ? -1 : 0;
+            });
+            resolve(results);
+          }
+        });
+      }
+    });
+  });
+}
+
+/**
+ * Get the most recent CLI session for a given project directory.
+ * Returns the session object or null if none found.
+ */
+function getMostRecentCliSession(cwd) {
+  return listCliSessions(cwd).then(function (sessions) {
+    return sessions.length > 0 ? sessions[0] : null;
+  });
+}
+
+/**
+ * Extract user message text from a CLI JSONL content field.
+ * Content can be a string or an array of content blocks.
+ */
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  var parts = [];
+  for (var i = 0; i < content.length; i++) {
+    if (content[i].type === "text" && content[i].text) {
+      parts.push(content[i].text);
+    }
+  }
+  return parts.join("");
+}
+
+/**
+ * Read a full CLI session JSONL file and convert it to relay-compatible
+ * history entries (user_message, delta, tool_start, tool_executing, tool_result).
+ * Returns a Promise that resolves to an array of history entries.
+ */
+function readCliSessionHistory(cwd, sessionId) {
+  var encoded = encodeCwd(cwd);
+  var filePath = path.join(os.homedir(), ".claude", "projects", encoded, sessionId + ".jsonl");
+
+  return new Promise(function (resolve) {
+    var history = [];
+    var stream;
+    try {
+      stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    } catch (e) {
+      return resolve([]);
+    }
+
+    var rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    var toolCounter = 0;
+
+    rl.on("line", function (line) {
+      var obj;
+      try { obj = JSON.parse(line); } catch (e) { return; }
+
+      if (!obj.message) return;
+
+      // User prompt
+      if (obj.type === "user" && obj.message.role === "user") {
+        // Skip tool_result records (they have type "user" but content is tool results)
+        var content = obj.message.content;
+        if (Array.isArray(content) && content.length > 0 && content[0].type === "tool_result") {
+          return;
+        }
+        var text = extractText(content);
+        if (text) {
+          history.push({ type: "user_message", text: text });
+        }
+        return;
+      }
+
+      // Assistant message
+      if (obj.message.role === "assistant" && Array.isArray(obj.message.content)) {
+        for (var i = 0; i < obj.message.content.length; i++) {
+          var block = obj.message.content[i];
+
+          if (block.type === "text" && block.text) {
+            history.push({ type: "delta", text: block.text });
+          }
+
+          if (block.type === "tool_use") {
+            var toolId = "cli-tool-" + (++toolCounter);
+            var toolName = block.name || "Tool";
+            history.push({ type: "tool_start", id: toolId, name: toolName });
+            history.push({
+              type: "tool_executing",
+              id: toolId,
+              name: toolName,
+              input: block.input || {},
+            });
+            // Emit ask_user_answered so the client re-enables input after replaying AskUserQuestion
+            if (toolName === "AskUserQuestion") {
+              history.push({ type: "ask_user_answered", toolId: toolId });
+            }
+            history.push({ type: "tool_result", id: toolId, content: "" });
+          }
+        }
+      }
+    });
+
+    rl.on("close", function () {
+      resolve(history);
+    });
+
+    rl.on("error", function () {
+      resolve([]);
+    });
+
+    stream.on("error", function () {
+      rl.close();
+      resolve([]);
+    });
+  });
+}
+
+module.exports = {
+  listCliSessions: listCliSessions,
+  getMostRecentCliSession: getMostRecentCliSession,
+  readCliSessionHistory: readCliSessionHistory,
+  parseSessionFile: parseSessionFile,
+  encodeCwd: encodeCwd,
+  extractText: extractText,
+};

package/lib/config.js

@@ -0,0 +1,237 @@
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var net = require("net");
+
+// v3: ~/.clay/  (v2 was ~/.claude-relay/, v1 was {cwd}/.claude-relay/)
+var CLAY_HOME = process.env.CLAY_HOME || path.join(os.homedir(), ".clay");
+var LEGACY_HOME = path.join(os.homedir(), ".claude-relay");
+
+// Auto-migrate v2 -> v3: rename ~/.claude-relay/ to ~/.clay/ (once, before anything reads)
+if (!fs.existsSync(CLAY_HOME) && fs.existsSync(LEGACY_HOME)) {
+  try {
+    fs.renameSync(LEGACY_HOME, CLAY_HOME);
+    console.log("[config] Migrated " + LEGACY_HOME + " → " + CLAY_HOME);
+  } catch (e) {
+    // rename failed (cross-device?), fall through — individual files will be read from old path
+    console.error("[config] Migration rename failed:", e.message);
+  }
+}
+
+var CONFIG_DIR = CLAY_HOME;
+var CLAYRC_PATH = path.join(os.homedir(), ".clayrc");
+var CRASH_INFO_PATH = path.join(CONFIG_DIR, "crash.json");
+
+function configPath() {
+  return path.join(CONFIG_DIR, "daemon.json");
+}
+
+function socketPath() {
+  if (process.platform === "win32") {
+    var pipeName = process.env.CLAY_HOME ? "clay-dev-daemon" : "clay-daemon";
+    return "\\\\.\\pipe\\" + pipeName;
+  }
+  return path.join(CONFIG_DIR, "daemon.sock");
+}
+
+function logPath() {
+  return path.join(CONFIG_DIR, "daemon.log");
+}
+
+function ensureConfigDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+function loadConfig() {
+  try {
+    var data = fs.readFileSync(configPath(), "utf8");
+    return JSON.parse(data);
+  } catch (e) {
+    return null;
+  }
+}
+
+function saveConfig(config) {
+  ensureConfigDir();
+  var tmpPath = configPath() + ".tmp";
+  fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2));
+  fs.renameSync(tmpPath, configPath());
+}
+
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function isDaemonAlive(config) {
+  if (!config || !config.pid) return false;
+  if (!isPidAlive(config.pid)) return false;
+  // Named pipes on Windows can't be stat'd, just check PID
+  if (process.platform === "win32") return true;
+  try {
+    fs.statSync(socketPath());
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function isDaemonAliveAsync(config) {
+  return new Promise(function (resolve) {
+    if (!config || !config.pid) return resolve(false);
+    if (!isPidAlive(config.pid)) return resolve(false);
+
+    var sock = socketPath();
+    var client = net.connect(sock);
+    var timer = setTimeout(function () {
+      client.destroy();
+      resolve(false);
+    }, 1000);
+
+    client.on("connect", function () {
+      clearTimeout(timer);
+      client.destroy();
+      resolve(true);
+    });
+    client.on("error", function () {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+
+function generateSlug(projectPath, existingSlugs) {
+  var base = path.basename(projectPath).toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (!base) base = "project";
+  if (!existingSlugs || existingSlugs.indexOf(base) === -1) return base;
+  for (var i = 2; i < 100; i++) {
+    var candidate = base + "-" + i;
+    if (existingSlugs.indexOf(candidate) === -1) return candidate;
+  }
+  return base + "-" + Date.now();
+}
+
+function clearStaleConfig() {
+  try { fs.unlinkSync(configPath()); } catch (e) {}
+  if (process.platform !== "win32") {
+    try { fs.unlinkSync(socketPath()); } catch (e) {}
+  }
+}
+
+// --- Crash info ---
+
+function crashInfoPath() {
+  return CRASH_INFO_PATH;
+}
+
+function writeCrashInfo(info) {
+  try {
+    ensureConfigDir();
+    fs.writeFileSync(CRASH_INFO_PATH, JSON.stringify(info));
+  } catch (e) {}
+}
+
+function readCrashInfo() {
+  try {
+    var data = fs.readFileSync(CRASH_INFO_PATH, "utf8");
+    return JSON.parse(data);
+  } catch (e) {
+    return null;
+  }
+}
+
+function clearCrashInfo() {
+  try { fs.unlinkSync(CRASH_INFO_PATH); } catch (e) {}
+}
+
+// --- ~/.clayrc (recent projects persistence) ---
+
+function clayrcPath() {
+  return CLAYRC_PATH;
+}
+
+function loadClayrc() {
+  try {
+    var data = fs.readFileSync(CLAYRC_PATH, "utf8");
+    return JSON.parse(data);
+  } catch (e) {
+    return { recentProjects: [] };
+  }
+}
+
+function saveClayrc(rc) {
+  var tmpPath = CLAYRC_PATH + ".tmp";
+  fs.writeFileSync(tmpPath, JSON.stringify(rc, null, 2) + "\n");
+  fs.renameSync(tmpPath, CLAYRC_PATH);
+}
+
+/**
+ * Update ~/.clayrc with the current project list from daemon config.
+ * Merges with existing entries (preserves addedAt, updates lastUsed).
+ */
+function syncClayrc(projects) {
+  var rc = loadClayrc();
+  var existing = rc.recentProjects || [];
+
+  // Build a map by path for quick lookup
+  var byPath = {};
+  for (var i = 0; i < existing.length; i++) {
+    byPath[existing[i].path] = existing[i];
+  }
+
+  // Update/add current projects
+  for (var j = 0; j < projects.length; j++) {
+    var p = projects[j];
+    if (byPath[p.path]) {
+      // Update existing entry
+      byPath[p.path].slug = p.slug;
+      byPath[p.path].lastUsed = Date.now();
+      if (p.title) byPath[p.path].title = p.title;
+      else delete byPath[p.path].title;
+    } else {
+      // New entry
+      byPath[p.path] = {
+        path: p.path,
+        slug: p.slug,
+        title: p.title || undefined,
+        addedAt: p.addedAt || Date.now(),
+        lastUsed: Date.now(),
+      };
+    }
+  }
+
+  // Rebuild array, sorted by lastUsed descending
+  var all = Object.keys(byPath).map(function (k) { return byPath[k]; });
+  all.sort(function (a, b) { return (b.lastUsed || 0) - (a.lastUsed || 0); });
+
+  // Keep at most 20 recent projects
+  rc.recentProjects = all.slice(0, 20);
+  saveClayrc(rc);
+}
+
+module.exports = {
+  CONFIG_DIR: CONFIG_DIR,
+  configPath: configPath,
+  socketPath: socketPath,
+  logPath: logPath,
+  ensureConfigDir: ensureConfigDir,
+  loadConfig: loadConfig,
+  saveConfig: saveConfig,
+  isPidAlive: isPidAlive,
+  isDaemonAlive: isDaemonAlive,
+  isDaemonAliveAsync: isDaemonAliveAsync,
+  generateSlug: generateSlug,
+  clearStaleConfig: clearStaleConfig,
+  crashInfoPath: crashInfoPath,
+  writeCrashInfo: writeCrashInfo,
+  readCrashInfo: readCrashInfo,
+  clearCrashInfo: clearCrashInfo,
+  clayrcPath: clayrcPath,
+  loadClayrc: loadClayrc,
+  saveClayrc: saveClayrc,
+  syncClayrc: syncClayrc,
+};