claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/__tests__/chat-exit-close-race.test.cjs

@@ -1,146 +0,0 @@
-/**
- * chat-exit-close-race.test.cjs — regression for the exit/close race that
- * silently dropped a pure-text-only final turn (PRD 716).
- *
- * Bug: the terminal-event fallback was wired to `child.on('exit', ...)`
- * instead of `child.on('close', ...)`. Node only guarantees all buffered
- * stdout 'data' events have been delivered by 'close', not 'exit' — 'exit'
- * can fire before the final stdout chunk (last assistant text + terminating
- * `result` line) reaches the parent's 'data' handler. When that happened,
- * the exit fallback ran first, set the one-shot terminalSent latch, and
- * broadcast a misleading chat:run:error. The real result line then parsed
- * moments later, but emitTerminal silently no-op'd and the genuine
- * chat:run:complete was dropped.
- *
- * Fix: use `child.on('close', ...)` for the fallback so it only fires once
- * Node guarantees stdout is fully drained — a real result event that arrives
- * (even "late", right up against process exit) always wins.
- *
- * This test mocks node:child_process.spawn so it can deterministically
- * reproduce the exact race ordering (exit fires, THEN the final stdout chunk
- * arrives, THEN close fires) rather than relying on real OS/pipe timing,
- * which is not reliably reproducible from a real child process.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-exit-close-race.test.cjs
- */
-
-'use strict';
-
-delete process.env.SM_CHAT_CONCURRENCY;
-
-import { test, afterAll } from 'vitest';
-const assert = require('node:assert/strict');
-const EventEmitter = require('node:events');
-const cp = require('node:child_process');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// Replace spawn BEFORE chatRunner.cjs is first required, so the module's
-// top-level `const { spawn } = require('node:child_process')` destructuring
-// captures this mock instead of the real implementation.
-const originalSpawn = cp.spawn;
-let nextChild = null;
-cp.spawn = () => {
-  const child = new EventEmitter();
-  child.stdout = new EventEmitter();
-  child.stderr = new EventEmitter();
-  child.pid = 424242;
-  child.kill = () => {};
-  nextChild = child;
-  return child;
-};
-
-const cr = require('../chatRunner.cjs');
-
-// Scratch project dir under os.tmpdir() — never the real repo root (opsErrorLog would pollute it).
-const scratchCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-cwd-'));
-
-const tick = () => new Promise((r) => setImmediate(r));
-
-test('a final-text-only turn whose stdout chunk lands after exit still surfaces chat:run:complete', async () => {
-  nextChild = null;
-  const events = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'show me a sample post', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 20 && !nextChild; i++) await tick();
-  const child = nextChild;
-  assert.ok(child, 'spawn should have been invoked');
-
-  const text = 'Here is your sample post, all in one go.';
-  const lines =
-    JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text }] } }) +
-    '\n' +
-    JSON.stringify({ type: 'result', subtype: 'success', result: text }) +
-    '\n';
-
-  // The exact race: 'exit' fires first (process already gone from the OS's
-  // perspective), the final stdout chunk is delivered to the 'data' handler
-  // only after that, and 'close' — which Node guarantees fires after all
-  // stdout data has been delivered — fires last.
-  child.emit('exit', 0, null);
-  child.stdout.emit('data', Buffer.from(lines));
-  child.emit('close', 0, null);
-
-  await tick();
-  await tick();
-
-  const terminal = events.filter((e) => isTerminal(e.channel));
-  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
-  assert.equal(
-    terminal[0].channel,
-    'chat:run:complete',
-    'the real result event must win over the generic exit-fallback error',
-  );
-  assert.equal(terminal[0].payload.finalMessage, text);
-});
-
-test('a crashed process with no result event ever emitted still fires the fallback chat:run:error', async () => {
-  nextChild = null;
-  const events = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T3', sessionId: 'S3', prompt: 'anything', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 20 && !nextChild; i++) await tick();
-  const child = nextChild;
-  assert.ok(child, 'spawn should have been invoked');
-
-  // Crashes with no stdout at all — 'close' is the only event that fires.
-  child.emit('close', 1, null);
-
-  await tick();
-  await tick();
-
-  const terminal = events.filter((e) => isTerminal(e.channel));
-  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
-  assert.equal(terminal[0].channel, 'chat:run:error', 'a crash with no result surfaces as an error turn');
-  assert.match(terminal[0].payload.message, /process exited without a result event/);
-});
-
-function isTerminal(channel) {
-  return (
-    channel === 'chat:run:complete' ||
-    channel === 'chat:run:needs-input' ||
-    channel === 'chat:run:error'
-  );
-}
-
-afterAll(() => {
-  cp.spawn = originalSpawn;
-  delete process.env.SM_CHAT_CONCURRENCY;
-});

package/src/main/__tests__/chat-mcp-consent-notice.test.cjs

@@ -1,139 +0,0 @@
-/**
- * chat-mcp-consent-notice.test.cjs — regression for the headless MCP-consent
- * hang: a chat run with stdin closed can never answer an MCP server's own
- * interactive consent flow (e.g. `/design consent`). This drives the real
- * stdout parser with a synthetic stream-json `tool_result` denial line and
- * asserts a `chat:run:notice` event is broadcast — informational, not a
- * terminal event.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-mcp-consent-notice.test.cjs
- */
-
-'use strict';
-
-delete process.env.SM_CHAT_CONCURRENCY;
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// Scratch project dir under os.tmpdir() — never the real repo root (opsErrorLog would pollute it).
-const scratchCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-cwd-'));
-const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
-
-function writeStub(lines) {
-  const body = lines.map((l) => `process.stdout.write(${JSON.stringify(JSON.stringify(l))} + "\\n");`).join('\n');
-  return claudeStub.writeClaudeStub({ body: `${body}\nprocess.exit(0);` });
-}
-
-function isTerminal(channel) {
-  return (
-    channel === 'chat:run:complete' ||
-    channel === 'chat:run:needs-input' ||
-    channel === 'chat:run:error'
-  );
-}
-
-test('MCP consent denial in a tool_result surfaces a chat:run:notice event', async () => {
-  const stubPath = writeStub([
-    {
-      type: 'user',
-      message: {
-        content: [
-          {
-            type: 'tool_result',
-            tool_use_id: 'toolu_1',
-            is_error: true,
-            content: [
-              {
-                type: 'text',
-                text:
-                  "Claude Design: write_files The user hasn't granted this — run /design consent " +
-                  "to grant it (it can't be approved automatically in this permission mode).",
-              },
-            ],
-          },
-        ],
-      },
-    },
-    { type: 'result', subtype: 'success', result: 'done anyway' },
-  ]);
-  process.env.SM_CLAUDE_BIN = stubPath;
-  delete require.cache[require.resolve('../chatRunner.cjs')];
-  const cr = require('../chatRunner.cjs');
-
-  const events = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T-notice', sessionId: 'S-notice', prompt: 'do a design thing', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 60 && !events.some((e) => isTerminal(e.channel)); i++) {
-    await new Promise((r) => setTimeout(r, 25));
-  }
-
-  const notice = events.find((e) => e.channel === 'chat:run:notice');
-  assert.ok(notice, 'chat:run:notice should be broadcast');
-  assert.match(notice.payload.message, /consent/i, 'message mentions consent');
-  assert.match(notice.payload.message, /terminal/i, 'message mentions the raw terminal session');
-
-  // Notice is informational, not terminal — the normal result still fires.
-  const terminal = events.filter((e) => isTerminal(e.channel));
-  assert.equal(terminal.length, 1, 'exactly one terminal event still fires');
-  assert.equal(terminal[0].channel, 'chat:run:complete');
-
-  try { fs.unlinkSync(stubPath); } catch { /* already gone */ }
-  delete process.env.SM_CLAUDE_BIN;
-});
-
-test('a normal tool_result with no consent marker does not fire chat:run:notice', async () => {
-  const stubPath = writeStub([
-    {
-      type: 'user',
-      message: {
-        content: [
-          {
-            type: 'tool_result',
-            tool_use_id: 'toolu_2',
-            is_error: false,
-            content: [{ type: 'text', text: 'Wrote 3 files successfully.' }],
-          },
-        ],
-      },
-    },
-    { type: 'result', subtype: 'success', result: 'all good' },
-  ]);
-  process.env.SM_CLAUDE_BIN = stubPath;
-  delete require.cache[require.resolve('../chatRunner.cjs')];
-  const cr = require('../chatRunner.cjs');
-
-  const events = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T-clean', sessionId: 'S-clean', prompt: 'do a normal thing', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 60 && !events.some((e) => isTerminal(e.channel)); i++) {
-    await new Promise((r) => setTimeout(r, 25));
-  }
-
-  assert.ok(
-    !events.some((e) => e.channel === 'chat:run:notice'),
-    'no chat:run:notice should fire for a clean tool_result (no false positive)',
-  );
-
-  try { fs.unlinkSync(stubPath); } catch { /* already gone */ }
-  delete process.env.SM_CLAUDE_BIN;
-});

package/src/main/__tests__/chat-preamble-anchors.test.cjs

@@ -1,100 +0,0 @@
-/**
- * chat-preamble-anchors.test.cjs — drift guard between chatRunner's injected
- * instruction blocks and the renderer's splitter that hides them.
- *
- * `src/renderer/lib/promptPreamble.ts` anchors each block on its FIRST and
- * LAST sentence only, because it cannot import this main-process .cjs. That
- * indirection is safe ONLY while those anchors still bracket the real text —
- * so this test composes the exact `fullPrompt` chatRunner builds and asserts
- * the splitter recovers the human's words exactly. Reword either block's
- * opening or closing sentence and this fails here, loudly, instead of the
- * boilerplate silently reappearing in every user bubble.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/chat-preamble-anchors.test.cjs
- */
-
-'use strict';
-
-const path = require('path');
-
-import { test, expect } from 'vitest';
-
-const { STOP_SIGNAL_INSTRUCTION, CHAT_MODE_TRUTH_INSTRUCTION } = require('../chatRunner.cjs');
-
-const HUMAN = 'Review the Alpaca limits and report back what we can trade for free.';
-
-async function loadSplitter() {
-  const mod = await import(
-    /* @vite-ignore */ path.resolve(__dirname, '..', '..', 'renderer', 'lib', 'promptPreamble.ts')
-  );
-  return mod;
-}
-
-test('the real fullPrompt splits back into exactly the human’s words', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  // Mirrors chatRunner's own composition at its `-p` call site.
-  const fullPrompt = STOP_SIGNAL_INSTRUCTION + CHAT_MODE_TRUTH_INSTRUCTION + HUMAN;
-
-  const split = splitInjectedPreamble(fullPrompt);
-  expect(split.body).toBe(HUMAN);
-  expect(split.blockKeys).toEqual(['stop-signal', 'chat-mode-truth']);
-  expect(split.preamble).toBeTruthy();
-  // Nothing is invented or lost: preamble + body reconstitute the input.
-  expect(split.preamble.length + split.body.length).toBeLessThanOrEqual(fullPrompt.length);
-  expect(fullPrompt.startsWith(split.preamble)).toBe(true);
-  expect(fullPrompt.endsWith(split.body)).toBe(true);
-});
-
-test('each block strips independently, so one being absent still works', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-
-  const onlyStop = splitInjectedPreamble(STOP_SIGNAL_INSTRUCTION + HUMAN);
-  expect(onlyStop.body).toBe(HUMAN);
-  expect(onlyStop.blockKeys).toEqual(['stop-signal']);
-
-  const onlyTruth = splitInjectedPreamble(CHAT_MODE_TRUTH_INSTRUCTION + HUMAN);
-  expect(onlyTruth.body).toBe(HUMAN);
-  expect(onlyTruth.blockKeys).toEqual(['chat-mode-truth']);
-});
-
-test('a prompt with no injected blocks is returned untouched', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  const split = splitInjectedPreamble(HUMAN);
-  expect(split.preamble).toBe(null);
-  expect(split.body).toBe(HUMAN);
-  expect(split.blockKeys).toEqual([]);
-});
-
-test('EDGE: a boilerplate-only prompt is NOT stripped to an empty bubble', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  const onlyBoilerplate = STOP_SIGNAL_INSTRUCTION + CHAT_MODE_TRUTH_INSTRUCTION;
-  const split = splitInjectedPreamble(onlyBoilerplate);
-  expect(split.preamble).toBe(null);
-  expect(split.body).toBe(onlyBoilerplate);
-});
-
-test('EDGE: a truncated block (opening present, closing missing) is left fully intact', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  // Simulates a reworded/cut-off block: better to over-show boilerplate than
-  // to guess at a boundary and eat the human's words.
-  const truncated = `${STOP_SIGNAL_INSTRUCTION.slice(0, 120)}\n\n${HUMAN}`;
-  const split = splitInjectedPreamble(truncated);
-  expect(split.preamble).toBe(null);
-  expect(split.body).toBe(truncated);
-});
-
-test('the two blocks strip in either order', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  const reversed = CHAT_MODE_TRUTH_INSTRUCTION + STOP_SIGNAL_INSTRUCTION + HUMAN;
-  const split = splitInjectedPreamble(reversed);
-  expect(split.body).toBe(HUMAN);
-  expect(split.blockKeys).toEqual(['chat-mode-truth', 'stop-signal']);
-});
-
-test('EDGE: boilerplate quoted inside the human’s own message is never stripped', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  const quoting = `Why does chat prepend this?\n\n${STOP_SIGNAL_INSTRUCTION}`;
-  const split = splitInjectedPreamble(quoting);
-  expect(split.preamble).toBe(null);
-  expect(split.body).toBe(quoting);
-});

package/src/main/__tests__/chat-queue.test.cjs

@@ -1,97 +0,0 @@
-/**
- * chat-queue.test.cjs — unit tests for the chatRunner serial run queue (v0.34).
- * Asserts the "up to two loops at a time" guarantee: SILENT (automated probe)
- * runs execute up to the concurrency cap in FIFO order, and a queued
- * (not-yet-started) silent run can be cancelled without running. PRD 493:
- * this cap/FIFO governs silent runs only — manual runs bypass it entirely
- * (see chatRunner.spec.ts's "manual runs are uncapped" tests).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-queue.test.cjs
- */
-
-'use strict';
-
-// Force the default cap (2) regardless of the developer's shell env.
-delete process.env.SM_CHAT_CONCURRENCY;
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const cr = require('../chatRunner.cjs');
-
-const tick = () => new Promise((r) => setImmediate(r));
-const job = (id) => ({ tabId: id, sessionId: id, prompt: 'x', cwd: '/', resume: true, silent: true });
-
-test('runs execute up to the concurrency cap in FIFO order', async () => {
-  const order = [];
-  let active = 0;
-  let maxActive = 0;
-  // Stub the spawn: each run resolves on the next tick, so the queue must
-  // advance via the pump's finally hook for C to ever run.
-  cr.__setExecutor((j) => {
-    active += 1;
-    maxActive = Math.max(maxActive, active);
-    order.push(j.tabId);
-    return new Promise((res) => setImmediate(() => { active -= 1; res(); }));
-  });
-
-  cr.run(job('A'));
-  cr.run(job('B'));
-  cr.run(job('C'));
-
-  // Drain the queue (each run takes one tick; allow generous headroom).
-  for (let i = 0; i < 12 && order.length < 3; i++) await tick();
-  await tick();
-
-  assert.equal(maxActive, 2, 'up to two runs active at once under the default cap');
-  assert.deepEqual(order, ['A', 'B', 'C'], 'runs execute in FIFO order');
-
-  cr.__setExecutor(null); // restore real executor
-});
-
-test('cancelling a queued run drops it without executing', async () => {
-  const order = [];
-  cr.__setExecutor((j) => {
-    order.push(j.tabId);
-    return new Promise((res) => setImmediate(res));
-  });
-
-  // X and Y each take one of the two lanes; Z queues behind them. Cancel Z
-  // before a lane frees.
-  cr.run(job('X'));
-  cr.run(job('Y'));
-  cr.run(job('Z'));
-  cr.cancel('Z'); // Z is still in the waiting list — drop it
-
-  for (let i = 0; i < 8; i++) await tick();
-
-  assert.deepEqual(order, ['X', 'Y'], 'only X and Y ran; Z was cancelled while queued');
-
-  cr.__setExecutor(null);
-});
-
-test('a queued silent run never broadcasts chat:run:queued (silent runs stay invisible to the renderer)', async () => {
-  const sent = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
-  });
-  cr.__setExecutor((j) => new Promise((res) => setImmediate(res)));
-
-  // P and Q take the two lanes under the default cap; R queues behind them —
-  // this is the only path that ever populates chatRunner's `waiting` list,
-  // and every job on it is silent (manual runs bypass the queue entirely).
-  cr.run(job('P'));
-  cr.run(job('Q'));
-  cr.run(job('R'));
-
-  for (let i = 0; i < 8; i++) await tick();
-
-  assert.equal(
-    sent.filter((s) => s.channel === 'chat:run:queued').length,
-    0,
-    'no chat:run:queued broadcast for a silent (automated probe) run',
-  );
-
-  cr.__setExecutor(null);
-  cr.attachWindow(null);
-});

package/src/main/__tests__/chat-stop-signal.test.cjs

@@ -1,89 +0,0 @@
-/**
- * chat-stop-signal.test.cjs — unit tests for chatRunner.parseStopSignal, the
- * single source of truth for the terminal-chat stop-signal protocol (PRD 318).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-stop-signal.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { parseStopSignal, STOP_SENTINEL } = require('../chatRunner.cjs');
-
-test('sentinel present with valid JSON → questions array', () => {
-  const text =
-    'I did some work but need to know which target.\n' +
-    `${STOP_SENTINEL}\n` +
-    '{"questions":["Which environment?","Overwrite existing config?"]}';
-  const out = parseStopSignal(text);
-  assert.deepEqual(out, {
-    questions: ['Which environment?', 'Overwrite existing config?'],
-  });
-});
-
-test('sentinel absent → null (run is complete)', () => {
-  const text = 'All done. I created the file and the tests pass.';
-  assert.equal(parseStopSignal(text), null);
-});
-
-test('sentinel present but malformed JSON → null (treated as complete, no crash)', () => {
-  const text = `Here is a summary.\n${STOP_SENTINEL}\n{questions: [oops not json}`;
-  assert.equal(parseStopSignal(text), null);
-});
-
-test('sentinel present but JSON lacks questions array → null', () => {
-  const text = `${STOP_SENTINEL}\n{"foo":"bar"}`;
-  assert.equal(parseStopSignal(text), null);
-});
-
-test('non-string input → null (no crash)', () => {
-  assert.equal(parseStopSignal(undefined), null);
-  assert.equal(parseStopSignal(null), null);
-  assert.equal(parseStopSignal(42), null);
-});
-
-test('only the LAST sentinel occurrence is parsed', () => {
-  const text =
-    `${STOP_SENTINEL}\n{"questions":["stale earlier block"]}\n` +
-    'then the agent kept working...\n' +
-    `${STOP_SENTINEL}\n{"questions":["the real question"]}`;
-  assert.deepEqual(parseStopSignal(text), { questions: ['the real question'] });
-});
-
-test('blank lines between sentinel and JSON → questions array', () => {
-  const text = `${STOP_SENTINEL}\n\n\n{"questions":["Which environment?"]}`;
-  assert.deepEqual(parseStopSignal(text), { questions: ['Which environment?'] });
-});
-
-test('JSON wrapped in a ```json code fence → questions array', () => {
-  const text =
-    `${STOP_SENTINEL}\n` +
-    '```json\n' +
-    '{"questions":["Overwrite existing config?"]}\n' +
-    '```';
-  assert.deepEqual(parseStopSignal(text), { questions: ['Overwrite existing config?'] });
-});
-
-test('pretty-printed multi-line JSON → questions array', () => {
-  const text =
-    `${STOP_SENTINEL}\n` +
-    '{\n' +
-    '  "questions": [\n' +
-    '    "Which environment?",\n' +
-    '    "Overwrite existing config?"\n' +
-    '  ]\n' +
-    '}';
-  assert.deepEqual(parseStopSignal(text), {
-    questions: ['Which environment?', 'Overwrite existing config?'],
-  });
-});
-
-test('trailing prose after the closing brace → questions array', () => {
-  const text =
-    `${STOP_SENTINEL}\n` +
-    '{"questions":["Which environment?"]}\n' +
-    '\n' +
-    'Let me know and I will continue.';
-  assert.deepEqual(parseStopSignal(text), { questions: ['Which environment?'] });
-});