clay-server 2.5.0

package/lib/sessions.js

@@ -0,0 +1,424 @@
+const fs = require("fs");
+const path = require("path");
+const config = require("./config");
+
+function createSessionManager(opts) {
+  var cwd = opts.cwd;
+  var send = opts.send;          // function(obj) - broadcast to all clients
+  var sendAndRecord = null;      // set after init via setSendAndRecord
+
+  // --- Multi-session state ---
+  var nextLocalId = 1;
+  var sessions = new Map();     // localId -> session object
+  var activeSessionId = null;   // currently active local ID
+  var slashCommands = null;     // shared across sessions
+  var skillNames = null;        // Claude-only skills to filter from slash menu
+
+  // --- Session persistence (centralized in ~/.clay/sessions/{encoded-cwd}/) ---
+  var encodedCwd = cwd.replace(/\//g, "-");
+  var sessionsDir = path.join(config.CONFIG_DIR, "sessions", encodedCwd);
+  fs.mkdirSync(sessionsDir, { recursive: true });
+
+  // Auto-migrate sessions from legacy locations:
+  //   v1: {cwd}/.claude-relay/sessions/
+  //   v2: ~/.claude-relay/sessions/{encoded-cwd}/  (if config.js rename didn't cover it)
+  var legacySessionDirs = [
+    path.join(cwd, ".claude-relay", "sessions"),
+    path.join(require("os").homedir(), ".claude-relay", "sessions", encodedCwd),
+  ];
+  for (var li = 0; li < legacySessionDirs.length; li++) {
+    var oldSessionsDir = legacySessionDirs[li];
+    try {
+      var oldFiles = fs.readdirSync(oldSessionsDir);
+      var migrated = 0;
+      for (var mi = 0; mi < oldFiles.length; mi++) {
+        if (!oldFiles[mi].endsWith(".jsonl")) continue;
+        var oldFilePath = path.join(oldSessionsDir, oldFiles[mi]);
+        var newFilePath = path.join(sessionsDir, oldFiles[mi]);
+        if (fs.existsSync(newFilePath)) continue;
+        try {
+          fs.renameSync(oldFilePath, newFilePath);
+          migrated++;
+        } catch (renameErr) {
+          try {
+            fs.copyFileSync(oldFilePath, newFilePath);
+            fs.unlinkSync(oldFilePath);
+            migrated++;
+          } catch (copyErr) {}
+        }
+      }
+      if (migrated > 0) {
+        console.log("[sessions] Migrated " + migrated + " session(s) from " + oldSessionsDir);
+      }
+      // Clean up old directory if empty
+      try {
+        if (fs.readdirSync(oldSessionsDir).length === 0) {
+          fs.rmdirSync(oldSessionsDir);
+          var parentDir = path.dirname(oldSessionsDir);
+          if (fs.readdirSync(parentDir).length === 0) fs.rmdirSync(parentDir);
+        }
+      } catch (e) {}
+    } catch (e) {
+      // Old directory doesn't exist — that's fine
+    }
+  }
+
+  function sessionFilePath(cliSessionId) {
+    return path.join(sessionsDir, cliSessionId + ".jsonl");
+  }
+
+  function saveSessionFile(session) {
+    if (!session.cliSessionId) return;
+    session.lastActivity = Date.now();
+    try {
+      var metaObj = {
+        type: "meta",
+        localId: session.localId,
+        cliSessionId: session.cliSessionId,
+        title: session.title,
+        createdAt: session.createdAt,
+      };
+      if (session.lastRewindUuid) metaObj.lastRewindUuid = session.lastRewindUuid;
+      var meta = JSON.stringify(metaObj);
+      var lines = [meta];
+      for (var i = 0; i < session.history.length; i++) {
+        lines.push(JSON.stringify(session.history[i]));
+      }
+      fs.writeFileSync(sessionFilePath(session.cliSessionId), lines.join("\n") + "\n");
+    } catch(e) {
+      console.error("[session] Failed to save session file:", e.message);
+    }
+  }
+
+  function appendToSessionFile(session, obj) {
+    if (!session.cliSessionId) return;
+    session.lastActivity = Date.now();
+    try {
+      fs.appendFileSync(sessionFilePath(session.cliSessionId), JSON.stringify(obj) + "\n");
+    } catch(e) {
+      console.error("[session] Failed to append to session file:", e.message);
+    }
+  }
+
+  function loadSessions() {
+    var files;
+    try { files = fs.readdirSync(sessionsDir); } catch { return; }
+
+    var loaded = [];
+    for (var i = 0; i < files.length; i++) {
+      if (!files[i].endsWith(".jsonl")) continue;
+      var content;
+      try { content = fs.readFileSync(path.join(sessionsDir, files[i]), "utf8"); } catch { continue; }
+      var lines = content.trim().split("\n");
+      if (lines.length === 0) continue;
+
+      var meta;
+      try { meta = JSON.parse(lines[0]); } catch { continue; }
+      if (meta.type !== "meta" || !meta.cliSessionId) continue;
+
+      var history = [];
+      for (var j = 1; j < lines.length; j++) {
+        try { history.push(JSON.parse(lines[j])); } catch {}
+      }
+
+      var fileMtime = 0;
+      try { fileMtime = fs.statSync(path.join(sessionsDir, files[i])).mtimeMs; } catch {}
+      loaded.push({ meta: meta, history: history, mtime: fileMtime });
+    }
+
+    loaded.sort(function(a, b) { return a.meta.createdAt - b.meta.createdAt; });
+
+    for (var i = 0; i < loaded.length; i++) {
+      var m = loaded[i].meta;
+      var localId = nextLocalId++;
+      // Reconstruct messageUUIDs from history
+      var messageUUIDs = [];
+      for (var k = 0; k < loaded[i].history.length; k++) {
+        if (loaded[i].history[k].type === "message_uuid") {
+          messageUUIDs.push({ uuid: loaded[i].history[k].uuid, type: loaded[i].history[k].messageType, historyIndex: k });
+        }
+      }
+      var session = {
+        localId: localId,
+        queryInstance: null,
+        messageQueue: null,
+        cliSessionId: m.cliSessionId,
+        blocks: {},
+        sentToolResults: {},
+        pendingPermissions: {},
+        pendingAskUser: {},
+        isProcessing: false,
+        title: m.title || "",
+        createdAt: m.createdAt || Date.now(),
+        lastActivity: loaded[i].mtime || m.createdAt || Date.now(),
+        history: loaded[i].history,
+        messageUUIDs: messageUUIDs,
+        lastRewindUuid: m.lastRewindUuid || null,
+      };
+      sessions.set(localId, session);
+    }
+  }
+
+  // Load persisted sessions from disk
+  loadSessions();
+
+  function getActiveSession() {
+    return sessions.get(activeSessionId) || null;
+  }
+
+  function broadcastSessionList() {
+    send({
+      type: "session_list",
+      sessions: [...sessions.values()].map(function(s) {
+        return {
+          id: s.localId,
+          cliSessionId: s.cliSessionId || null,
+          title: s.title || "New Session",
+          active: s.localId === activeSessionId,
+          isProcessing: s.isProcessing,
+          lastActivity: s.lastActivity || s.createdAt || 0,
+        };
+      }),
+    });
+  }
+
+  function createSession() {
+    var localId = nextLocalId++;
+    var session = {
+      localId: localId,
+      queryInstance: null,
+      messageQueue: null,
+      cliSessionId: null,
+      blocks: {},
+      sentToolResults: {},
+      pendingPermissions: {},
+      pendingAskUser: {},
+      allowedTools: {},
+      isProcessing: false,
+      title: "",
+      createdAt: Date.now(),
+      lastActivity: Date.now(),
+      history: [],
+      messageUUIDs: [],
+    };
+    sessions.set(localId, session);
+    switchSession(localId);
+    return session;
+  }
+
+  var HISTORY_PAGE_SIZE = 200;
+
+  function findTurnBoundary(history, targetIndex) {
+    for (var i = targetIndex; i >= 0; i--) {
+      if (history[i].type === "user_message") return i;
+    }
+    return 0;
+  }
+
+  function replayHistory(session, fromIndex) {
+    var total = session.history.length;
+    if (typeof fromIndex !== "number") {
+      if (total <= HISTORY_PAGE_SIZE) {
+        fromIndex = 0;
+      } else {
+        fromIndex = findTurnBoundary(session.history, Math.max(0, total - HISTORY_PAGE_SIZE));
+      }
+    }
+
+    send({ type: "history_meta", total: total, from: fromIndex });
+
+    for (var i = fromIndex; i < total; i++) {
+      send(session.history[i]);
+    }
+
+    // Find the last result message in the full history for accurate context data
+    var lastUsage = null;
+    var lastModelUsage = null;
+    var lastCost = null;
+    for (var j = total - 1; j >= 0; j--) {
+      if (session.history[j].type === "result") {
+        var r = session.history[j];
+        lastUsage = r.usage || null;
+        lastModelUsage = r.modelUsage || null;
+        lastCost = r.cost != null ? r.cost : null;
+        break;
+      }
+    }
+
+    send({ type: "history_done", lastUsage: lastUsage, lastModelUsage: lastModelUsage, lastCost: lastCost });
+  }
+
+  function switchSession(localId) {
+    var session = sessions.get(localId);
+    if (!session) return;
+
+    activeSessionId = localId;
+    send({ type: "session_switched", id: localId, cliSessionId: session.cliSessionId || null });
+    broadcastSessionList();
+    replayHistory(session);
+
+    if (session.isProcessing) {
+      send({ type: "status", status: "processing" });
+    }
+
+    // Re-send any pending permission requests
+    var pendingIds = Object.keys(session.pendingPermissions);
+    for (var i = 0; i < pendingIds.length; i++) {
+      var p = session.pendingPermissions[pendingIds[i]];
+      send({
+        type: "permission_request_pending",
+        requestId: p.requestId,
+        toolName: p.toolName,
+        toolInput: p.toolInput,
+        toolUseId: p.toolUseId,
+        decisionReason: p.decisionReason,
+      });
+    }
+  }
+
+  function deleteSession(localId) {
+    var session = sessions.get(localId);
+    if (!session) return;
+
+    if (session.abortController) {
+      try { session.abortController.abort(); } catch(e) {}
+    }
+    if (session.messageQueue) {
+      try { session.messageQueue.end(); } catch(e) {}
+    }
+
+    if (session.cliSessionId) {
+      try { fs.unlinkSync(sessionFilePath(session.cliSessionId)); } catch(e) {}
+    }
+
+    sessions.delete(localId);
+
+    if (activeSessionId === localId) {
+      var remaining = [...sessions.keys()];
+      if (remaining.length > 0) {
+        switchSession(remaining[remaining.length - 1]);
+      } else {
+        createSession();
+      }
+    } else {
+      broadcastSessionList();
+    }
+  }
+
+  function doSendAndRecord(session, obj) {
+    session.history.push(obj);
+    appendToSessionFile(session, obj);
+    if (session.localId === activeSessionId) {
+      send(obj);
+    }
+  }
+
+  function resumeSession(cliSessionId, opts) {
+    // If a session with this cliSessionId already exists, just switch to it
+    var existing = null;
+    sessions.forEach(function (s) {
+      if (s.cliSessionId === cliSessionId) existing = s;
+    });
+    if (existing) {
+      existing.lastActivity = Date.now();
+      switchSession(existing.localId);
+      return existing;
+    }
+
+    var cliHistory = (opts && opts.history) || [];
+    var title = (opts && opts.title) || "Resumed session";
+    var localId = nextLocalId++;
+    var session = {
+      localId: localId,
+      queryInstance: null,
+      messageQueue: null,
+      cliSessionId: cliSessionId,
+      blocks: {},
+      sentToolResults: {},
+      pendingPermissions: {},
+      pendingAskUser: {},
+      allowedTools: {},
+      isProcessing: false,
+      title: title,
+      createdAt: Date.now(),
+      history: cliHistory,
+      messageUUIDs: [],
+    };
+    sessions.set(localId, session);
+    saveSessionFile(session);
+    switchSession(localId);
+    return session;
+  }
+
+  // --- Spawn initial session only if no persisted sessions ---
+  if (sessions.size === 0) {
+    createSession();
+  } else {
+    // Activate the most recently used session
+    var allSessions = [...sessions.values()];
+    var mostRecent = allSessions[0];
+    for (var i = 1; i < allSessions.length; i++) {
+      if ((allSessions[i].lastActivity || 0) > (mostRecent.lastActivity || 0)) {
+        mostRecent = allSessions[i];
+      }
+    }
+    activeSessionId = mostRecent.localId;
+  }
+
+  function searchSessions(query) {
+    if (!query) return [];
+    var q = query.toLowerCase();
+    var results = [];
+    sessions.forEach(function (session) {
+      var titleMatch = (session.title || "New Session").toLowerCase().indexOf(q) !== -1;
+      var contentMatch = false;
+      for (var i = 0; i < session.history.length; i++) {
+        var entry = session.history[i];
+        if ((entry.type === "delta" || entry.type === "user_message") && entry.text) {
+          if (entry.text.toLowerCase().indexOf(q) !== -1) {
+            contentMatch = true;
+            break;
+          }
+        }
+      }
+      if (titleMatch || contentMatch) {
+        results.push({
+          id: session.localId,
+          cliSessionId: session.cliSessionId || null,
+          title: session.title || "New Session",
+          active: session.localId === activeSessionId,
+          isProcessing: session.isProcessing,
+          lastActivity: session.lastActivity || session.createdAt || 0,
+          matchType: titleMatch && contentMatch ? "both" : titleMatch ? "title" : "content",
+        });
+      }
+    });
+    return results;
+  }
+
+  return {
+    get activeSessionId() { return activeSessionId; },
+    get nextLocalId() { return nextLocalId; },
+    get slashCommands() { return slashCommands; },
+    set slashCommands(v) { slashCommands = v; },
+    get skillNames() { return skillNames; },
+    set skillNames(v) { skillNames = v; },
+    sessions: sessions,
+    sessionsDir: sessionsDir,
+    HISTORY_PAGE_SIZE: HISTORY_PAGE_SIZE,
+    getActiveSession: getActiveSession,
+    createSession: createSession,
+    switchSession: switchSession,
+    deleteSession: deleteSession,
+    resumeSession: resumeSession,
+    broadcastSessionList: broadcastSessionList,
+    saveSessionFile: saveSessionFile,
+    appendToSessionFile: appendToSessionFile,
+    sendAndRecord: doSendAndRecord,
+    findTurnBoundary: findTurnBoundary,
+    replayHistory: replayHistory,
+    searchSessions: searchSessions,
+  };
+}
+
+module.exports = { createSessionManager };

package/lib/terminal-manager.js

@@ -0,0 +1,187 @@
+var { createTerminal } = require("./terminal");
+
+var MAX_TERMINALS = 10;
+var SCROLLBACK_MAX = 50 * 1024; // 50 KB per terminal
+
+/**
+ * Create a terminal manager for a project.
+ * Manages persistent PTY sessions with scrollback buffering.
+ * opts: { cwd, send, sendTo }
+ */
+function createTerminalManager(opts) {
+  var cwd = opts.cwd;
+  var send = opts.send;
+  var sendTo = opts.sendTo;
+
+  var nextId = 1;
+  var terminals = new Map(); // id -> terminal session
+
+  function create(cols, rows) {
+    if (terminals.size >= MAX_TERMINALS) return null;
+
+    var pty = createTerminal(cwd, cols, rows);
+    if (!pty) return null;
+
+    var id = nextId++;
+    var session = {
+      id: id,
+      pty: pty,
+      scrollback: [],
+      scrollbackSize: 0,
+      cols: cols || 80,
+      rows: rows || 24,
+      title: "Terminal " + id,
+      exited: false,
+      exitCode: null,
+      subscribers: new Set(),
+    };
+
+    pty.onData(function (data) {
+      // Buffer scrollback
+      session.scrollback.push(data);
+      session.scrollbackSize += data.length;
+      while (session.scrollbackSize > SCROLLBACK_MAX && session.scrollback.length > 1) {
+        session.scrollbackSize -= session.scrollback[0].length;
+        session.scrollback.shift();
+      }
+
+      // Broadcast to subscribers
+      var msg = JSON.stringify({ type: "term_output", id: id, data: data });
+      for (var ws of session.subscribers) {
+        if (ws.readyState === 1) ws.send(msg);
+      }
+    });
+
+    pty.onExit(function (e) {
+      session.exited = true;
+      session.exitCode = e && e.exitCode != null ? e.exitCode : null;
+      session.pty = null;
+
+      var msg = JSON.stringify({ type: "term_exited", id: id });
+      for (var ws of session.subscribers) {
+        if (ws.readyState === 1) ws.send(msg);
+      }
+
+      // Broadcast updated list
+      send({ type: "term_list", terminals: list() });
+    });
+
+    terminals.set(id, session);
+    return session;
+  }
+
+  function attach(id, ws) {
+    var session = terminals.get(id);
+    if (!session) return false;
+
+    session.subscribers.add(ws);
+
+    // Replay scrollback
+    if (session.scrollback.length > 0) {
+      var replay = session.scrollback.join("");
+      sendTo(ws, { type: "term_output", id: id, data: replay });
+    }
+
+    // If already exited, notify
+    if (session.exited) {
+      sendTo(ws, { type: "term_exited", id: id });
+    }
+
+    return true;
+  }
+
+  function detach(id, ws) {
+    var session = terminals.get(id);
+    if (!session) return;
+    session.subscribers.delete(ws);
+  }
+
+  function detachAll(ws) {
+    for (var session of terminals.values()) {
+      session.subscribers.delete(ws);
+    }
+  }
+
+  function write(id, data) {
+    var session = terminals.get(id);
+    if (session && session.pty) {
+      session.pty.write(data);
+    }
+  }
+
+  function resize(id, cols, rows) {
+    var session = terminals.get(id);
+    if (!session || !session.pty) return;
+    if (cols > 0 && rows > 0) {
+      try {
+        session.pty.resize(cols, rows);
+        session.cols = cols;
+        session.rows = rows;
+      } catch (e) {}
+    }
+  }
+
+  function close(id) {
+    var session = terminals.get(id);
+    if (!session) return;
+
+    if (session.pty) {
+      try { session.pty.kill(); } catch (e) {}
+      session.pty = null;
+    }
+
+    // Notify subscribers
+    var msg = JSON.stringify({ type: "term_closed", id: id });
+    for (var ws of session.subscribers) {
+      if (ws.readyState === 1) ws.send(msg);
+    }
+
+    terminals.delete(id);
+
+    // Reset counter when all terminals are closed
+    if (terminals.size === 0) nextId = 1;
+  }
+
+  function rename(id, title) {
+    var session = terminals.get(id);
+    if (!session) return;
+    session.title = String(title).substring(0, 50);
+  }
+
+  function list() {
+    var result = [];
+    for (var session of terminals.values()) {
+      result.push({
+        id: session.id,
+        title: session.title,
+        exited: session.exited,
+      });
+    }
+    return result;
+  }
+
+  function destroyAll() {
+    for (var session of terminals.values()) {
+      if (session.pty) {
+        try { session.pty.kill(); } catch (e) {}
+        session.pty = null;
+      }
+    }
+    terminals.clear();
+  }
+
+  return {
+    create: create,
+    attach: attach,
+    detach: detach,
+    detachAll: detachAll,
+    write: write,
+    resize: resize,
+    close: close,
+    rename: rename,
+    list: list,
+    destroyAll: destroyAll,
+  };
+}
+
+module.exports = { createTerminalManager: createTerminalManager };

package/lib/terminal.js

@@ -0,0 +1,24 @@
+var pty;
+try {
+  pty = require("@lydell/node-pty");
+} catch (e) {
+  pty = null;
+}
+
+function createTerminal(cwd, cols, rows) {
+  if (!pty) return null;
+
+  var shell = process.env.SHELL
+    || (process.platform === "win32" ? process.env.COMSPEC || "cmd.exe" : "/bin/bash");
+  var term = pty.spawn(shell, [], {
+    name: "xterm-256color",
+    cols: cols || 80,
+    rows: rows || 24,
+    cwd: cwd,
+    env: Object.assign({}, process.env, { TERM: "xterm-256color" }),
+  });
+
+  return term;
+}
+
+module.exports = { createTerminal: createTerminal };

package/lib/themes/ayu-light.json

@@ -0,0 +1,9 @@
+{
+  "name": "Ayu Light",
+  "author": "Ike Ku",
+  "variant": "light",
+  "base00": "FAFAFA", "base01": "EDEFF1", "base02": "D2D4D8", "base03": "A0A6AC",
+  "base04": "8A9199", "base05": "5C6166", "base06": "4E5257", "base07": "404447",
+  "base08": "F07171", "base09": "FA8D3E", "base0A": "F2AE49", "base0B": "6CBF49",
+  "base0C": "4CBF99", "base0D": "399EE6", "base0E": "A37ACC", "base0F": "E6BA7E"
+}

package/lib/themes/catppuccin-latte.json

@@ -0,0 +1,9 @@
+{
+  "name": "Catppuccin Latte",
+  "author": "catppuccin",
+  "variant": "light",
+  "base00": "eff1f5", "base01": "e6e9ef", "base02": "ccd0da", "base03": "9ca0b0",
+  "base04": "8c8fa1", "base05": "5c5f77", "base06": "4c4f69", "base07": "303446",
+  "base08": "d20f39", "base09": "fe640b", "base0A": "df8e1d", "base0B": "40a02b",
+  "base0C": "179299", "base0D": "1e66f5", "base0E": "8839ef", "base0F": "dd7878"
+}

package/lib/themes/catppuccin-mocha.json

@@ -0,0 +1,9 @@
+{
+  "name": "Catppuccin Mocha",
+  "author": "catppuccin",
+  "variant": "dark",
+  "base00": "1e1e2e", "base01": "181825", "base02": "313244", "base03": "45475a",
+  "base04": "585b70", "base05": "cdd6f4", "base06": "f5e0dc", "base07": "b4befe",
+  "base08": "f38ba8", "base09": "fab387", "base0A": "f9e2af", "base0B": "a6e3a1",
+  "base0C": "94e2d5", "base0D": "89b4fa", "base0E": "cba6f7", "base0F": "f2cdcd"
+}

package/lib/themes/clay-light.json

@@ -0,0 +1,10 @@
+{
+  "name": "Clay Light",
+  "author": "Clay",
+  "variant": "light",
+  "base00": "F3EBE7", "base01": "EBE1DC", "base02": "D8CCC6", "base03": "A09590",
+  "base04": "786D67", "base05": "504541", "base06": "332925", "base07": "1A1412",
+  "base08": "C83520", "base09": "F74728", "base0A": "C08520", "base0B": "008F6B",
+  "base0C": "1C8575", "base0D": "3560B0", "base0E": "8C4E8E", "base0F": "A57C45",
+  "accent2": "2A26E5"
+}

package/lib/themes/clay.json

@@ -0,0 +1,10 @@
+{
+  "name": "Clay Dark",
+  "author": "Clay",
+  "variant": "dark",
+  "base00": "1F1B1B", "base01": "2A2525", "base02": "352F2F", "base03": "7D7370",
+  "base04": "A09590", "base05": "C2BAB4", "base06": "E5DED8", "base07": "FFFFFF",
+  "base08": "F74728", "base09": "FE7150", "base0A": "E5A040", "base0B": "09E5A3",
+  "base0C": "4EC9B0", "base0D": "6BA0E5", "base0E": "D085CC", "base0F": "D09558",
+  "accent2": "5857FC"
+}

package/lib/themes/dracula.json

@@ -0,0 +1,9 @@
+{
+  "name": "Dracula",
+  "author": "Jamy Golden",
+  "variant": "dark",
+  "base00": "282a36", "base01": "363447", "base02": "44475a", "base03": "6272a4",
+  "base04": "9ea8c7", "base05": "f8f8f2", "base06": "f0f1f4", "base07": "ffffff",
+  "base08": "ff5555", "base09": "ffb86c", "base0A": "f1fa8c", "base0B": "50fa7b",
+  "base0C": "8be9fd", "base0D": "80bfff", "base0E": "ff79c6", "base0F": "bd93f9"
+}