claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/lib/sessionSlots.cjs

@@ -28,6 +28,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { sessionSlotsConfigPath } = require('./schedulerPaths.cjs');
 const { appendAuditEvent } = require('./auditLog.cjs');
+const atomicFs = require('./atomicFs.cjs');
 const { isProvablyDead, DEFAULT_GRACE_MS } = require('./reservationExpiry.cjs');
 
 const MIN_SLOTS = 0;
@@ -57,10 +58,7 @@ function setCap(cap) {
     throw new Error(`sessionSlots.setCap: cap must be an integer in [${MIN_SLOTS}, ${MAX_SLOTS}]`);
   }
   const configPath = sessionSlotsConfigPath();
-  fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  const tmp = `${configPath}.${process.pid}.${Date.now()}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify({ cap: n }, null, 2));
-  fs.renameSync(tmp, configPath);
+  atomicFs.writeJsonAtomicSync(configPath, { cap: n });
   for (const fn of listeners) {
     try { fn(); } catch { /* a consumer's pump error is its own problem */ }
   }

package/src/main/lib/shippedPersonaSeeds.cjs

@@ -0,0 +1,226 @@
+'use strict';
+
+/**
+ * SHIPPED_PERSONA_SEEDS — every distinct version this app has ever bundled
+ * for the four seed personas (`src/main/seedAgentPersonas.cjs`'s `PERSONAS`),
+ * keyed by persona name. One entry per version actually shipped in
+ * `src/seed/agents/<name>.md`'s git history; exact duplicates (same body
+ * hash and same `fm`) are dropped.
+ *
+ * `seedAgentPersonas.cjs`'s upgrade pass only replaces an installed persona
+ * file when its body hash matches one of the `bodySha256` values below — a
+ * body that never shipped from this app (hand-written, or hand-edited after
+ * install) is left alone, never overwritten. `fm` holds every frontmatter
+ * key that version had, except `name` and `seedVersion` — those two are
+ * never diffed against this list.
+ *
+ * When you change a bundled persona, add its new version here. The test in
+ * seedAgentPersonas.test.cjs prints the entry to paste.
+ */
+
+function deepFreeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const key of Object.keys(value)) deepFreeze(value[key]);
+  }
+  return value;
+}
+
+const SHIPPED_PERSONA_SEEDS = deepFreeze({
+  "architect": [
+    {
+      commit: "dba99697",
+      bodySha256: "40a4d41445e7fdb128f4f1d8d3eef88b857ca466726b3719b36cb69933f09168",
+      fm: {
+        description: "The primary Actor for an Epic's whole interactive conversation — owns overall plan and decomposition, clarifies scope, searches before building, decomposes work into scheduled PRDs via /develop, tracks them to completion, and verifies before calling anything done. Never implements a PRD itself — that's dev-lead's job, one PRD at a time, headless. Task-type framing is the Epic's Mission tag's job, not this persona's.",
+        model: "opus",
+        tags: "feature, bug, discussion",
+        title: "Engineering — Architect",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+    {
+      commit: "767c3b8e",
+      bodySha256: "40a4d41445e7fdb128f4f1d8d3eef88b857ca466726b3719b36cb69933f09168",
+      fm: {
+        description: "The primary Actor for an Epic's whole interactive conversation — owns overall plan and decomposition, clarifies scope, searches before building, decomposes work into scheduled PRDs via /develop, tracks them to completion, and verifies before calling anything done. Never implements a PRD itself — that's dev-lead's job, one PRD at a time, headless. Task-type framing is the Epic's Mission tag's job, not this persona's.",
+        model: "opus",
+        effort: "medium",
+        tags: "feature, bug, discussion",
+        title: "Engineering — Architect",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+  ],
+  "dev-lead": [
+    {
+      commit: "dba99697",
+      bodySha256: "7821f5bf3f1617fb4c9ea80c81fc37680bfc4c61346e59f58da456c69ef74a90",
+      fm: {
+        description: "Executes exactly one already-scoped PRD at a time, headless, start to finish — reads the PRD's Goal/Acceptance Criteria/Implementation notes and standards.md, implements it, verifies against its own AC, and reports. Has no visibility into the overall plan — that's architect's job. Not currently wired to run automatically; a PRD must name this persona explicitly (e.g. in its Implementation notes) for an executor to adopt it.",
+        model: "fable",
+        title: "Engineering — Software Engineer",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+    {
+      commit: "07b73fac",
+      bodySha256: "21284b34473fd4a9b727e8fa2a0702379751d3af0985392a9814f91a4fdc8551",
+      fm: {
+        description: "Executes exactly one already-scoped PRD at a time, headless, start to finish — reads the PRD's Goal/Acceptance Criteria/Implementation notes and standards.md, implements it, verifies against its own AC, and reports. Has no visibility into the overall plan — that's architect's job. This is the default persona a scheduled PRD runs as: the scheduler resolves a PRD's `agentType` frontmatter field (default `dev-lead`) to this file and launches the headless executor AS this persona via `--append-system-prompt`.",
+        model: "sonnet",
+        title: "Engineering — Software Engineer",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+    {
+      commit: "2751c9f5",
+      bodySha256: "375b46dd6f1edc7b7e304e0be5bf32a4e61ca4adf329bc73d65ba2224e3c7b8a",
+      fm: {
+        description: "Executes exactly one already-scoped PRD at a time, headless, start to finish — reads the PRD's Goal/Acceptance Criteria/Implementation notes and standards.md, implements it, verifies against its own AC, and reports. Has no visibility into the overall plan — that's architect's job. This is the default persona a scheduled PRD runs as: the scheduler resolves a PRD's `agentType` frontmatter field (default `dev-lead`) to this file and launches the headless executor AS this persona via `--append-system-prompt`.",
+        model: "sonnet",
+        title: "Engineering — Software Engineer",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+    {
+      commit: "9f8286d7",
+      bodySha256: "86e5d8a679c3be879b162140d403f905a1ef9edbcc54b3bf4b3a278425dea841",
+      fm: {
+        description: "Executes exactly one already-scoped PRD at a time, headless, start to finish — reads the PRD's Goal/Acceptance Criteria/Implementation notes and standards.md, implements it, verifies against its own AC, and reports. Has no visibility into the overall plan — that's architect's job. This is the default persona a scheduled PRD runs as: the scheduler resolves a PRD's `agentType` frontmatter field (default `dev-lead`) to this file and launches the headless executor AS this persona via `--append-system-prompt`.",
+        model: "sonnet",
+        title: "Engineering — Software Engineer",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+    {
+      commit: "ab4be752",
+      bodySha256: "dbd5500968b75cbbe6549e612dc3df5de8d1569fa902cac173705542ea095225",
+      fm: {
+        description: "Executes exactly one already-scoped PRD at a time, headless, start to finish — reads the PRD's Goal/Acceptance Criteria/Implementation notes and standards.md, implements it, verifies against its own AC, and reports. Has no visibility into the overall plan — that's architect's job. This is the default persona a scheduled PRD runs as: the scheduler resolves a PRD's `agentType` frontmatter field (default `dev-lead`) to this file and launches the headless executor AS this persona via `--append-system-prompt`.",
+        model: "sonnet",
+        title: "Engineering — Software Engineer",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+    {
+      commit: "535b04f8",
+      bodySha256: "91232cfd7ce5fb1dc608ff639a07dcb1c5c13c22502ae4790f51707f498ec917",
+      fm: {
+        description: "Executes exactly one already-scoped PRD at a time, headless, start to finish — reads the PRD's Goal/Acceptance Criteria/Implementation notes and standards.md, implements it, verifies against its own AC, and reports. Has no visibility into the overall plan — that's architect's job. This is the default persona a scheduled PRD runs as: the scheduler resolves a PRD's `agentType` frontmatter field (default `dev-lead`) to this file and launches the headless executor AS this persona via `--append-system-prompt`.",
+        model: "sonnet",
+        title: "Engineering — Software Engineer",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+    {
+      commit: "767c3b8e",
+      bodySha256: "91232cfd7ce5fb1dc608ff639a07dcb1c5c13c22502ae4790f51707f498ec917",
+      fm: {
+        description: "Executes exactly one already-scoped PRD at a time, headless, start to finish — reads the PRD's Goal/Acceptance Criteria/Implementation notes and standards.md, implements it, verifies against its own AC, and reports. Has no visibility into the overall plan — that's architect's job. This is the default persona a scheduled PRD runs as: the scheduler resolves a PRD's `agentType` frontmatter field (default `dev-lead`) to this file and launches the headless executor AS this persona via `--append-system-prompt`.",
+        model: "sonnet",
+        effort: "medium",
+        title: "Engineering — Software Engineer",
+        tools: "Read, Grep, Glob, Bash, Edit, Write",
+      },
+    },
+  ],
+  "project-home-builder": [
+    {
+      commit: "e9f2f540",
+      bodySha256: "e1c80f465179f814f1e9ea95529434309e5238facdc8c6664cb8f44f8302e148",
+      fm: {
+        description: "Generates a project's 5 static Project Page HTML files (Home / Marketing Landing / Feature Description / Architecture Overview / Brief) by following the session-manager app's own MCP contract for the pipeline — portable to any machine with the app installed, no source-repo paths required.",
+        title: "Project Pages — Builder",
+        tools: "Read, Grep, Glob, Bash, Write, Edit",
+      },
+    },
+    {
+      commit: "5cc32fa4",
+      bodySha256: "7ad61d9b9dbe7f35727baf83f94c3c244deb25133eebb78c9295c9841237dd1c",
+      fm: {
+        description: "Reads a project and writes ONE self-contained overview page (home.html) for its Project Home tab, then saves it with a single project_home_write call.",
+        title: "Project Home — Builder",
+        tools: "Read, Grep, Glob, Bash, Write, Edit",
+      },
+    },
+    {
+      commit: "e2cdd120",
+      bodySha256: "8cef2256f31d1d166a305923388d1d0d2f4f099275df24d869decc35a6cb11bb",
+      fm: {
+        description: "Reads a project and writes ONE self-contained overview page (home.html) for its Project Home tab, then saves it with a single project_home_write call.",
+        tools: "Read, Grep, Glob, Bash, Write, Edit",
+        title: "Project Home — Builder",
+        model: "sonnet",
+        effort: "medium",
+      },
+    },
+  ],
+  "validator": [
+    {
+      commit: "41c28597",
+      bodySha256: "4791f25651b4fc3b7cfa3a26148e6dd1cceec05f057b882516fafcdcc04f71e7",
+      fm: {
+        description: "Validates a finished PLAN (the PRDs that share one planId) once, after its last PRD lands — re-runs each PRD's gate, checks every acceptance criterion against the real tree, reviews the plan's combined diff, and reports one VERIFIED/REFUTED verdict per PRD via sentinel lines. Runs headless as a scheduled PRD (agentType: validator); never edits product code and never queues work.",
+        model: "sonnet",
+        title: "Engineering — Plan Validator",
+        tools: "Read, Grep, Glob, Bash",
+      },
+    },
+    {
+      commit: "7ed8dd1d",
+      bodySha256: "80d19294bc8a0e654f242a6177ae14ebdb116c899614c6b6bed503774624a0b8",
+      fm: {
+        description: "Validates a finished PLAN (the PRDs that share one planId) once, after its last PRD lands — re-runs each PRD's gate, checks every acceptance criterion against the real tree, reviews the plan's combined diff, and reports one VERIFIED/REFUTED verdict per PRD via sentinel lines. Runs headless as a scheduled PRD (agentType: validator); never edits product code and never queues work.",
+        model: "sonnet",
+        title: "Engineering — Plan Validator",
+        tools: "Read, Grep, Glob, Bash",
+      },
+    },
+    {
+      commit: "9f8286d7",
+      bodySha256: "8e95bfe06f70e7f9ae7f22de829b6f40727714e7f66364d166756b269ad7d50f",
+      fm: {
+        description: "Validates a finished PLAN (the PRDs that share one planId) once, after its last PRD lands — re-runs each PRD's gate, checks every acceptance criterion against the real tree, reviews the plan's combined diff, and reports one VERIFIED/REFUTED verdict per PRD via sentinel lines. Runs headless as a scheduled PRD (agentType: validator); never edits product code and never queues work.",
+        model: "sonnet",
+        title: "Engineering — Plan Validator",
+        tools: "Read, Grep, Glob, Bash",
+      },
+    },
+    {
+      commit: "ab4be752",
+      bodySha256: "512ec61490f6b652268bedc2aebd07fb4aafe8df53cfed38bb728348a29f29cc",
+      fm: {
+        description: "Validates a finished PLAN (the PRDs that share one planId) once, after its last PRD lands — re-runs each PRD's gate, checks every acceptance criterion against the real tree, reviews the plan's combined diff, and reports one VERIFIED/REFUTED verdict per PRD via sentinel lines. Runs headless as a scheduled PRD (agentType: validator); never edits product code and never queues work.",
+        model: "sonnet",
+        title: "Engineering — Plan Validator",
+        tools: "Read, Grep, Glob, Bash",
+      },
+    },
+    {
+      commit: "535b04f8",
+      bodySha256: "5aeaf796a30ac98bdce440a6fcd088e1c776ae762f2778327439ab8d75a2de94",
+      fm: {
+        description: "Validates a finished PLAN (the PRDs its validate PRD lists) once, after its last PRD lands — re-runs each PRD's gate, checks every acceptance criterion against the real tree, reviews the plan's combined diff, and reports one VERIFIED/REFUTED verdict per PRD via sentinel lines. Runs headless as a scheduled PRD (agentType: validator); never edits product code and never queues work.",
+        model: "sonnet",
+        title: "Engineering — Plan Validator",
+        tools: "Read, Grep, Glob, Bash",
+      },
+    },
+  ],
+  "demo-video-builder": [
+    {
+      commit: "b4f4f84b",
+      bodySha256: "4bc6279a4553889f3996c4eb95803a9b38191a959f512b47ee9168b85e49b889",
+      fm: {
+        description: "30-second self-contained HTML/JS demo video for Project Home, saved via project_demo_video_write.",
+        tools: "Read, Grep, Glob, Bash, Write, Edit",
+        title: "Project Home — Demo Video",
+        model: "sonnet",
+        effort: "medium",
+      },
+    },
+  ],
+});
+
+module.exports = { SHIPPED_PERSONA_SEEDS };

package/src/main/lib/smfileHeaders.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+const DEMO_VIDEO_CSP_HEADER = [
+  "default-src 'none'",
+  "script-src 'unsafe-inline'",
+  "style-src 'unsafe-inline'",
+  'img-src data: blob:',
+  'media-src data: blob:',
+  "font-src data:",
+  "connect-src 'none'",
+  "frame-src 'none'",
+  "worker-src 'none'",
+  "form-action 'none'",
+  "base-uri 'none'",
+].join('; ');
+
+const DEMO_VIDEO_PATH_MARKER = '/session-manager-operations/project-pages/demo-video/';
+
+/**
+ * Response headers for a file served over the smfile:// protocol. A file
+ * under the demo-video project-pages folder gets a CSP response header —
+ * document content (a decoy <head>, HTML comments) cannot override this,
+ * unlike the meta-tag CSP the demo-video HTML ships inline.
+ * @param {string} realPath
+ * @param {string} contentType
+ */
+function smfileResponseHeaders(realPath, contentType) {
+  const normalised = String(realPath).replace(/\\/g, '/');
+  const headers = { 'content-type': contentType };
+  if (normalised.includes(DEMO_VIDEO_PATH_MARKER)) {
+    headers['content-security-policy'] = DEMO_VIDEO_CSP_HEADER;
+  }
+  return headers;
+}
+
+/**
+ * Guards against a demo-video document exfiltrating data by navigating its
+ * own sandboxed iframe (meta refresh, `location.href = 'https://…'`), which
+ * the CSP response header does not govern — `frame-src`/`connect-src` don't
+ * stop a top-level navigation of the subframe itself.
+ * @param {{ isMainFrame: boolean, currentUrl: string, targetUrl: string }} params
+ * @returns {boolean}
+ */
+function shouldBlockFrameNavigation({ isMainFrame, currentUrl, targetUrl }) {
+  if (isMainFrame) return false;
+  if (typeof currentUrl !== 'string' || !currentUrl.startsWith('smfile:')) return false;
+
+  let pathname;
+  try {
+    // Same normalisation as smfileResponseHeaders below: on Windows the
+    // absolute path (and therefore the smfile:// URL built from it) uses
+    // backslashes, which the forward-slash DEMO_VIDEO_PATH_MARKER would
+    // otherwise never match — silently disabling this guard on win32.
+    pathname = decodeURIComponent(new URL(currentUrl).pathname).replace(/\\/g, '/');
+  } catch {
+    return false;
+  }
+  if (!pathname.includes(DEMO_VIDEO_PATH_MARKER)) return false;
+
+  if (typeof targetUrl !== 'string') return false;
+  if (targetUrl.startsWith('smfile:')) return false;
+  if (targetUrl === 'about:blank' || targetUrl === 'about:srcdoc') return false;
+  return true;
+}
+
+module.exports = { DEMO_VIDEO_CSP_HEADER, smfileResponseHeaders, shouldBlockFrameNavigation };

package/src/main/lib/timeoutShim.cjs

@@ -0,0 +1,123 @@
+/**
+ * timeoutShim.cjs — installs a dependency-free `timeout` shim under the
+ * user's home, for machines whose `timeout` is missing or non-GNU (stock
+ * macOS ships none at all), and exposes `withTimeoutShimOnPath` so a child
+ * spawn's PATH can fall back to it.
+ *
+ * Mirrors guardShims.cjs's pattern: a stable path under
+ * `~/.claude/session-manager/`, written with `writeTextAtomic`, idempotent
+ * (a re-run with unchanged content writes nothing), and `addAllowedRoot`
+ * called first so a test's temp "home" passes config.cjs's write-boundary
+ * check the same way the real home does.
+ *
+ * `timeout-shim.cjs` under the shim dir is a verbatim copy of
+ * timeoutShimScript.cjs, read from disk at call time (not inlined here) so
+ * the installed copy can never drift from the source file. `timeout` is a
+ * tiny POSIX launcher that runs it with `node`, falling back to the current
+ * Electron binary (`execPath`) with ELECTRON_RUN_AS_NODE=1 when no `node` is
+ * on PATH.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { writeTextAtomic, addAllowedRoot } = require('../config.cjs');
+
+function shimDir(homeDir = os.homedir()) {
+  return path.join(homeDir, '.claude', 'session-manager', 'bin');
+}
+
+function shimPath(homeDir = os.homedir()) {
+  return path.join(shimDir(homeDir), 'timeout');
+}
+
+function scriptDestPath(homeDir = os.homedir()) {
+  return path.join(shimDir(homeDir), 'timeout-shim.cjs');
+}
+
+// Single-quote the exec path for POSIX sh: close the quote, escape any
+// literal `'` as `'\''`, reopen it. A plain path with no `'` in it just
+// comes back wrapped in quotes.
+function quoteForShell(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function launcherBody(execPath) {
+  return `#!/bin/sh
+SHIM_DIR=$(dirname "$0")
+if command -v node >/dev/null 2>&1; then
+  exec node "$SHIM_DIR/timeout-shim.cjs" "$@"
+fi
+ELECTRON_RUN_AS_NODE=1 exec ${quoteForShell(execPath)} "$SHIM_DIR/timeout-shim.cjs" "$@"
+`;
+}
+
+function readIfExists(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Writes the shim pair under `<homeDir>/.claude/session-manager/bin`.
+ * Each file is written only when its content differs from what's already on
+ * disk. The launcher's own write sets its mode to 0755 on the temp file
+ * BEFORE the rename, so the path at `launcherDest` never exists without the
+ * exec bit — a gate that races the install can only ever see "not there yet"
+ * or "there and runnable", never "there but exit 126". The chmod right after
+ * is a second, unconditional pass (even on a no-op run) so a permission
+ * change made outside this function self-heals on the next call. Never
+ * throws: returns `{ok:true, changed, path}` (`path` is the launcher path) on
+ * success, `{ok:false, error}` on failure, and `{ok:false, skipped:true}` on
+ * win32, where there is no POSIX shell to run the launcher.
+ */
+async function ensureTimeoutShim({ homeDir = os.homedir(), execPath = process.execPath } = {}) {
+  if (process.platform === 'win32') return { ok: false, skipped: true };
+  try {
+    addAllowedRoot(homeDir);
+    const scriptDest = scriptDestPath(homeDir);
+    const launcherDest = shimPath(homeDir);
+    const scriptContent = fs.readFileSync(path.join(__dirname, 'timeoutShimScript.cjs'), 'utf8');
+    const launcherContent = launcherBody(execPath);
+
+    let changed = false;
+    if (readIfExists(scriptDest) !== scriptContent) {
+      await writeTextAtomic(scriptDest, scriptContent);
+      changed = true;
+    }
+    if (readIfExists(launcherDest) !== launcherContent) {
+      await writeTextAtomic(launcherDest, launcherContent, { mode: 0o755 });
+      changed = true;
+    }
+    // Repairs a mode changed by hand; the write above already set 0o755
+    // before the rename, so this is a no-op in the common case.
+    fs.chmodSync(launcherDest, 0o755);
+    return { ok: true, changed, path: launcherDest };
+  } catch (err) {
+    return { ok: false, error: err?.message ?? String(err) };
+  }
+}
+
+/**
+ * Appends the shim dir to `pathValue`, at the end, so a real `timeout`
+ * earlier on PATH (GNU coreutils, Homebrew, ...) keeps winning. No-op when
+ * the shim dir is already anywhere in `pathValue` — never adds a duplicate.
+ */
+function withTimeoutShimOnPath(pathValue, homeDir = os.homedir()) {
+  const dir = shimDir(homeDir);
+  const current = pathValue == null ? '' : String(pathValue);
+  const parts = current.split(path.delimiter).filter(Boolean);
+  if (parts.includes(dir)) return current;
+  if (!parts.length) return dir;
+  return `${current}${path.delimiter}${dir}`;
+}
+
+module.exports = {
+  shimDir,
+  shimPath,
+  ensureTimeoutShim,
+  withTimeoutShimOnPath,
+};