claude-code-session-manager 0.10.5 → 0.11.1

package/src/main/agentMemory.cjs

@@ -0,0 +1,267 @@
+/**
+ * agentMemory.cjs — per-subagent memory backend.
+ *
+ * Distinct from the workspace-scoped Memory tool (memoryTool.cjs): this stores
+ * memory entries keyed by **agentId** (the subagent name, e.g. "code-reviewer"),
+ * not by workspace cwd. Conceptually mirrors Anthropic's "give each subagent its
+ * own scratchpad" pattern.
+ *
+ * Storage: `~/.claude/session-manager/agent-memory/<agentId>.json`
+ *
+ *   {
+ *     "agentId": "code-reviewer",
+ *     "entries": [
+ *       { "id": "mem_<ts>_<rand>", "body": "<markdown>",
+ *         "category": "command|preference|pattern|failure|workflow" (optional),
+ *         "createdAt": <epoch ms>, "updatedAt": <epoch ms> }
+ *     ],
+ *     "lastUpdated": <epoch ms>
+ *   }
+ *
+ * Deviation from Unleashed (which keys by projectPath hash and writes to
+ * `~/.claudecodeui/agent-memory/<hash>.json` with raw fs.writeFile): we key by
+ * agentId per the user's spec, write under `~/.claude/session-manager/` (the
+ * conventional spot for this app's own state), and route every mutation through
+ * config.cjs's writeJson / validatePath helpers.
+ *
+ * Hard caps:
+ *   - agentId must match /^[A-Za-z0-9._-]{1,128}$/
+ *   - entryId must match /^[A-Za-z0-9._-]{1,128}$/
+ *   - body up to 1 MiB
+ *   - up to 200 entries per agent (oldest dropped when over cap on set())
+ */
+
+'use strict';
+
+const { ipcMain } = require('electron');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const config = require('./config.cjs');
+
+const MAX_BODY_BYTES = 1024 * 1024; // 1 MiB
+const MAX_ENTRIES = 200;
+const AGENT_ID_RE = /^[A-Za-z0-9._-]{1,128}$/;
+const ENTRY_ID_RE = /^[A-Za-z0-9._-]{1,128}$/;
+
+function rootDir() {
+  return path.join(os.homedir(), '.claude', 'session-manager', 'agent-memory');
+}
+
+function recordPath(agentId) {
+  if (!AGENT_ID_RE.test(agentId)) {
+    throw new Error(`invalid agentId (must match ${AGENT_ID_RE.source})`);
+  }
+  return path.join(rootDir(), `${agentId}.json`);
+}
+
+async function ensureRoot() {
+  await fsp.mkdir(rootDir(), { recursive: true });
+}
+
+function emptyRecord(agentId) {
+  return { agentId, entries: [], lastUpdated: 0 };
+}
+
+async function loadRecord(agentId) {
+  const abs = recordPath(agentId);
+  const r = await config.readJson(abs).catch(() => ({ exists: false, data: null }));
+  if (!r || !r.exists || !r.data) return emptyRecord(agentId);
+  const data = r.data;
+  if (!data || typeof data !== 'object' || !Array.isArray(data.entries)) {
+    return emptyRecord(agentId);
+  }
+  return {
+    agentId,
+    entries: data.entries.filter(
+      (e) => e && typeof e === 'object' && typeof e.id === 'string' && typeof e.body === 'string'
+    ),
+    lastUpdated: typeof data.lastUpdated === 'number' ? data.lastUpdated : 0,
+  };
+}
+
+async function persist(record) {
+  await ensureRoot();
+  // Cap entry count: drop oldest by updatedAt (or createdAt) ascending.
+  if (record.entries.length > MAX_ENTRIES) {
+    record.entries = record.entries
+      .slice()
+      .sort((a, b) => (b.updatedAt ?? b.createdAt ?? 0) - (a.updatedAt ?? a.createdAt ?? 0))
+      .slice(0, MAX_ENTRIES);
+  }
+  const abs = recordPath(record.agentId);
+  const out = { ...record, lastUpdated: Date.now() };
+  await config.writeJson(abs, out);
+  return out;
+}
+
+// ────────────────────────────────────────────────── handlers
+
+async function list({ agentId }) {
+  if (!AGENT_ID_RE.test(agentId || '')) {
+    return { entries: [], agentId: agentId || '', error: 'invalid agentId' };
+  }
+  try {
+    const record = await loadRecord(agentId);
+    const entries = record.entries
+      .slice()
+      .sort((a, b) => (b.updatedAt ?? b.createdAt ?? 0) - (a.updatedAt ?? a.createdAt ?? 0))
+      .map((e) => ({
+        id: e.id,
+        body: e.body,
+        category: e.category ?? null,
+        createdAt: e.createdAt ?? 0,
+        updatedAt: e.updatedAt ?? e.createdAt ?? 0,
+        bytes: Buffer.byteLength(e.body, 'utf8'),
+      }));
+    return { entries, agentId, error: null };
+  } catch (e) {
+    return { entries: [], agentId, error: e.message };
+  }
+}
+
+async function get({ agentId, entryId }) {
+  if (!AGENT_ID_RE.test(agentId || '') || !ENTRY_ID_RE.test(entryId || '')) {
+    return { entry: null, error: 'invalid id' };
+  }
+  try {
+    const record = await loadRecord(agentId);
+    const entry = record.entries.find((e) => e.id === entryId) ?? null;
+    if (!entry) return { entry: null, error: null };
+    return {
+      entry: {
+        id: entry.id,
+        body: entry.body,
+        category: entry.category ?? null,
+        createdAt: entry.createdAt ?? 0,
+        updatedAt: entry.updatedAt ?? entry.createdAt ?? 0,
+        bytes: Buffer.byteLength(entry.body, 'utf8'),
+      },
+      error: null,
+    };
+  } catch (e) {
+    return { entry: null, error: e.message };
+  }
+}
+
+async function set({ agentId, entryId, body, category }) {
+  if (!AGENT_ID_RE.test(agentId || '')) {
+    return { ok: false, error: 'invalid agentId' };
+  }
+  if (!ENTRY_ID_RE.test(entryId || '')) {
+    return { ok: false, error: 'invalid entryId' };
+  }
+  if (typeof body !== 'string') {
+    return { ok: false, error: 'body must be a string' };
+  }
+  const bytes = Buffer.byteLength(body, 'utf8');
+  if (bytes > MAX_BODY_BYTES) {
+    return { ok: false, error: `body exceeds 1 MiB cap (${bytes} bytes)` };
+  }
+  try {
+    const record = await loadRecord(agentId);
+    const now = Date.now();
+    const idx = record.entries.findIndex((e) => e.id === entryId);
+    if (idx >= 0) {
+      // Update — preserve createdAt
+      record.entries[idx] = {
+        ...record.entries[idx],
+        id: entryId,
+        body,
+        category: category ?? record.entries[idx].category ?? null,
+        updatedAt: now,
+      };
+    } else {
+      // Enforce cap on create
+      if (record.entries.length >= MAX_ENTRIES) {
+        return { ok: false, error: `agent at ${MAX_ENTRIES}-entry cap` };
+      }
+      record.entries.push({
+        id: entryId,
+        body,
+        category: category ?? null,
+        createdAt: now,
+        updatedAt: now,
+      });
+    }
+    await persist(record);
+    return { ok: true, error: null };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function deleteEntry({ agentId, entryId }) {
+  if (!AGENT_ID_RE.test(agentId || '') || !ENTRY_ID_RE.test(entryId || '')) {
+    return { ok: false, error: 'invalid id' };
+  }
+  try {
+    const record = await loadRecord(agentId);
+    const before = record.entries.length;
+    record.entries = record.entries.filter((e) => e.id !== entryId);
+    if (record.entries.length === before) {
+      // No-op delete (entry didn't exist) — treat as success, same as fs unlink ENOENT.
+      return { ok: true, error: null };
+    }
+    // If we just emptied the record, remove the file outright so listProjects()
+    // doesn't report a stale ghost agent.
+    if (record.entries.length === 0) {
+      const abs = recordPath(agentId);
+      let real;
+      try {
+        real = config.validatePath(abs);
+        config.validateWrite(real);
+        await fsp.unlink(real);
+      } catch (e) {
+        if (e.code !== 'ENOENT') {
+          // Fall back to persisting an empty record; better than throwing.
+          await persist(record);
+        }
+      }
+      return { ok: true, error: null };
+    }
+    await persist(record);
+    return { ok: true, error: null };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function listAgents() {
+  try {
+    await ensureRoot();
+    const dir = rootDir();
+    const r = await config.listDir(dir, { filesOnly: true });
+    if (!r.ok) return { agents: [], error: r.error };
+    const agents = r.entries
+      .filter((e) => e.name.endsWith('.json'))
+      .map((e) => ({
+        agentId: e.name.replace(/\.json$/, ''),
+        bytes: e.size,
+        mtimeMs: e.mtimeMs,
+      }))
+      .sort((a, b) => a.agentId.localeCompare(b.agentId));
+    return { agents, error: null };
+  } catch (e) {
+    return { agents: [], error: e.message };
+  }
+}
+
+function registerAgentMemoryHandlers() {
+  const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
+  ipcMain.handle('agent-memory:list', v(s.agentMemoryList, list));
+  ipcMain.handle('agent-memory:get', v(s.agentMemoryGet, get));
+  ipcMain.handle('agent-memory:set', v(s.agentMemorySet, set));
+  ipcMain.handle('agent-memory:delete', v(s.agentMemoryDelete, deleteEntry));
+  ipcMain.handle('agent-memory:list-agents', () => listAgents());
+}
+
+module.exports = {
+  registerAgentMemoryHandlers,
+  // exported for tests
+  rootDir,
+  recordPath,
+  AGENT_ID_RE,
+  ENTRY_ID_RE,
+};

package/src/main/files.cjs

@@ -0,0 +1,346 @@
+/**
+ * Files IPC — file-tree-sidebar backend.
+ *
+ * Mirrors Unleashed's files IPC but routes every path through config.cjs's
+ * `validatePath` (allowedRoots = home dir), and uses `shell.trashItem` for
+ * delete so renames/deletes are recoverable from the OS trash.
+ *
+ * Notes:
+ *   - Reads are constrained to anywhere inside the home dir.
+ *   - Writes (create/rename/delete) likewise stay inside home but additionally
+ *     reject anything that would land on `.credentials.json`.
+ *   - All listings sort directories first, then alphabetically.
+ *   - The renderer is expected to pass absolute paths only. Tilde is expanded.
+ */
+
+const { ipcMain, shell } = require('electron');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+
+const { z } = require('zod');
+
+function expandHome(p) {
+  if (!p) return p;
+  if (p === '~') return os.homedir();
+  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+/**
+ * Resolve to realpath; on ENOENT resolve the parent then re-append basename so
+ * we can still validate create destinations. Mirrors config.cjs.
+ */
+function realResolve(abs) {
+  const lex = path.resolve(expandHome(abs));
+  try {
+    return fs.realpathSync(lex);
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      const parent = path.dirname(lex);
+      try {
+        return path.join(fs.realpathSync(parent), path.basename(lex));
+      } catch {
+        return lex;
+      }
+    }
+    throw e;
+  }
+}
+
+const HOME = os.homedir();
+
+/**
+ * Validates that the path is under the home directory. Returns the realpath
+ * or throws. Files IPC is intentionally home-scoped — broader than
+ * config.cjs's write boundaries, since the user may browse any project under
+ * ~ — but never escapes the home tree.
+ */
+function validateHomePath(abs) {
+  const real = realResolve(abs);
+  let realHome;
+  try { realHome = fs.realpathSync(HOME); } catch { realHome = HOME; }
+  if (real === realHome || real.startsWith(realHome + path.sep)) return real;
+  throw new Error(`Path outside home directory: ${real}`);
+}
+
+/** Reject .credentials.json writes regardless of where they sit. */
+function rejectCredentials(real) {
+  if (path.basename(real) === '.credentials.json') {
+    throw new Error('Write to .credentials.json denied');
+  }
+}
+
+// Invalid characters for file/folder names (cross-platform).
+const INVALID_NAME_CHARS = /[<>:"/\\|?*\x00-\x1f]/;
+const RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
+
+function validateName(name) {
+  if (!name || name.trim().length === 0) return 'Name cannot be empty';
+  if (name !== name.trim()) return 'Name cannot start or end with whitespace';
+  if (name === '.' || name === '..') return 'Name cannot be "." or ".."';
+  if (INVALID_NAME_CHARS.test(name)) return 'Name contains invalid characters';
+  if (RESERVED_NAMES.test(name.split('.')[0])) return 'Name is a reserved system name';
+  if (name.length > 255) return 'Name is too long (max 255 characters)';
+  return null;
+}
+
+async function listDir(dirPath, showHidden) {
+  let resolved;
+  try { resolved = validateHomePath(dirPath); }
+  catch (e) { return { ok: false, entries: [], error: e.message }; }
+
+  try {
+    const entries = await fsp.readdir(resolved, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      if (!showHidden && entry.name.startsWith('.')) continue;
+      const full = path.join(resolved, entry.name);
+      let size = 0;
+      let mtimeMs = 0;
+      try {
+        const st = await fsp.stat(full);
+        size = st.size;
+        mtimeMs = st.mtimeMs;
+      } catch { /* skip unreadable */ continue; }
+      out.push({
+        name: entry.name,
+        path: full,
+        isDirectory: entry.isDirectory(),
+        isFile: entry.isFile(),
+        size,
+        mtimeMs,
+      });
+    }
+    out.sort((a, b) => {
+      if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return { ok: true, entries: out, error: null };
+  } catch (e) {
+    return { ok: false, entries: [], error: e.message };
+  }
+}
+
+async function readFile(filePath) {
+  let resolved;
+  try { resolved = validateHomePath(filePath); }
+  catch (e) { return { ok: false, text: '', error: e.message, size: 0 }; }
+
+  try {
+    const st = await fsp.stat(resolved);
+    if (st.isDirectory()) return { ok: false, text: '', error: 'Path is a directory', size: 0 };
+    // 5 MB cap — preview pane shouldn't try to load huge logs.
+    if (st.size > 5 * 1024 * 1024) {
+      return { ok: false, text: '', error: 'File too large to preview (> 5 MB)', size: st.size };
+    }
+    const text = await fsp.readFile(resolved, 'utf8');
+    return { ok: true, text, error: null, size: st.size };
+  } catch (e) {
+    return { ok: false, text: '', error: e.message, size: 0 };
+  }
+}
+
+async function writeFile(filePath, content) {
+  let resolved;
+  try {
+    resolved = validateHomePath(filePath);
+    rejectCredentials(resolved);
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+  try {
+    const dir = path.dirname(resolved);
+    await fsp.mkdir(dir, { recursive: true });
+    const tmp = `${resolved}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await fsp.writeFile(tmp, content, 'utf8');
+    await fsp.rename(tmp, resolved);
+    return { ok: true, error: null };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function createEntry(parentPath, name, kind) {
+  const nameError = validateName(name);
+  if (nameError) return { ok: false, error: nameError };
+
+  let parent;
+  try { parent = validateHomePath(parentPath); }
+  catch (e) { return { ok: false, error: e.message }; }
+
+  const target = path.join(parent, name);
+  // Re-validate target — name passed validateName but join could still
+  // produce something outside parent (defense in depth).
+  try { validateHomePath(target); }
+  catch (e) { return { ok: false, error: e.message }; }
+  try { rejectCredentials(target); }
+  catch (e) { return { ok: false, error: e.message }; }
+
+  try {
+    const parentStat = await fsp.stat(parent);
+    if (!parentStat.isDirectory()) {
+      return { ok: false, error: 'Parent path is not a directory' };
+    }
+    try {
+      await fsp.access(target);
+      return { ok: false, error: 'A file or folder with that name already exists' };
+    } catch { /* expected — doesn't exist */ }
+
+    if (kind === 'folder') {
+      await fsp.mkdir(target, { recursive: false });
+    } else {
+      // 'wx' is exclusive — fails if it races with another writer.
+      await fsp.writeFile(target, '', { encoding: 'utf8', flag: 'wx' });
+    }
+    return { ok: true, path: target, error: null };
+  } catch (e) {
+    if (e.code === 'EEXIST') return { ok: false, error: 'A file or folder with that name already exists' };
+    return { ok: false, error: e.message };
+  }
+}
+
+async function renameEntry(oldPath, newName) {
+  const nameError = validateName(newName);
+  if (nameError) return { ok: false, error: nameError };
+
+  let resolvedOld;
+  try { resolvedOld = validateHomePath(oldPath); }
+  catch (e) { return { ok: false, error: e.message }; }
+
+  const newPath = path.join(path.dirname(resolvedOld), newName);
+  try { validateHomePath(newPath); }
+  catch (e) { return { ok: false, error: e.message }; }
+  try { rejectCredentials(newPath); }
+  catch (e) { return { ok: false, error: e.message }; }
+
+  try {
+    await fsp.access(resolvedOld);
+    try {
+      await fsp.access(newPath);
+      return { ok: false, error: 'A file or folder with that name already exists' };
+    } catch { /* good */ }
+    await fsp.rename(resolvedOld, newPath);
+    return { ok: true, newPath, error: null };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+const CRITICAL_PATHS = new Set([HOME, '/', '/usr', '/bin', '/etc', '/var', '/System', '/Applications']);
+
+async function deleteEntry(filePath) {
+  let resolved;
+  try { resolved = validateHomePath(filePath); }
+  catch (e) { return { ok: false, error: e.message }; }
+
+  if (CRITICAL_PATHS.has(resolved)) {
+    return { ok: false, error: 'Cannot delete system-critical paths' };
+  }
+  try { rejectCredentials(resolved); }
+  catch (e) { return { ok: false, error: e.message }; }
+
+  try {
+    // Prefer trash so deletes are recoverable. Fall back to hard delete only
+    // if the platform doesn't support it (very old Linux desktops).
+    try {
+      await shell.trashItem(resolved);
+      return { ok: true, error: null };
+    } catch {
+      const st = await fsp.lstat(resolved);
+      if (st.isDirectory() && !st.isSymbolicLink()) {
+        await fsp.rm(resolved, { recursive: true });
+      } else {
+        await fsp.unlink(resolved);
+      }
+      return { ok: true, error: null };
+    }
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function openExternal(filePath) {
+  let resolved;
+  try { resolved = validateHomePath(filePath); }
+  catch (e) { return { ok: false, error: e.message }; }
+  try {
+    await fsp.access(resolved);
+    const err = await shell.openPath(resolved);
+    if (err) return { ok: false, error: err };
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function showInFinder(filePath) {
+  let resolved;
+  try { resolved = validateHomePath(filePath); }
+  catch (e) { return { ok: false, error: e.message }; }
+  try {
+    await fsp.access(resolved);
+    shell.showItemInFolder(resolved);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+// ──────────────────────────────────────────── schemas
+const filesPath = z.object({ path: z.string().min(1).max(4096) });
+const filesList = z.object({ path: z.string().min(1).max(4096), showHidden: z.boolean().optional() });
+const filesWrite = z.object({ path: z.string().min(1).max(4096), content: z.string() });
+const filesCreate = z.object({
+  parentPath: z.string().min(1).max(4096),
+  name: z.string().min(1).max(255),
+  kind: z.enum(['file', 'folder']),
+});
+const filesRename = z.object({ path: z.string().min(1).max(4096), newName: z.string().min(1).max(255) });
+
+function registerFilesHandlers() {
+  ipcMain.handle('files:list', (_e, payload) => {
+    const { path: p, showHidden } = filesList.parse(payload);
+    return listDir(p, !!showHidden);
+  });
+  ipcMain.handle('files:read', (_e, payload) => {
+    const { path: p } = filesPath.parse(payload);
+    return readFile(p);
+  });
+  ipcMain.handle('files:write', (_e, payload) => {
+    const { path: p, content } = filesWrite.parse(payload);
+    return writeFile(p, content);
+  });
+  ipcMain.handle('files:create', (_e, payload) => {
+    const { parentPath, name, kind } = filesCreate.parse(payload);
+    return createEntry(parentPath, name, kind);
+  });
+  ipcMain.handle('files:rename', (_e, payload) => {
+    const { path: p, newName } = filesRename.parse(payload);
+    return renameEntry(p, newName);
+  });
+  ipcMain.handle('files:delete', (_e, payload) => {
+    const { path: p } = filesPath.parse(payload);
+    return deleteEntry(p);
+  });
+  ipcMain.handle('files:open-external', (_e, payload) => {
+    const { path: p } = filesPath.parse(payload);
+    return openExternal(p);
+  });
+  ipcMain.handle('files:show-in-finder', (_e, payload) => {
+    const { path: p } = filesPath.parse(payload);
+    return showInFinder(p);
+  });
+}
+
+module.exports = {
+  registerFilesHandlers,
+  // exported for tests
+  listDir,
+  readFile,
+  writeFile,
+  createEntry,
+  renameEntry,
+  deleteEntry,
+};