claude-code-session-manager 0.10.5 → 0.11.0

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

package/src/main/git.cjs

@@ -0,0 +1,333 @@
+/**
+ * Git IPC handlers — richer status data than the StatusBar-only `app:git-branch`.
+ *
+ * Ported (in spirit) from ClaudeCodeUnleashed's src/main/ipc/git.ts. Built
+ * fresh for our conventions: argv-array spawn (never shell:true), validatePath
+ * gating, zod-validated IPC payloads, 5s timeout ceiling, 5s per-cwd cache.
+ *
+ * Channels:
+ *   git:status      → { branch, ahead, behind, uncommittedCount, files[] } | null
+ *   git:file-status → { [absolutePath]: 'modified' | 'added' | 'deleted' |
+ *                       'renamed' | 'untracked' | 'staged' | 'conflict' }
+ *
+ * "Not a git repo" / spawn errors / timeouts all surface as `null` (status)
+ * or `{}` (file-status) so the renderer can render unconditionally.
+ *
+ * Future readers: this file is for OBSERVATION only. No mutation commands
+ * (commit/push/pull/add) — those belong to a separate, much-more-restricted
+ * surface if they ever land. The whole point of the cache is so the planned
+ * file-tree sidebar can poll cheaply without spawning git for every render.
+ */
+
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+const { schemas } = require('./ipcSchemas.cjs');
+const { validatePath } = require('./config.cjs');
+
+const GIT_TIMEOUT_MS = 5_000;
+const CACHE_TTL_MS = 5_000;
+const MAX_BUFFER = 10 * 1024 * 1024; // 10 MiB — same cap Unleashed uses
+
+// Per-cwd in-memory caches. Keyed by the realpath-validated cwd so symlinks
+// to the same repo dedupe. Each entry: { value, expiresAt }.
+const statusCache = new Map();
+const fileStatusCache = new Map();
+
+/**
+ * Run `git <args>` in cwd with a hard 5s SIGKILL ceiling. Resolves
+ * { ok:true, stdout } on exit 0, { ok:false, code, stderr } otherwise.
+ * Never throws — IPC handlers want a discriminated result, not an exception.
+ *
+ * argv-array spawn — never `shell: true`. cwd MUST already be validatePath-checked.
+ */
+function runGit(args, cwd) {
+  return new Promise((resolve) => {
+    let proc;
+    try {
+      proc = spawn('git', args, {
+        cwd,
+        windowsHide: true,
+        // Inherit env minus anything that could change git behaviour; default
+        // is fine here — we explicitly do NOT want `cleanChildEnv` because
+        // git relies on $HOME/$PATH/$GIT_* to find config + ssh credentials.
+      });
+    } catch (err) {
+      resolve({ ok: false, code: -1, stderr: `spawn failed: ${err?.message ?? String(err)}` });
+      return;
+    }
+
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutLen = 0;
+    let stderrLen = 0;
+    let timedOut = false;
+
+    const killTimer = setTimeout(() => {
+      timedOut = true;
+      try { proc.kill('SIGKILL'); } catch { /* already dead */ }
+    }, GIT_TIMEOUT_MS);
+
+    proc.stdout.on('data', (b) => {
+      if (stdoutLen < MAX_BUFFER) {
+        stdoutChunks.push(b);
+        stdoutLen += b.length;
+      }
+    });
+    proc.stderr.on('data', (b) => {
+      if (stderrLen < MAX_BUFFER) {
+        stderrChunks.push(b);
+        stderrLen += b.length;
+      }
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(killTimer);
+      resolve({ ok: false, code: -1, stderr: `spawn error: ${err?.message ?? String(err)}` });
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(killTimer);
+      const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+      const stderr = Buffer.concat(stderrChunks).toString('utf8');
+      if (timedOut) {
+        resolve({ ok: false, code: -1, stderr: `timeout after ${GIT_TIMEOUT_MS}ms\n${stderr}` });
+        return;
+      }
+      if (code === 0) {
+        resolve({ ok: true, stdout, stderr });
+      } else {
+        resolve({ ok: false, code: typeof code === 'number' ? code : -1, stderr });
+      }
+    });
+  });
+}
+
+/**
+ * Unquote a git path. With porcelain v1 *without* -z, git quotes paths
+ * containing special chars (spaces, unicode, control bytes). We use -z so
+ * paths come through raw NUL-separated, but kept as a defensive shim in
+ * case a future caller drops -z.
+ */
+function unquoteGitPath(p) {
+  if (p.startsWith('"') && p.endsWith('"')) {
+    return p.slice(1, -1)
+      .replace(/\\n/g, '\n')
+      .replace(/\\t/g, '\t')
+      .replace(/\\"/g, '"')
+      .replace(/\\\\/g, '\\');
+  }
+  return p;
+}
+
+/**
+ * Map porcelain XY pair to one of our enum values. Mirrors Unleashed's
+ * git-file-status handler, with the same conflict-detection rules.
+ *
+ *   ' M' → modified           '??' → untracked
+ *   'A ' → added              'AM' → added (index) — staged-then-modified
+ *   ' D' → deleted            'D ' → deleted
+ *   'R ' → renamed            'C ' → added (copy treated as new)
+ *   'U.' / '.U' / 'DD' / 'AA' → conflict
+ *   any other staged change   → staged
+ */
+function mapStatus(indexChar, workChar) {
+  if (indexChar === '?' && workChar === '?') return 'untracked';
+  if (
+    indexChar === 'U' || workChar === 'U' ||
+    (indexChar === 'D' && workChar === 'D') ||
+    (indexChar === 'A' && workChar === 'A')
+  ) return 'conflict';
+  if (indexChar === 'A') return 'added';
+  if (indexChar === 'D' || workChar === 'D') return 'deleted';
+  if (indexChar === 'R') return 'renamed';
+  if (indexChar === 'C') return 'added';
+  if (indexChar !== ' ' && indexChar !== '?') return 'staged';
+  if (workChar === 'M') return 'modified';
+  return 'modified';
+}
+
+/**
+ * Parse `git status --porcelain=v1 -b -u -z` output.
+ *
+ * First entry (when -b is set) is the branch header:
+ *   "## main...origin/main [ahead 1, behind 2]"
+ *   "## HEAD (no branch)" — detached
+ *   "## No commits yet on main"
+ *
+ * Remaining entries are NUL-separated "XY <path>" records. Renamed/copied
+ * records consume TWO entries (new path, then original path).
+ *
+ * Returns { branch, ahead, behind, files }.
+ */
+function parsePorcelain(stdout, cwd) {
+  const entries = stdout.split('\0').filter((e) => e.length > 0);
+  const out = {
+    branch: 'HEAD',
+    ahead: 0,
+    behind: 0,
+    files: [],
+  };
+
+  let i = 0;
+  // Branch header
+  if (entries.length > 0 && entries[0].startsWith('## ')) {
+    const header = entries[0].slice(3);
+    if (header.startsWith('No commits yet on ')) {
+      out.branch = header.slice('No commits yet on '.length).split(' ')[0];
+    } else if (header.startsWith('HEAD (no branch)')) {
+      out.branch = 'HEAD';
+    } else {
+      // "main" or "main...origin/main [ahead 1, behind 2]"
+      const m = /^([^.\s]+)(?:\.\.\.([^\s]+))?(?:\s+\[([^\]]+)\])?/.exec(header);
+      if (m) {
+        out.branch = m[1];
+        const bracket = m[3];
+        if (bracket) {
+          const am = /ahead (\d+)/.exec(bracket);
+          const bm = /behind (\d+)/.exec(bracket);
+          if (am) out.ahead = parseInt(am[1], 10) || 0;
+          if (bm) out.behind = parseInt(bm[1], 10) || 0;
+        }
+      }
+    }
+    i = 1;
+  }
+
+  while (i < entries.length) {
+    const entry = entries[i];
+    if (entry.length < 3) { i++; continue; }
+    const indexChar = entry[0];
+    const workChar = entry[1];
+    // Format with -z: "XY <path>" — note SINGLE space between XY and path.
+    let filePath = entry.substring(3);
+
+    // Renamed/copied → next entry is the original path; skip it.
+    if (indexChar === 'R' || indexChar === 'C') {
+      i++;
+    }
+
+    filePath = unquoteGitPath(filePath);
+    const absolutePath = path.resolve(cwd, filePath);
+    const status = mapStatus(indexChar, workChar);
+
+    out.files.push({
+      path: absolutePath,
+      relativePath: filePath,
+      status,
+      indexStatus: indexChar,
+      workTreeStatus: workChar,
+    });
+
+    i++;
+  }
+
+  return out;
+}
+
+/**
+ * git:status(cwd) — full status. Returns null if not a git repo / git fails.
+ *
+ * Cached per realpath-cwd for 5s so the renderer can poll cheaply (the
+ * planned file-tree sidebar will tick this every couple seconds).
+ */
+async function getStatus(cwd) {
+  let realCwd;
+  try {
+    realCwd = validatePath(cwd);
+  } catch {
+    return null;
+  }
+
+  const now = Date.now();
+  const cached = statusCache.get(realCwd);
+  if (cached && cached.expiresAt > now) return cached.value;
+
+  // Single porcelain call gets us branch + ahead/behind + files in one shot.
+  const result = await runGit(
+    ['status', '--porcelain=v1', '-b', '-u', '-z'],
+    realCwd,
+  );
+
+  if (!result.ok) {
+    // "not a git repository" or any other failure → null
+    statusCache.set(realCwd, { value: null, expiresAt: now + CACHE_TTL_MS });
+    return null;
+  }
+
+  const parsed = parsePorcelain(result.stdout, realCwd);
+  const value = {
+    branch: parsed.branch,
+    ahead: parsed.ahead,
+    behind: parsed.behind,
+    uncommittedCount: parsed.files.length,
+    files: parsed.files,
+  };
+  statusCache.set(realCwd, { value, expiresAt: now + CACHE_TTL_MS });
+  return value;
+}
+
+/**
+ * git:file-status(cwd) — `{ absPath: status }` map. Returns `{}` if not a
+ * git repo / git fails. Same 5s per-cwd cache.
+ */
+async function getFileStatus(cwd) {
+  let realCwd;
+  try {
+    realCwd = validatePath(cwd);
+  } catch {
+    return {};
+  }
+
+  const now = Date.now();
+  const cached = fileStatusCache.get(realCwd);
+  if (cached && cached.expiresAt > now) return cached.value;
+
+  const result = await runGit(
+    ['status', '--porcelain=v1', '-u', '-z'],
+    realCwd,
+  );
+
+  if (!result.ok) {
+    fileStatusCache.set(realCwd, { value: {}, expiresAt: now + CACHE_TTL_MS });
+    return {};
+  }
+
+  // No -b here, so parsePorcelain's branch-header branch will simply not fire.
+  const parsed = parsePorcelain(result.stdout, realCwd);
+  const map = {};
+  for (const f of parsed.files) {
+    map[f.path] = f.status;
+  }
+  fileStatusCache.set(realCwd, { value: map, expiresAt: now + CACHE_TTL_MS });
+  return map;
+}
+
+/** Drop cached entries — useful for tests / forced refresh. Not wired to IPC. */
+function clearCache() {
+  statusCache.clear();
+  fileStatusCache.clear();
+}
+
+function register(ipcMain) {
+  ipcMain.handle('git:status', async (_e, payload) => {
+    const parsed = schemas.gitStatus.safeParse(payload);
+    if (!parsed.success) return null;
+    return getStatus(parsed.data.cwd);
+  });
+
+  ipcMain.handle('git:file-status', async (_e, payload) => {
+    const parsed = schemas.gitFileStatus.safeParse(payload);
+    if (!parsed.success) return {};
+    return getFileStatus(parsed.data.cwd);
+  });
+}
+
+module.exports = {
+  register,
+  // Exposed for unit-test / sanity-check use.
+  getStatus,
+  getFileStatus,
+  parsePorcelain,
+  mapStatus,
+  clearCache,
+};