claude-code-session-manager 0.20.0 → 0.20.1

package/src/main/index.cjs

@@ -35,11 +35,11 @@ const { registerDocEditorHandlers } = require('./docEditor.cjs');
 const git = require('./git.cjs');
 const superagent = require('./superagent.cjs');
 const kg = require('./kg.cjs');
-const { registerProjectSkillsHandlers } = require('./projectSkills.cjs');
 const filesIpc = require('./files.cjs');
 const searchIpc = require('./search.cjs');
 const repoAnalyzer = require('./repoAnalyzer.cjs');
 const hivesIpc = require('./hives.cjs');
+const webRemote = require('./webRemote.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { checkInsideHome, assertInsideHome } = require('./lib/insideHome.cjs');
 const { openInEditor, openFileInEditor, openInFinder, openInTerminal } = require('./lib/openExternalApp.cjs');
@@ -626,11 +626,11 @@ agentMemory.registerAgentMemoryHandlers();
 registerDocEditorHandlers();
 git.register(ipcMain);
 superagent.registerSuperAgentHandlers();
-registerProjectSkillsHandlers();
 filesIpc.registerFilesHandlers();
 searchIpc.registerSearchHandlers();
 repoAnalyzer.register(ipcMain);
 hivesIpc.registerHiveHandlers();
+webRemote.registerRemoteHandlers();
 
 // OTEL telemetry export (opt-in via ~/.config/session-manager/otel.json).
 ipcMain.handle('otel:get-config', async () => otelSettings.load());
@@ -918,9 +918,13 @@ app.whenReady().then(async () => {
   pluginInstall.attachWindow(mainWindow);
   superagent.attachWindow(mainWindow);
   kg.attachWindow(mainWindow);
+  webRemote.attachWindow(mainWindow);
   scheduler.init().catch((e) => {
     logs.writeLine({ scope: 'scheduler', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });
+  webRemote.init().catch((e) => {
+    logs.writeLine({ scope: 'webRemote', level: 'error', message: 'init failed', meta: { error: e?.message } });
+  });
   // Knowledge Graph: watch the prompt log + register kg:* IPC. Best-effort.
   try { kg.init({ logger: logs }); } catch (e) {
     logs.writeLine({ scope: 'kg', level: 'error', message: 'init failed', meta: { error: e?.message } });
@@ -964,6 +968,7 @@ let teardownDone = false;
 function runShutdownCleanup() {
   if (teardownDone) return;          // idempotent — will-quit may still fire after an app.exit path
   teardownDone = true;
+  webRemote.destroy();
   // Mark a clean exit so the next boot can distinguish a graceful quit from an
   // OOM-kill / native crash (which leaves the sentinel `open`).
   crashDiagnostics.markCleanShutdown();

package/src/main/ipcSchemas.cjs

@@ -242,6 +242,23 @@ const agentMemoryDelete = z.object({
   entryId: z.string().regex(AGENT_MEMORY_ID_RE),
 }).strict();
 
+// ──────────────────────────────────────────── Web Remote
+// OTP is 8 uppercase alphanumeric chars (case-insensitive entry, normalised to upper in handler).
+const WEB_REMOTE_OTP_RE = /^[A-Z0-9]{8}$/i;
+const DEVICE_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+const webRemotePair = z.object({
+  otp: z.string().regex(WEB_REMOTE_OTP_RE),
+}).strict();
+
+const webRemoteRevokeDevice = z.object({
+  deviceId: z.string().regex(DEVICE_ID_RE),
+}).strict();
+
+const webRemoteAuditTail = z.object({
+  lines: z.number().int().min(1).max(500).optional(),
+}).strict();
+
 // ──────────────────────────────────────────── History
 const DATE_YYYY_MM_DD = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -365,12 +382,38 @@ function validated(schema, handler) {
   };
 }
 
+// ──────────────────────────────────────────── Web Remote command allowlist
+// Single source of truth — imported by webRemote.cjs and by the unit test.
+// Only these type strings will ever reach a handler; all others are silently
+// dropped without leaking error details back to the relay (ADR §6.2).
+const ALLOWED_COMMANDS = new Set([
+  'cmd:sessions:load',
+  'cmd:sessions:save',
+  'cmd:pty:spawn',
+  'cmd:pty:write',
+  'cmd:pty:resize',
+  'cmd:pty:kill',
+  'cmd:schedule:state',
+  'cmd:schedule:read-prd',
+  'cmd:schedule:read-log',
+  'cmd:schedule:write-prd',
+  'cmd:schedule:reset-job',
+  'cmd:schedule:run-now',
+  'cmd:schedule:set-config',
+  'cmd:history:aggregate',
+  'cmd:app:version',
+]);
+
 module.exports = {
   // Centralized slug regex — used by scheduler.cjs and queueOps.cjs for
   // direct test()/match() containment checks alongside the zod parses.
   SCHEDULE_SLUG_RE,
   SCHEDULE_RUN_ID_RE,
+  ALLOWED_COMMANDS,
   schemas: {
+    webRemotePair,
+    webRemoteRevokeDevice,
+    webRemoteAuditTail,
     ptySpawn,
     ptyTabId,
     ptyWrite,

package/src/main/kg.cjs

@@ -312,7 +312,7 @@ async function ingest() {
     const units = planUnits(buf.toString('utf8'));
     if (!units) { broadcast('kg:ingest-progress', { phase: 'done', ingesting: false, added: 0 }); return { ok: true, added: 0 }; }
 
-    const graphs = new Map();   // encodedCwd -> graph (lazy-loaded, saved once at end)
+    const graphs = new Map();   // encodedCwd -> graph (lazy-loaded; persisted per batch)
     async function graphFor(cwd) {
       const enc = encodeCwd(cwd);
       if (!graphs.has(enc)) graphs.set(enc, await loadGraphFor(cwd));
@@ -320,15 +320,23 @@ async function ingest() {
     }
 
     const totalBatches = units.filter((u) => u.type === 'batch').length;
-    let committedBytes = 0;
     let committedPrompts = 0;
     let added = 0;
-    let lastTs = st.lastTs;
     let batchNo = 0;
     let failed = false;
+    const touched = new Set();   // encodedCwds whose graph changed this run
 
+    // Each iteration COMMITS before moving on: persist the touched graph, then
+    // advance the global byte-watermark past exactly this unit. Because units
+    // are processed in log order, the watermark stays a correct contiguous
+    // boundary — a crash, quit, or rate-limit mid-run loses at most the batch
+    // in flight, and the graph grows live as each batch lands.
     for (const u of units) {
-      if (u.type === 'skip') { committedBytes += u.bytes; continue; }
+      if (u.type === 'skip') {
+        st.lastOffset += u.bytes;
+        await saveIngestState(st);
+        continue;
+      }
       batchNo++;
       broadcast('kg:ingest-progress', { phase: 'extract', ingesting: true, batch: batchNo, totalBatches });
 
@@ -342,28 +350,30 @@ async function ingest() {
       const parsed = extractJson(r.out);
       if (!parsed) { logger.writeLine({ scope: 'kg', level: 'warn', message: 'extraction unparseable; stopping (resumable)', meta: { cwd: u.cwd } }); failed = true; break; }
 
-      const batchTs = u.entries[u.entries.length - 1].ts || lastTs || new Date().toISOString();
+      const batchTs = u.entries[u.entries.length - 1].ts || st.lastTs || new Date().toISOString();
       for (const ent of (parsed.entities || [])) { if (upsertNode(byKey, g, ent, batchTs)) added++; }
       for (const rel of (parsed.relations || [])) { upsertEdge(byEdge, g, canonicalize(rel.src), canonicalize(rel.dst), rel.relation, batchTs); }
       g.promptCount += u.entries.length;
       g.updatedAt = new Date().toISOString();
 
-      committedBytes += u.bytes;
+      // Commit this batch: graph first (so a crash can't advance the watermark
+      // past unsaved work), then the watermark.
+      await saveGraph(g);
+      st.lastOffset += u.bytes;
+      st.promptCount += u.entries.length;
+      st.lastTs = batchTs;
+      st.updatedAt = new Date().toISOString();
+      await saveIngestState(st);
+
       committedPrompts += u.entries.length;
-      lastTs = batchTs;
+      touched.add(encodeCwd(u.cwd));
+      // Tell the renderer this batch landed so it can refresh the graph live.
+      broadcast('kg:ingest-progress', { phase: 'batch', ingesting: true, batch: batchNo, totalBatches, cwd: u.cwd, added });
     }
 
-    // Persist every touched graph, then advance the watermark past committed bytes only.
-    for (const g of graphs.values()) await saveGraph(g);
-    st.lastOffset += committedBytes;
-    st.promptCount += committedPrompts;
-    st.lastTs = lastTs;
-    st.updatedAt = new Date().toISOString();
-    await saveIngestState(st);
-
-    logger.writeLine({ scope: 'kg', level: 'info', message: 'ingest complete', meta: { committedPrompts, projects: graphs.size, stopped: failed } });
+    logger.writeLine({ scope: 'kg', level: 'info', message: 'ingest complete', meta: { committedPrompts, projects: touched.size, stopped: failed } });
     broadcast('kg:ingest-progress', { phase: 'done', ingesting: false, added: committedPrompts });
-    return { ok: true, added: committedPrompts, projects: graphs.size, stopped: failed };
+    return { ok: true, added: committedPrompts, projects: touched.size, stopped: failed };
   } catch (e) {
     logger.writeLine({ scope: 'kg', level: 'error', message: 'ingest error', meta: { error: e?.message } });
     broadcast('kg:ingest-progress', { phase: 'error', ingesting: false, error: e?.message });

package/src/main/lib/reaperHelpers.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * reaperHelpers.cjs — pure helpers for the dead-process reaper in scheduler.cjs.
+ *
+ * Kept in a separate lib file so they can be unit-tested without importing
+ * scheduler.cjs (which requires electron/ipcMain).
+ */
+
+const fs = require('node:fs');
+const { readTail } = require('./fileTail.cjs');
+
+/**
+ * Return true if pid is alive AND its cmdline looks like a claude process.
+ *
+ * Guards against PID recycling: on Linux we read /proc/<pid>/cmdline and
+ * require /\bclaude\b/ in the command. On macOS (no /proc) we can't read
+ * cmdline, so we conservatively return true — never false-reap a live PID
+ * just because we can't verify its identity.
+ *
+ * Conservative by design: a false negative (live process treated as dead) is
+ * far worse than a late reap.
+ */
+function claudePidAlive(pid) {
+  if (!pid || typeof pid !== 'number' || pid <= 1) return false;
+  try { process.kill(pid, 0); } catch { return false; }
+  try {
+    const cmd = fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8').replace(/\0/g, ' ');
+    return /\bclaude\b/.test(cmd);
+  } catch {
+    // Can't read cmdline (macOS, permission denied) → assume alive.
+    return true;
+  }
+}
+
+/**
+ * Classify the terminal outcome of a completed run by reading the last 64 KB
+ * of its log file and scanning for the LAST `{"type":"result"}` JSONL event.
+ *
+ * Returns:
+ *   'success'   — last result event has subtype=success and is_error !== true
+ *   'failed'    — last result event exists but indicates an error
+ *   'no_result' — no result event found in the tail (process may have been killed
+ *                 before emitting one, or the log is absent/empty)
+ *   'unknown'   — unexpected error reading/parsing (outer catch)
+ */
+function classifyRunOutcome(logPath) {
+  try {
+    const text = readTail(logPath, 65536);
+    let lastResult = null;
+    for (const line of text.split('\n')) {
+      const t = line.trim();
+      if (!t.startsWith('{')) continue;
+      try {
+        const obj = JSON.parse(t);
+        if (obj && obj.type === 'result') lastResult = obj;
+      } catch { /* partial line at tail boundary or non-JSON scheduler log line */ }
+    }
+    if (!lastResult) return 'no_result';
+    if (lastResult.subtype === 'success' && lastResult.is_error !== true) return 'success';
+    return 'failed';
+  } catch {
+    return 'unknown';
+  }
+}
+
+module.exports = { claudePidAlive, classifyRunOutcome };

package/src/main/lib/schedulerBatch.cjs

@@ -0,0 +1,212 @@
+'use strict';
+
+/**
+ * schedulerBatch.cjs — pure batch-picking logic for the scheduler.
+ *
+ * Extracted from scheduler.cjs so the functions can be unit-tested without
+ * loading the full scheduler (which requires electron + heavy I/O).
+ *
+ * Group-ordering gates (failure-gate, running-gate) are evaluated
+ * PER PROJECT (keyed by cwd). Jobs in different projects do not serialize
+ * each other. Within a single project, the sequential-group semantics are
+ * fully preserved.
+ */
+
+const path = require('node:path');
+const os = require('node:os');
+
+const DEFAULT_PROJECT_CWD = path.join(os.homedir(), 'Projects', 'session-manager');
+
+/**
+ * Per-project batch picker. Applies group-ordering rules scoped to a single
+ * project (all jobs sharing one cwd).
+ *
+ * Rules (same as original global pickNextBatch, but scoped):
+ *   1. Find the lowest parallelGroup with pending jobs not already running.
+ *   2. Failure gate: if an earlier group has failed jobs, hold this project.
+ *   3. If that group has jobs in flight (backfill), fire more from SAME group.
+ *   4. If a lower-numbered group arrives late (late-arrival), fire it now.
+ *   5. If no group is in flight, start the lowest pending group fresh.
+ *
+ * @param {object[]} projectJobs - All jobs for this project (all statuses).
+ * @param {Set<string>} runningSlugsInProject - Slugs from the global
+ *   runningSet that belong to this project.
+ * @param {number} slots - Maximum jobs to return (global remaining slots;
+ *   caller enforces the global cap across projects).
+ * @returns {object[]} Jobs to spawn for this project this tick.
+ */
+function pickForProject(projectJobs, runningSlugsInProject, slots) {
+  const pending = projectJobs.filter(
+    (j) => j.status === 'pending' && !runningSlugsInProject.has(j.slug),
+  );
+  if (pending.length === 0) return [];
+
+  const projectCwd = (projectJobs.find((j) => j.cwd) || {}).cwd || DEFAULT_PROJECT_CWD;
+
+  // Lowest pending group (computed up-front for the failure-gate check).
+  const lowestPendingGroup = pending.reduce(
+    (min, j) => Math.min(min, j.parallelGroup ?? 99),
+    Infinity,
+  );
+
+  // Cross-group failure gate: refuse to advance past a group with failed jobs.
+  // A failed foundation PRD should not allow later groups to run and
+  // silently corrupt project state. needs_review is NOT a blocker.
+  const blockingFailures = projectJobs.filter(
+    (j) => j.status === 'failed' && (j.parallelGroup ?? 99) < lowestPendingGroup,
+  );
+  if (blockingFailures.length > 0) {
+    const slugs = blockingFailures.map((j) => j.slug).join(', ');
+    console.log(
+      `[scheduler] failure-gate [${projectCwd}]: holding g${lowestPendingGroup} — ` +
+      `${blockingFailures.length} failed job(s) in earlier groups [${slugs}]. ` +
+      `Reset to pending or archive to unblock.`,
+    );
+    return [];
+  }
+
+  // Groups with at least one job in flight: either tracked in runningSlugsInProject
+  // (this process spawned it) or still marked 'running' in queue.json
+  // (persisted from a previous session that hasn't been orphan-reset yet).
+  const jobBySlug = new Map(projectJobs.map((j) => [j.slug, j]));
+  const activeGroups = new Set();
+  for (const slug of runningSlugsInProject) {
+    const job = jobBySlug.get(slug);
+    if (job) activeGroups.add(job.parallelGroup ?? 99);
+  }
+  for (const j of projectJobs) {
+    if (j.status === 'running' && !runningSlugsInProject.has(j.slug)) {
+      activeGroups.add(j.parallelGroup ?? 99);
+    }
+  }
+
+  if (activeGroups.size > 0) {
+    const lowestActive = Math.min(...activeGroups);
+    if (lowestPendingGroup > lowestActive) {
+      // Earlier group still running — wait for it to drain before advancing.
+      console.log(
+        `[scheduler] concurrency [${projectCwd}]: g${lowestActive} in flight, holding g${lowestPendingGroup}`,
+      );
+      return [];
+    }
+    if (lowestPendingGroup < lowestActive) {
+      // Late-arrival: a lower-numbered (higher-priority) PRD reconciled AFTER
+      // a higher-numbered group was already picked. Fire it now in parallel
+      // with the active group rather than starving it until drain.
+      if (slots <= 0) {
+        console.log(
+          `[scheduler] concurrency [${projectCwd}]: no slots for late-arrival g${lowestPendingGroup}`,
+        );
+        return [];
+      }
+      const batch = pending
+        .filter((j) => (j.parallelGroup ?? 99) === lowestPendingGroup)
+        .slice(0, slots);
+      console.log(
+        `[scheduler] concurrency [${projectCwd}]: firing late-arrival g${lowestPendingGroup} ` +
+        `(${batch.length} job(s)) alongside active g${lowestActive}`,
+      );
+      return batch;
+    }
+    // Backfill slots remaining in the current group.
+    if (slots <= 0) {
+      console.log(`[scheduler] concurrency [${projectCwd}]: cap reached, no slots`);
+      return [];
+    }
+    const batch = pending
+      .filter((j) => (j.parallelGroup ?? 99) === lowestActive)
+      .slice(0, slots);
+    if (batch.length > 0) {
+      console.log(
+        `[scheduler] concurrency [${projectCwd}]: backfilling ${batch.length} into g${lowestActive}`,
+      );
+    }
+    return batch;
+  }
+
+  // No active group — start the next group fresh.
+  if (slots <= 0) {
+    console.log(`[scheduler] concurrency [${projectCwd}]: cap reached, no slots`);
+    return [];
+  }
+  const batch = pending
+    .filter((j) => (j.parallelGroup ?? 99) === lowestPendingGroup)
+    .slice(0, slots);
+  console.log(
+    `[scheduler] concurrency [${projectCwd}]: starting g${lowestPendingGroup} with ${batch.length} job(s)`,
+  );
+  return batch;
+}
+
+/**
+ * Pick the next batch of jobs to spawn this tick.
+ *
+ * Group-ordering gates are evaluated PER PROJECT (keyed by cwd), so jobs in
+ * different projects are not serialized by each other's groups. Within a
+ * single project, the existing sequential-group semantics are fully preserved.
+ *
+ * O(N) where N = allJobs.length.
+ *
+ * @param {object[]} allJobs - Full queue.json job list.
+ * @param {Set<string>} running - In-process running slugs (runningSet).
+ * @param {number} cap - concurrencyCap.
+ * @returns {object[]} Jobs to spawn this tick.
+ */
+function pickNextBatch(allJobs, running, cap) {
+  if (!allJobs.some((j) => j.status === 'pending' && !running.has(j.slug))) return [];
+
+  // Global slot accounting: take the higher of in-process running count and
+  // queue.json running count (handles orphaned running entries from a previous
+  // session not yet reaped).
+  const queueRunningCount = allJobs.filter((j) => j.status === 'running').length;
+  const effectiveRunning = Math.max(running.size, queueRunningCount);
+  let slots = cap - effectiveRunning;
+  if (slots <= 0) {
+    console.log(
+      `[scheduler] concurrency: cap ${cap} reached (${effectiveRunning} running), no slots`,
+    );
+    return [];
+  }
+
+  // Group all jobs by project cwd.
+  const projectMap = new Map();
+  for (const job of allJobs) {
+    const key = job.cwd || DEFAULT_PROJECT_CWD;
+    if (!projectMap.has(key)) projectMap.set(key, []);
+    projectMap.get(key).push(job);
+  }
+
+  // Build per-project candidate list (only projects that have pending jobs).
+  const projectCandidates = [];
+  for (const [, projectJobs] of projectMap) {
+    const hasPending = projectJobs.some(
+      (j) => j.status === 'pending' && !running.has(j.slug),
+    );
+    if (!hasPending) continue;
+
+    const runningSlugsInProject = new Set(
+      projectJobs.filter((j) => running.has(j.slug)).map((j) => j.slug),
+    );
+    const lowestPendingForProject = projectJobs
+      .filter((j) => j.status === 'pending' && !running.has(j.slug))
+      .reduce((min, j) => Math.min(min, j.parallelGroup ?? 99), Infinity);
+
+    projectCandidates.push({ projectJobs, runningSlugsInProject, lowestPendingForProject });
+  }
+
+  // Sort by lowest pending group so earlier (higher-priority) groups win
+  // slot allocation ties across projects.
+  projectCandidates.sort((a, b) => a.lowestPendingForProject - b.lowestPendingForProject);
+
+  // Aggregate batch across projects, consuming global slots as we go.
+  const batch = [];
+  for (const { projectJobs, runningSlugsInProject } of projectCandidates) {
+    if (slots <= 0) break;
+    const projectBatch = pickForProject(projectJobs, runningSlugsInProject, slots);
+    batch.push(...projectBatch);
+    slots -= projectBatch.length;
+  }
+  return batch;
+}
+
+module.exports = { pickForProject, pickNextBatch, DEFAULT_PROJECT_CWD };