claude-code-session-manager 0.35.2 → 0.35.3

package/src/main/__tests__/adminServer.test.cjs

@@ -0,0 +1,175 @@
+/**
+ * adminServer.test.cjs — unit tests for the loopback-only scheduler admin API.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/adminServer.test.cjs
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { createAdminServer } = require('../adminServer.cjs');
+
+function request(port, { method = 'GET', path: reqPath, token, body }) {
+  return new Promise((resolve, reject) => {
+    const headers = {};
+    if (token !== undefined) headers.Authorization = `Bearer ${token}`;
+    let payload;
+    if (body !== undefined) {
+      payload = JSON.stringify(body);
+      headers['Content-Type'] = 'application/json';
+      headers['Content-Length'] = Buffer.byteLength(payload);
+    }
+    const req = http.request({ hostname: '127.0.0.1', port, method, path: reqPath, headers }, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        let json = null;
+        try { json = JSON.parse(text); } catch { /* leave null for non-JSON bodies */ }
+        resolve({ status: res.statusCode, json, text });
+      });
+    });
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+function makeFakeRemote({ jobs = [] } = {}) {
+  return {
+    async listJobs() {
+      return jobs.map((j) => ({ slug: j.slug, title: j.title, status: j.status, cwd: j.cwd }));
+    },
+    async resetJob(slug) {
+      const job = jobs.find((j) => j.slug === slug);
+      if (!job) return { ok: false, error: 'not found' };
+      job.status = 'pending';
+      job.runId = null;
+      job.startedAt = null;
+      job.finishedAt = null;
+      job.exitCode = null;
+      job.error = null;
+      delete job.runtime;
+      delete job.verifierVerdict;
+      return { ok: true, slug, status: 'pending' };
+    },
+  };
+}
+
+test('request without bearer token returns 401', async () => {
+  const remote = makeFakeRemote();
+  const admin = createAdminServer(remote);
+  const { port } = await admin.start();
+  try {
+    const res = await request(port, { path: '/admin/scheduler/jobs' });
+    assert.strictEqual(res.status, 401);
+    assert.strictEqual(res.json.ok, false);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('request with wrong bearer token returns 401', async () => {
+  const remote = makeFakeRemote();
+  const admin = createAdminServer(remote);
+  const { port } = await admin.start();
+  try {
+    const res = await request(port, { path: '/admin/scheduler/jobs', token: 'not-the-token' });
+    assert.strictEqual(res.status, 401);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('GET /admin/scheduler/jobs with correct token returns 200 + array', async () => {
+  const remote = makeFakeRemote({
+    jobs: [{ slug: '10-foo', title: 'Foo', status: 'completed', cwd: '/tmp/foo' }],
+  });
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const res = await request(port, { path: '/admin/scheduler/jobs', token });
+    assert.strictEqual(res.status, 200);
+    assert.ok(Array.isArray(res.json));
+    assert.strictEqual(res.json.length, 1);
+    assert.strictEqual(res.json[0].slug, '10-foo');
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/reset-job with unknown slug returns ok:false', async () => {
+  const remote = makeFakeRemote({ jobs: [] });
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/reset-job', token, body: { slug: 'does-not-exist' },
+    });
+    assert.strictEqual(res.status, 200);
+    assert.strictEqual(res.json.ok, false);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/reset-job with known slug flips job to pending and clears run fields', async () => {
+  const job = {
+    slug: '10-foo',
+    title: 'Foo',
+    status: 'completed',
+    cwd: '/tmp/foo',
+    runId: 'run-1',
+    startedAt: 100,
+    finishedAt: 200,
+    exitCode: 0,
+    error: null,
+    runtime: { pid: 1234 },
+    verifierVerdict: 'PASS',
+  };
+  const remote = makeFakeRemote({ jobs: [job] });
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/reset-job', token, body: { slug: '10-foo' },
+    });
+    assert.strictEqual(res.status, 200);
+    assert.deepStrictEqual(res.json, { ok: true, slug: '10-foo', status: 'pending' });
+    assert.strictEqual(job.status, 'pending');
+    assert.strictEqual(job.runId, null);
+    assert.strictEqual(job.startedAt, null);
+    assert.strictEqual(job.finishedAt, null);
+    assert.strictEqual(job.exitCode, null);
+    assert.strictEqual(job.error, null);
+    assert.strictEqual('runtime' in job, false);
+    assert.strictEqual('verifierVerdict' in job, false);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('unknown path/method returns 404', async () => {
+  const remote = makeFakeRemote();
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const res = await request(port, { path: '/admin/scheduler/nope', token });
+    assert.strictEqual(res.status, 404);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('server binds only to 127.0.0.1', async () => {
+  const remote = makeFakeRemote();
+  const admin = createAdminServer(remote);
+  await admin.start();
+  try {
+    assert.strictEqual(admin.server.address().address, '127.0.0.1');
+  } finally {
+    await admin.stop();
+  }
+});

package/src/main/__tests__/runVerify.test.cjs

@@ -285,7 +285,7 @@ test('Truly clean run (no error markers) → clean/null', async () => {
       {
         type: 'result',
         subtype: 'success',
-        result: 'Feature complete. All acceptance criteria satisfied.',
+        result: 'Feature complete. All acceptance criteria satisfied.\nSCHEDULER_VERDICT: PASS',
       },
     ];
 
@@ -367,7 +367,7 @@ test('FAIL recovered within 30 events → clean', async () => {
       {
         type: 'result',
         subtype: 'success',
-        result: 'Fixed the failing test and verified all pass.',
+        result: 'Fixed the failing test and verified all pass.\nSCHEDULER_VERDICT: PASS',
       },
     ];
 
@@ -416,7 +416,7 @@ function bashRunEvents(content, { toolName = 'Bash', resultSubtype = 'success' }
         }],
       },
     },
-    { type: 'result', subtype: resultSubtype, result: 'All acceptance criteria verified.' },
+    { type: 'result', subtype: resultSubtype, result: 'All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS' },
   ];
 }
 
@@ -568,7 +568,7 @@ test('harness tool error (<tool_use_error>) in final 20% → clean', async () =>
     events.push({ type: 'user', message: { role: 'user', content: [
       { type: 'tool_result', tool_use_id: 'tbad',
         content: '<tool_use_error>Error: No such tool available: bash</tool_use_error>', is_error: true }] } });
-    events.push({ type: 'result', subtype: 'success', result: 'All acceptance criteria verified.' });
+    events.push({ type: 'result', subtype: 'success', result: 'All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS' });
 
     writeLog(tmp, slug, events);
     const prdPath = writePrd(tmp, slug, '# Correctness batch');
@@ -809,6 +809,76 @@ test('no sentinel + committed + allowPreSentinelHeal=false (default) → transcr
   }
 });
 
+// ─── no_verdict_sentinel: no commit + no sentinel is not "clean" by default ──
+
+/** A run with zero tool_result pattern hits — e.g. the agent asked a
+ *  clarifying question and stopped, ending its turn without touching tools. */
+function noOpRunEvents(resultText) {
+  return [
+    { type: 'result', subtype: 'success', result: resultText },
+  ];
+}
+
+test('no_verdict_sentinel: no tool_result issues, no sentinel, no commit → needs_review', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '406-browser-capture-panel-ui';
+    writeLog(tmp, slug, noOpRunEvents('I need clarification on which capture API to target before proceeding.'));
+    const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'no_verdict_sentinel', `expected no_verdict_sentinel, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('no_verdict_sentinel guard: same run but committedDuringRun:true → stays clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '406-browser-capture-panel-ui-committed';
+    writeLog(tmp, slug, noOpRunEvents('I need clarification on which capture API to target before proceeding.'));
+    const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: true,
+    });
+    assert.equal(verdict.verdict, 'clean', `commit landed should stay clean, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('no_verdict_sentinel guard: same run but with SCHEDULER_VERDICT: PASS sentinel → stays clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '406-browser-capture-panel-ui-sentinel';
+    writeLog(tmp, slug, noOpRunEvents('All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'clean', `PASS sentinel should stay clean, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
 // (e) halt + sentinel PASS → still halt (override must not apply to halt)
 test('halt result + sentinel PASS + committedDuringRun:true → still halt', async () => {
   const tmp = makeTmpDir();

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