claude-code-session-manager 0.35.2 → 0.35.4

package/src/main/__tests__/scheduler-autofix-select.test.cjs

@@ -8,9 +8,10 @@
 
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
-const { selectAutoFixTargets } = require('../scheduler.cjs');
+const { selectAutoFixTargets, isUnresolvableNeedsReview } = require('../scheduler.cjs');
 
 const noSiblingOnDisk = () => false;
+const noRunDir = () => null;
 
 function makeJob(overrides = {}) {
   return {
@@ -53,8 +54,55 @@ test('excludes a completed job', () => {
   assert.strictEqual(result.length, 0);
 });
 
-test('excludes a job missing runId', () => {
+test('excludes a job missing runId when no run dir resolves', () => {
   const jobs = [makeJob({ runId: null })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk, resolveJobRunId: noRunDir });
+  assert.strictEqual(result.length, 0);
+});
+
+test('selects a job missing runId when a run dir resolves (gap 1: runId backfill)', () => {
+  const jobs = [makeJob({ runId: null })];
+  const result = selectAutoFixTargets(jobs, {
+    fixSlugExists: noSiblingOnDisk,
+    resolveJobRunId: () => '2026-06-16T10-00-00-000Z',
+  });
+  assert.strictEqual(result.length, 1);
+});
+
+test('isUnresolvableNeedsReview: needs_review + no runId + no run dir → true', () => {
+  const job = makeJob({ runId: null });
+  assert.strictEqual(isUnresolvableNeedsReview(job, { hasRunDir: false }), true);
+});
+
+test('isUnresolvableNeedsReview: needs_review + no runId + has run dir → false', () => {
+  const job = makeJob({ runId: null });
+  assert.strictEqual(isUnresolvableNeedsReview(job, { hasRunDir: true }), false);
+});
+
+test('isUnresolvableNeedsReview: needs_review + runId present → false', () => {
+  const job = makeJob();
+  assert.strictEqual(isUnresolvableNeedsReview(job, { hasRunDir: false }), false);
+});
+
+test('isUnresolvableNeedsReview: non needs_review status → false', () => {
+  const job = makeJob({ runId: null, status: 'failed' });
+  assert.strictEqual(isUnresolvableNeedsReview(job, { hasRunDir: false }), false);
+});
+
+test('autoFixOutcome no-plan with retries=0 is retried', () => {
+  const jobs = [makeJob({ autoFixAttempted: true, autoFixOutcome: 'no-plan', autoFixRetries: 0 })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 1);
+});
+
+test('autoFixOutcome no-plan with retries=1 is exhausted (not selected)', () => {
+  const jobs = [makeJob({ autoFixAttempted: true, autoFixOutcome: 'no-plan', autoFixRetries: 1 })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 0);
+});
+
+test('autoFixAttempted true with no outcome recorded stays excluded (existing 1-attempt cap)', () => {
+  const jobs = [makeJob({ autoFixAttempted: true })];
   const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
   assert.strictEqual(result.length, 0);
 });

package/src/main/__tests__/scheduler-autopromote.test.cjs

@@ -8,7 +8,7 @@
 
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
-const { isPromotableOriginal } = require('../scheduler.cjs');
+const { isPromotableOriginal, healTargetForFix } = require('../scheduler.cjs');
 
 test('isPromotableOriginal: failed → true', () => {
   assert.strictEqual(isPromotableOriginal('failed'), true);
@@ -30,4 +30,22 @@ test('isPromotableOriginal: pending → false', () => {
   assert.strictEqual(isPromotableOriginal('pending'), false);
 });
 
+test('healTargetForFix: matches the specific original by full numeric-prefixed slug, not just base', () => {
+  const jobs = [
+    { slug: '451-foo', status: 'needs_review' },
+    { slug: '453-foo', status: 'needs_review' },
+  ];
+  const target = healTargetForFix('451-fix-foo', jobs);
+  assert.strictEqual(target.slug, '451-foo');
+});
+
+test('healTargetForFix: returns null when no promotable original matches', () => {
+  const jobs = [
+    { slug: '451-foo', status: 'completed' },
+    { slug: '453-foo', status: 'needs_review' },
+  ];
+  const target = healTargetForFix('451-fix-foo', jobs);
+  assert.strictEqual(target, null);
+});
+
 console.log('scheduler-autopromote tests: PASS');

package/src/main/adminServer.cjs

@@ -0,0 +1,157 @@
+/**
+ * adminServer.cjs — loopback-only HTTP admin API for the scheduler.
+ *
+ * Foundation for PRD 449 (an MCP server wraps this HTTP API). Exposes a
+ * narrow, token-authed surface so a same-machine script/tool can reset a
+ * stuck scheduler job or list jobs without hand-editing queue.json from
+ * outside the running app (which would race the in-process mutate() queue
+ * — see scheduler.cjs's serialized-mutation comment).
+ *
+ * Security posture:
+ *   - Binds 127.0.0.1 only, OS-assigned ephemeral port. Never reachable
+ *     off-box.
+ *   - Bearer token, regenerated every app boot, written to
+ *     ~/.claude/session-manager/admin-api.json with 0600 perms.
+ *   - Token compared with crypto.timingSafeEqual to avoid a timing
+ *     side-channel on the comparison itself.
+ *   - Only two routes: reset-job (one narrow mutation) and jobs (read-only
+ *     list). writePrd/pause/resume are intentionally NOT exposed here.
+ */
+
+'use strict';
+
+const http = require('node:http');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const fsp = require('node:fs/promises');
+const config = require('./config.cjs');
+
+const TOKEN_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'admin-api.json');
+
+function timingSafeEqualStrings(a, b) {
+  const bufA = Buffer.from(String(a ?? ''));
+  const bufB = Buffer.from(String(b ?? ''));
+  if (bufA.length !== bufB.length) {
+    // Compare against a same-length buffer anyway so the failure path still
+    // takes constant time relative to the (fixed) token length, rather than
+    // returning early on a length mismatch.
+    crypto.timingSafeEqual(bufA, bufA);
+    return false;
+  }
+  return crypto.timingSafeEqual(bufA, bufB);
+}
+
+function readBody(req, maxBytes = 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    let total = 0;
+    const chunks = [];
+    req.on('data', (chunk) => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        reject(new Error('body too large'));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    req.on('error', reject);
+  });
+}
+
+function sendJson(res, status, obj) {
+  const body = JSON.stringify(obj);
+  res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) });
+  res.end(body);
+}
+
+/**
+ * Create the admin HTTP server. `remote` is scheduler.cjs's remote object
+ * (injected, not required directly, so this module stays testable without
+ * booting Electron).
+ */
+function createAdminServer(remote) {
+  let server = null;
+  let token = null;
+
+  async function ensureToken() {
+    token = crypto.randomBytes(32).toString('hex');
+    await config.writeJson(TOKEN_PATH, { port: null, token });
+    try { await fsp.chmod(TOKEN_PATH, 0o600); } catch { /* best-effort on platforms without POSIX perms */ }
+    return token;
+  }
+
+  async function persistPort(port) {
+    await config.writeJson(TOKEN_PATH, { port, token });
+    try { await fsp.chmod(TOKEN_PATH, 0o600); } catch { /* */ }
+  }
+
+  function authorized(req) {
+    const header = req.headers.authorization || '';
+    const match = /^Bearer (.+)$/.exec(header);
+    if (!match) return false;
+    return timingSafeEqualStrings(match[1], token);
+  }
+
+  async function handleRequest(req, res) {
+    if (!authorized(req)) {
+      sendJson(res, 401, { ok: false, error: 'unauthorized' });
+      return;
+    }
+    try {
+      if (req.method === 'GET' && req.url === '/admin/scheduler/jobs') {
+        const jobs = await remote.listJobs();
+        sendJson(res, 200, jobs);
+        return;
+      }
+      if (req.method === 'POST' && req.url === '/admin/scheduler/reset-job') {
+        const raw = await readBody(req);
+        let parsed;
+        try {
+          parsed = raw ? JSON.parse(raw) : {};
+        } catch {
+          sendJson(res, 400, { ok: false, error: 'invalid JSON body' });
+          return;
+        }
+        const slug = typeof parsed.slug === 'string' ? parsed.slug : null;
+        if (!slug) {
+          sendJson(res, 400, { ok: false, error: 'missing slug' });
+          return;
+        }
+        const result = await remote.resetJob(slug);
+        sendJson(res, 200, result);
+        return;
+      }
+      sendJson(res, 404, { ok: false, error: 'not found' });
+    } catch (e) {
+      sendJson(res, 500, { ok: false, error: e?.message ?? 'internal error' });
+    }
+  }
+
+  async function start() {
+    await ensureToken();
+    server = http.createServer((req, res) => {
+      handleRequest(req, res).catch(() => {
+        try { sendJson(res, 500, { ok: false, error: 'internal error' }); } catch { /* */ }
+      });
+    });
+    await new Promise((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(0, '127.0.0.1', resolve);
+    });
+    const { port } = server.address();
+    await persistPort(port);
+    return { port, token };
+  }
+
+  async function stop() {
+    if (!server) return;
+    await new Promise((resolve) => server.close(() => resolve()));
+    server = null;
+  }
+
+  return { start, stop, get token() { return token; }, get server() { return server; } };
+}
+
+module.exports = { createAdminServer, TOKEN_PATH };