@bakapiano/ccsm 0.1.0

package/lib/launcher.js

@@ -0,0 +1,219 @@
+'use strict';
+
+const { spawn, exec } = require('node:child_process');
+const path = require('node:path');
+const fs = require('node:fs');
+
+// Terminal kinds we know how to open a new window for. Each entry has:
+//   processName  — what shows up in tasklist, used by focus.js to find the
+//                  newly-created window via HWND diff.
+//   spawn(opts)  — returns { spawned: ChildProcess, args: string[] }.
+//
+// All variants take { cwd, command, args, title, commandShell } and open a
+// new on-screen window with `command args...` running in `cwd`. `commandShell`
+// only matters for the wt kind — see comment there.
+const TERMINAL_KINDS = {
+  wt: {
+    processName: 'WindowsTerminal.exe',
+    spawn({ cwd, command, args, title, commandShell }) {
+      // `-w new` forces a new wt window. Without it, recent wt versions
+      // honor the user's "windowingBehavior" setting and may fold the
+      // invocation into an existing window as a tab — which breaks the
+      // "one window per session" promise and the auto-focus HWND diff.
+      const wtArgs = ['-w', 'new'];
+      if (title) wtArgs.push('--title', title);
+      wtArgs.push('-d', cwd);
+      if (command) {
+        // wt by default runs the command via CreateProcess (no shell), so a
+        // PowerShell alias / function / profile-defined name like "ccp" can't
+        // be found. Wrapping in pwsh/powershell loads $PROFILE and resolves
+        // those names. commandShell="none" reverts to direct invocation for
+        // anyone who wants raw exe semantics.
+        //
+        // We use -EncodedCommand (base64 UTF-16LE) instead of -Command because
+        // wt's CLI parser treats `;` as a sub-command separator at any nesting
+        // depth — a `;` inside our -Command string would make wt try to launch
+        // whatever follows as a brand-new wt sub-command. Base64 has no `;`.
+        if (commandShell === 'pwsh' || commandShell === 'powershell') {
+          const shellExe = commandShell === 'powershell' ? 'powershell.exe' : 'pwsh.exe';
+          wtArgs.push(
+            shellExe,
+            '-NoExit', '-NoLogo',
+            '-EncodedCommand', buildPwshEncodedCommand({ cwd, command, args })
+          );
+        } else {
+          wtArgs.push(command, ...args);
+        }
+      }
+      const spawned = spawn('wt.exe', wtArgs, {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: false,
+      });
+      spawned.unref();
+      return { spawned, args: wtArgs };
+    },
+  },
+  powershell: {
+    processName: 'powershell.exe',
+    spawn(opts) {
+      return spawnViaCmdStart('powershell.exe', opts);
+    },
+  },
+  pwsh: {
+    processName: 'pwsh.exe',
+    spawn(opts) {
+      return spawnViaCmdStart('pwsh.exe', opts);
+    },
+  },
+  cmd: {
+    processName: 'cmd.exe',
+    spawn({ cwd, command, args, title }) {
+      // cmd /K runs a command and stays open. We use `start` to create a new
+      // window. The empty "" is the new window's title slot.
+      const inner = command
+        ? [command, ...args].map(quoteForCmd).join(' ')
+        : '';
+      const cmdLine = inner ? `/K ${inner}` : '/K';
+      const spawned = spawn(
+        'cmd.exe',
+        ['/c', 'start', title || '', '/D', cwd, 'cmd.exe', cmdLine],
+        { detached: true, stdio: 'ignore', windowsHide: false }
+      );
+      spawned.unref();
+      return { spawned, args: ['/c', 'start', title || '', '/D', cwd, 'cmd.exe', cmdLine] };
+    },
+  },
+};
+
+function quoteForCmd(s) {
+  if (s == null) return '';
+  const str = String(s);
+  if (/[\s"&|<>^]/.test(str)) return '"' + str.replace(/"/g, '\\"') + '"';
+  return str;
+}
+
+function quoteForPwsh(s) {
+  return "'" + String(s).replace(/'/g, "''") + "'";
+}
+
+// Build a PowerShell command-line string that cd's into cwd then invokes
+// command with args via `&` (works for aliases, functions, scripts, exes).
+function buildPwshScript({ cwd, command, args }) {
+  const pieces = [`Set-Location -LiteralPath ${quoteForPwsh(cwd)}`];
+  if (command) {
+    const argTail = (args || []).map(quoteForPwsh).join(' ');
+    pieces.push(`& ${quoteForPwsh(command)} ${argTail}`.trim());
+  }
+  return pieces.join('; ');
+}
+
+// PowerShell -EncodedCommand expects UTF-16LE base64. We pass scripts this
+// way so the wt CLI parser doesn't munge ';' (which wt uses as a sub-command
+// separator at any nesting depth) or other shell metacharacters.
+function buildPwshEncodedCommand(opts) {
+  return Buffer.from(buildPwshScript(opts), 'utf16le').toString('base64');
+}
+
+// Helper for the powershell/pwsh kinds: open a new window via `cmd /c start`
+// running powershell/pwsh that cd's to cwd and runs the command.
+function spawnViaCmdStart(psExe, { cwd, command, args, title }) {
+  const psScript = buildPwshScript({ cwd, command, args });
+  const startArgs = [
+    '/c', 'start',
+    title || '',
+    '/D', cwd,
+    psExe,
+    '-NoExit', '-NoLogo',
+    '-Command', psScript,
+  ];
+  const spawned = spawn('cmd.exe', startArgs, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: false,
+  });
+  spawned.unref();
+  return { spawned, args: startArgs };
+}
+
+function launchInTerminal({
+  cwd,
+  command = null,
+  args = [],
+  title = null,
+  terminal = 'wt',
+  commandShell = 'pwsh',
+}) {
+  if (!cwd) throw new Error('launchInTerminal: cwd required');
+  const kind = TERMINAL_KINDS[terminal];
+  if (!kind) throw new Error(`launchInTerminal: unknown terminal "${terminal}"`);
+  const resolved = path.resolve(cwd);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`launchInTerminal: cwd does not exist: ${resolved}`);
+  }
+  const { spawned, args: launchedArgs } = kind.spawn({
+    cwd: resolved,
+    command,
+    args,
+    title,
+    commandShell,
+  });
+  return {
+    pid: spawned.pid,
+    cwd: resolved,
+    terminal,
+    commandShell,
+    processName: kind.processName,
+    args: launchedArgs,
+  };
+}
+
+// Convenience wrappers — claudeCommand defaults to 'claude' but should be
+// supplied by the caller from config so the user's preference applies.
+function launchResume({ cwd, sessionId, title = null, terminal = 'wt', claudeCommand = 'claude', commandShell = 'pwsh' }) {
+  return launchInTerminal({
+    cwd,
+    command: claudeCommand,
+    args: ['--resume', sessionId],
+    title: title || `resume ${sessionId.slice(0, 8)}`,
+    terminal,
+    commandShell,
+  });
+}
+
+function launchNewClaude({
+  cwd,
+  title = null,
+  extraArgs = [],
+  terminal = 'wt',
+  claudeCommand = 'claude',
+  commandShell = 'pwsh',
+}) {
+  return launchInTerminal({
+    cwd,
+    command: claudeCommand,
+    args: extraArgs,
+    title: title || path.basename(cwd),
+    terminal,
+    commandShell,
+  });
+}
+
+function listTerminalKinds() {
+  return Object.keys(TERMINAL_KINDS).map((name) => ({
+    name,
+    processName: TERMINAL_KINDS[name].processName,
+  }));
+}
+
+function processNameFor(terminal) {
+  return TERMINAL_KINDS[terminal] ? TERMINAL_KINDS[terminal].processName : null;
+}
+
+module.exports = {
+  launchInTerminal,
+  launchResume,
+  launchNewClaude,
+  listTerminalKinds,
+  processNameFor,
+};

package/lib/sessions.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const { exec } = require('node:child_process');
+
+const SESSIONS_DIR = path.join(os.homedir(), '.claude', 'sessions');
+const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+
+function projectSlugForCwd(cwd) {
+  return String(cwd).replace(/[:\\]/g, '-');
+}
+
+function getLiveClaudePids() {
+  return new Promise((resolve) => {
+    exec(
+      'tasklist /FI "IMAGENAME eq claude.exe" /FO CSV /NH',
+      { windowsHide: true },
+      (err, stdout) => {
+        if (err) return resolve(new Set());
+        const pids = new Set();
+        for (const line of stdout.split(/\r?\n/)) {
+          const m = line.match(/"claude\.exe","(\d+)"/);
+          if (m) pids.add(Number(m[1]));
+        }
+        resolve(pids);
+      }
+    );
+  });
+}
+
+async function getAiTitleFromJsonl(jsonlPath) {
+  try {
+    const stat = await fs.stat(jsonlPath);
+    if (stat.size === 0) return null;
+    const TAIL = 1024 * 1024;
+    const offset = Math.max(0, stat.size - TAIL);
+    const readSize = stat.size - offset;
+    const fd = await fs.open(jsonlPath, 'r');
+    try {
+      const buf = Buffer.alloc(readSize);
+      await fd.read(buf, 0, readSize, offset);
+      const text = buf.toString('utf8');
+      const lines = text.split('\n');
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line.includes('"type":"ai-title"')) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.aiTitle) return obj.aiTitle;
+        } catch {}
+      }
+      return null;
+    } finally {
+      await fd.close();
+    }
+  } catch {
+    return null;
+  }
+}
+
+async function listSessions() {
+  let files;
+  try {
+    files = await fs.readdir(SESSIONS_DIR);
+  } catch {
+    return [];
+  }
+
+  const livePids = await getLiveClaudePids();
+
+  const entries = await Promise.all(
+    files
+      .filter((f) => f.endsWith('.json'))
+      .map(async (file) => {
+        const fullPath = path.join(SESSIONS_DIR, file);
+        try {
+          const raw = await fs.readFile(fullPath, 'utf8');
+          const s = JSON.parse(raw);
+          if (!livePids.has(Number(s.pid))) return null;
+
+          const slug = projectSlugForCwd(s.cwd);
+          const jsonl = path.join(PROJECTS_DIR, slug, `${s.sessionId}.jsonl`);
+          const aiTitle = await getAiTitleFromJsonl(jsonl);
+
+          return {
+            pid: s.pid,
+            sessionId: s.sessionId,
+            cwd: s.cwd,
+            status: s.status || 'unknown',
+            startedAt: s.startedAt || null,
+            updatedAt: s.updatedAt || null,
+            version: s.version || null,
+            kind: s.kind || null,
+            name: s.name || null,
+            aiTitle: aiTitle || null,
+            title: aiTitle || s.name || null,
+            jsonlPath: jsonl,
+            sessionFile: fullPath,
+          };
+        } catch {
+          return null;
+        }
+      })
+  );
+
+  return entries
+    .filter(Boolean)
+    .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+}
+
+module.exports = {
+  listSessions,
+  projectSlugForCwd,
+  getLiveClaudePids,
+  SESSIONS_DIR,
+  PROJECTS_DIR,
+};

package/lib/snapshot.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const fsSync = require('node:fs');
+const path = require('node:path');
+const { listSessions } = require('./sessions');
+const { launchResume } = require('./launcher');
+const { DATA_DIR } = require('./config');
+
+const SNAPSHOT_PATH = path.join(DATA_DIR, 'snapshot.json');
+const SNAPSHOT_HISTORY_DIR = path.join(DATA_DIR, 'snapshots');
+
+function ensureDirs() {
+  for (const d of [DATA_DIR, SNAPSHOT_HISTORY_DIR]) {
+    if (!fsSync.existsSync(d)) fsSync.mkdirSync(d, { recursive: true });
+  }
+}
+
+function snapshotFromSessions(sessions) {
+  return {
+    takenAt: Date.now(),
+    sessions: sessions.map((s) => ({
+      pid: s.pid,
+      sessionId: s.sessionId,
+      cwd: s.cwd,
+      title: s.title || null,
+      status: s.status,
+      updatedAt: s.updatedAt,
+    })),
+  };
+}
+
+function tsLabel(ms) {
+  const d = new Date(ms);
+  const p = (n) => String(n).padStart(2, '0');
+  return (
+    d.getFullYear() +
+    p(d.getMonth() + 1) +
+    p(d.getDate()) +
+    '-' +
+    p(d.getHours()) +
+    p(d.getMinutes()) +
+    p(d.getSeconds())
+  );
+}
+
+async function rotateHistory(keep) {
+  if (!keep || keep < 1) return;
+  try {
+    const files = (await fs.readdir(SNAPSHOT_HISTORY_DIR))
+      .filter((f) => f.endsWith('.json'))
+      .sort();
+    const excess = files.length - keep;
+    for (let i = 0; i < excess; i++) {
+      await fs.unlink(path.join(SNAPSHOT_HISTORY_DIR, files[i])).catch(() => {});
+    }
+  } catch {}
+}
+
+async function saveSnapshot({ keep = 30 } = {}) {
+  ensureDirs();
+  const sessions = await listSessions();
+  const snap = snapshotFromSessions(sessions);
+  const payload = JSON.stringify(snap, null, 2);
+  await fs.writeFile(SNAPSHOT_PATH, payload);
+  const histPath = path.join(SNAPSHOT_HISTORY_DIR, `${tsLabel(snap.takenAt)}.json`);
+  await fs.writeFile(histPath, payload);
+  await rotateHistory(keep);
+  return snap;
+}
+
+async function loadLatestSnapshot() {
+  try {
+    const raw = await fs.readFile(SNAPSHOT_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch (e) {
+    if (e.code === 'ENOENT') return null;
+    throw e;
+  }
+}
+
+async function listSnapshotHistory() {
+  ensureDirs();
+  try {
+    const files = (await fs.readdir(SNAPSHOT_HISTORY_DIR))
+      .filter((f) => f.endsWith('.json'))
+      .sort()
+      .reverse();
+    return files.map((f) => ({
+      file: f,
+      path: path.join(SNAPSHOT_HISTORY_DIR, f),
+    }));
+  } catch {
+    return [];
+  }
+}
+
+async function loadSnapshotByFile(file) {
+  const safe = path.basename(file);
+  const p = path.join(SNAPSHOT_HISTORY_DIR, safe);
+  const raw = await fs.readFile(p, 'utf8');
+  return JSON.parse(raw);
+}
+
+function restoreSnapshot(snap, { terminal = 'wt', claudeCommand = 'claude', commandShell = 'pwsh' } = {}) {
+  if (!snap || !Array.isArray(snap.sessions)) {
+    return { launched: [], skipped: [] };
+  }
+  const launched = [];
+  const skipped = [];
+  for (const s of snap.sessions) {
+    if (!s.sessionId || !s.cwd) {
+      skipped.push({ ...s, reason: 'missing sessionId or cwd' });
+      continue;
+    }
+    try {
+      const { pid, args } = launchResume({
+        cwd: s.cwd,
+        sessionId: s.sessionId,
+        title: (s.title || s.sessionId.slice(0, 8)),
+        terminal,
+        claudeCommand,
+        commandShell,
+      });
+      launched.push({ sessionId: s.sessionId, cwd: s.cwd, wtPid: pid, args });
+    } catch (e) {
+      skipped.push({ ...s, reason: String(e && e.message || e) });
+    }
+  }
+  return { launched, skipped };
+}
+
+module.exports = {
+  saveSnapshot,
+  loadLatestSnapshot,
+  listSnapshotHistory,
+  loadSnapshotByFile,
+  restoreSnapshot,
+  SNAPSHOT_PATH,
+  SNAPSHOT_HISTORY_DIR,
+};

package/lib/workspace.js

@@ -0,0 +1,229 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const fsSync = require('node:fs');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+const { listSessions } = require('./sessions');
+
+function normWin(p) {
+  return path.resolve(String(p)).toLowerCase();
+}
+
+function isInside(child, parent) {
+  const c = normWin(child);
+  const p = normWin(parent);
+  if (c === p) return true;
+  const pSep = p.endsWith(path.sep) ? p : p + path.sep;
+  return c.startsWith(pSep);
+}
+
+async function ensureDir(p) {
+  await fs.mkdir(p, { recursive: true });
+}
+
+async function dirExists(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function isGitClone(p) {
+  return dirExists(path.join(p, '.git'));
+}
+
+async function listSubdirs(p) {
+  try {
+    const entries = await fs.readdir(p, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch (e) {
+    if (e.code === 'ENOENT') return [];
+    throw e;
+  }
+}
+
+async function describeWorkspace(workspacePath, repos, busyPaths) {
+  const repoStatus = await Promise.all(
+    repos.map(async (r) => {
+      const repoPath = path.join(workspacePath, r.name);
+      const exists = await dirExists(repoPath);
+      const cloned = exists ? await isGitClone(repoPath) : false;
+      return {
+        name: r.name,
+        url: r.url,
+        path: repoPath,
+        exists,
+        cloned,
+      };
+    })
+  );
+  const inUse = busyPaths.some((p) => isInside(p, workspacePath));
+  const sessionsHere = busyPaths.filter((p) => isInside(p, workspacePath));
+  return {
+    name: path.basename(workspacePath),
+    path: workspacePath,
+    inUse,
+    sessionsHere,
+    repos: repoStatus,
+  };
+}
+
+async function listWorkspaces({ workDir, repos }) {
+  await ensureDir(workDir);
+  const subdirs = await listSubdirs(workDir);
+  const sessions = await listSessions();
+  const busyPaths = sessions.map((s) => s.cwd);
+
+  const workspaces = await Promise.all(
+    subdirs.map((name) =>
+      describeWorkspace(path.join(workDir, name), repos, busyPaths)
+    )
+  );
+  workspaces.sort((a, b) => {
+    if (a.inUse !== b.inUse) return a.inUse ? 1 : -1;
+    return a.name.localeCompare(b.name, undefined, { numeric: true });
+  });
+  return workspaces;
+}
+
+function nextWorkspaceName(existing) {
+  const used = new Set(existing.map((w) => w.name.toLowerCase()));
+  for (let i = 1; i < 10000; i++) {
+    const candidate = `ws-${i}`;
+    if (!used.has(candidate)) return candidate;
+  }
+  throw new Error('Could not allocate workspace name');
+}
+
+async function findOrCreateWorkspace({ workDir, repos, requireUnused = true }) {
+  const all = await listWorkspaces({ workDir, repos });
+  if (requireUnused) {
+    const free = all.find((w) => !w.inUse);
+    if (free) return { workspace: free, created: false };
+  }
+  const name = nextWorkspaceName(all);
+  const wsPath = path.join(workDir, name);
+  await ensureDir(wsPath);
+  const ws = await describeWorkspace(wsPath, repos, []);
+  return { workspace: ws, created: true };
+}
+
+// Parse a single git --progress line. Git emits these on stderr, using \r
+// to overwrite the same line in place, with the format:
+//   "<phase>: <pct>% (<cur>/<total>), <detail>"
+// Examples:
+//   "Receiving objects:  45% (12345/27384), 23.4 MiB | 5.2 MiB/s"
+//   "Resolving deltas: 100% (5847/5847), done."
+function parseGitProgress(line) {
+  if (!line) return null;
+  const clean = line.replace(/^remote:\s*/, '').trim();
+  const m = clean.match(/^([^:]+):\s+(\d+)%\s*(?:\((\d+)\/(\d+)\))?(?:,\s+(.+?))?$/);
+  if (!m) return null;
+  return {
+    phase: m[1].trim(),
+    percent: Number(m[2]),
+    current: m[3] ? Number(m[3]) : null,
+    total: m[4] ? Number(m[4]) : null,
+    detail: m[5] ? m[5].trim() : null,
+    raw: clean,
+  };
+}
+
+function runGit(args, cwd, { onProgress, onLine } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('git', args, {
+      cwd,
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let out = '';
+    let err = '';
+    let stderrBuf = '';
+    child.stdout.on('data', (d) => (out += d.toString()));
+    child.stderr.on('data', (d) => {
+      const text = d.toString();
+      err += text;
+      if (onProgress || onLine) {
+        stderrBuf += text;
+        const parts = stderrBuf.split(/[\r\n]/);
+        stderrBuf = parts.pop();
+        for (const line of parts) {
+          if (!line) continue;
+          if (onLine) onLine(line);
+          if (onProgress) {
+            const p = parseGitProgress(line);
+            if (p) onProgress(p);
+          }
+        }
+      }
+    });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (stderrBuf && (onLine || onProgress)) {
+        if (onLine) onLine(stderrBuf);
+        if (onProgress) {
+          const p = parseGitProgress(stderrBuf);
+          if (p) onProgress(p);
+        }
+      }
+      if (code === 0) resolve({ stdout: out, stderr: err });
+      else
+        reject(
+          Object.assign(
+            new Error(`git ${args.join(' ')} exited ${code}: ${err.trim()}`),
+            { code, stdout: out, stderr: err }
+          )
+        );
+    });
+  });
+}
+
+async function cloneRepoInto({ workspacePath, repo, onProgress, onLine }) {
+  const target = path.join(workspacePath, repo.name);
+  if (await dirExists(target)) {
+    if (await isGitClone(target)) {
+      return { repo: repo.name, action: 'already-cloned', path: target };
+    }
+    throw new Error(
+      `Target ${target} exists but is not a git clone — refusing to overwrite`
+    );
+  }
+  await runGit(['clone', '--progress', repo.url, repo.name], workspacePath, {
+    onProgress,
+    onLine,
+  });
+  return { repo: repo.name, action: 'cloned', path: target };
+}
+
+async function ensureReposInWorkspace({ workspacePath, repos, onProgress, onLine, onRepoStart, onRepoEnd }) {
+  const results = [];
+  for (const repo of repos) {
+    if (onRepoStart) onRepoStart(repo);
+    try {
+      const r = await cloneRepoInto({
+        workspacePath,
+        repo,
+        onProgress: onProgress ? (p) => onProgress(repo, p) : null,
+        onLine: onLine ? (l) => onLine(repo, l) : null,
+      });
+      if (onRepoEnd) onRepoEnd(repo, { ok: true, ...r });
+      results.push({ ok: true, ...r });
+    } catch (e) {
+      const err = { ok: false, repo: repo.name, error: String(e && e.message || e) };
+      if (onRepoEnd) onRepoEnd(repo, err);
+      results.push(err);
+    }
+  }
+  return results;
+}
+
+module.exports = {
+  listWorkspaces,
+  findOrCreateWorkspace,
+  ensureReposInWorkspace,
+  isInside,
+  nextWorkspaceName,
+};