claude-code-session-manager 0.37.1 → 0.38.0

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

@@ -0,0 +1,140 @@
+/**
+ * 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 120 node --test src/main/__tests__/chat-exit-close-race.test.cjs
+ */
+
+'use strict';
+
+delete process.env.SM_CHAT_CONCURRENCY;
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const EventEmitter = require('node:events');
+const cp = require('node:child_process');
+
+// 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');
+
+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: process.cwd(), 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: process.cwd(), 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'
+  );
+}
+
+test.after(() => {
+  cp.spawn = originalSpawn;
+  delete process.env.SM_CHAT_CONCURRENCY;
+});

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

@@ -0,0 +1,90 @@
+/**
+ * classifyTranscriptLine.test.cjs — unit tests for src/main/lib/classifyTranscriptLine.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/classifyTranscriptLine.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+
+const { classifyLine, trimContentArray, makeRaw, MAX_RAW_STR, EXEMPT_TYPES } = require('../lib/classifyTranscriptLine.cjs');
+
+test('classifyLine returns null for non-object input', () => {
+  expect(classifyLine(null)).toBeNull();
+  expect(classifyLine('not an object')).toBeNull();
+});
+
+test('classifyLine tags usage events', () => {
+  const ev = classifyLine({ usage: { input_tokens: 10, output_tokens: 5 } });
+  expect(ev.kind).toBe('usage');
+  expect(ev.data).toEqual({ input_tokens: 10, output_tokens: 5 });
+});
+
+test('classifyLine tags TodoWrite tool_use as todo_write', () => {
+  const ev = classifyLine({
+    message: { content: [{ type: 'tool_use', name: 'TodoWrite', input: { todos: [{ content: 'x' }] } }] },
+  });
+  expect(ev.kind).toBe('todo_write');
+  expect(ev.data).toEqual([{ content: 'x' }]);
+});
+
+test('classifyLine tags ExitPlanMode as plan', () => {
+  const ev = classifyLine({
+    message: { content: [{ type: 'tool_use', name: 'ExitPlanMode', input: { plan: 'do things' } }] },
+  });
+  expect(ev.kind).toBe('plan');
+});
+
+test('classifyLine tags Agent/Task tool_use as agent_spawn with toolUseId', () => {
+  const ev = classifyLine({
+    message: { content: [{ type: 'tool_use', name: 'Agent', id: 'tool-1', input: { description: 'do work' } }] },
+  });
+  expect(ev.kind).toBe('agent_spawn');
+  expect(ev.data.toolUseId).toBe('tool-1');
+});
+
+test('classifyLine tags generic tool_use blocks', () => {
+  const ev = classifyLine({
+    message: { content: [{ type: 'tool_use', name: 'Bash', id: 'tool-2', input: { command: 'ls' } }] },
+  });
+  expect(ev.kind).toBe('tool_use');
+  expect(ev.data).toEqual({ name: 'Bash', input: { command: 'ls' }, id: 'tool-2' });
+});
+
+test('classifyLine tags tool_result blocks with toolUseId', () => {
+  const ev = classifyLine({
+    message: { content: [{ type: 'tool_result', tool_use_id: 'tool-1' }] },
+  });
+  expect(ev.kind).toBe('tool_result');
+  expect(ev.data).toEqual({ toolUseId: 'tool-1' });
+});
+
+test('classifyLine falls back to message kind', () => {
+  const ev = classifyLine({ type: 'assistant', message: { content: 'hello' } });
+  expect(ev.kind).toBe('assistant');
+});
+
+test('trimContentArray passes through non-array input', () => {
+  expect(trimContentArray('not-an-array')).toBe('not-an-array');
+});
+
+test('trimContentArray truncates long text fields past MAX_RAW_STR', () => {
+  const longText = 'a'.repeat(MAX_RAW_STR + 100);
+  const [block] = trimContentArray([{ type: 'text', text: longText }]);
+  expect(block.text.length).toBe(MAX_RAW_STR + 1);
+  expect(block.text.endsWith('…')).toBe(true);
+});
+
+test('trimContentArray leaves EXEMPT_TYPES blocks untouched', () => {
+  expect(EXEMPT_TYPES.has('tool_result')).toBe(true);
+  expect(EXEMPT_TYPES.has('tool_use')).toBe(true);
+  const longText = 'a'.repeat(MAX_RAW_STR + 100);
+  const [block] = trimContentArray([{ type: 'tool_use', text: longText }]);
+  expect(block.text.length).toBe(longText.length);
+});
+
+test('makeRaw builds slim projection from message content', () => {
+  const raw = makeRaw({ message: { content: [{ type: 'text', text: 'hi' }] } });
+  expect(raw.message.content).toEqual([{ type: 'text', text: 'hi' }]);
+});

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

@@ -6,10 +6,27 @@
 
 'use strict';
 
-import { test, expect, describe } from 'vitest';
-const { parseDocEdit } = require('../docEdit.cjs');
+import { test, expect, describe, beforeEach, vi } from 'vitest';
+
+// docEdit.cjs requires chatRunner.cjs at module scope and calls `chatRunner.run(...)`
+// as a property access, so patching `run` on the already-required (cached) module
+// object — before docEdit.cjs's own require resolves to the same singleton — is
+// enough to intercept it, mirroring the exchanges.cjs patch pattern in chatRunner.spec.ts.
+const chatRunnerModule = require('../chatRunner.cjs');
+const runCalls = [];
+beforeEach(() => { runCalls.length = 0; });
+chatRunnerModule.run = (opts) => { runCalls.push(opts); };
+
+const { parseDocEdit, editPrompt, truncateDocumentText, MAX_DOC_CONTEXT, docEditViaSession, attachWindow } = require('../docEdit.cjs');
 const { duplicateNameFor } = require('../files.cjs');
 
+const broadcasts = [];
+attachWindow({
+  isDestroyed: () => false,
+  webContents: { isDestroyed: () => false, send: (channel, payload) => broadcasts.push({ channel, payload }) },
+});
+beforeEach(() => { broadcasts.length = 0; });
+
 describe('parseDocEdit', () => {
   test('valid JSON', () => {
     const result = parseDocEdit('{"after":"rewritten text"}');
@@ -57,6 +74,151 @@ describe('parseDocEdit', () => {
   });
 });
 
+describe('editPrompt', () => {
+  test('omits the document block when documentText is absent', () => {
+    const prompt = editPrompt('selected text', 'make it concise');
+    expect(prompt).not.toMatch(/<document_/);
+  });
+
+  test('includes a nonce-tagged document block when documentText is provided', () => {
+    const prompt = editPrompt('selected text', 'make it concise', 'the whole document');
+    expect(prompt).toMatch(/<document_[0-9a-f]+>/);
+    expect(prompt).toContain('the whole document');
+  });
+
+  test('truncates an oversized documentText before embedding it', () => {
+    const huge = 'x'.repeat(MAX_DOC_CONTEXT + 5000);
+    const prompt = editPrompt('selected text', 'make it concise', huge);
+    expect(prompt).toContain('[...document truncated for length...]');
+    expect(prompt.length).toBeLessThan(huge.length + 2000);
+  });
+});
+
+describe('truncateDocumentText', () => {
+  test('passes short text through unchanged', () => {
+    expect(truncateDocumentText('short')).toBe('short');
+  });
+
+  test('truncates to the documented head+tail scheme rather than dropping or erroring', () => {
+    const head = 'H'.repeat(40000);
+    const tail = 'T'.repeat(20000);
+    const middle = 'M'.repeat(10000);
+    const result = truncateDocumentText(head + middle + tail);
+    expect(result).toBe(`${head}\n\n[...document truncated for length...]\n\n${tail}`);
+    expect(result).not.toContain('M');
+  });
+});
+
+describe('docEditViaSession', () => {
+  test('builds its prompt via the shared editPrompt and calls chatRunner.run with resume+silent', () => {
+    docEditViaSession({
+      tabId: 'tab-1',
+      sessionId: 'chat-session-1',
+      cwd: '/home/user/project',
+      before: 'old text',
+      instruction: 'make it punchier',
+      documentText: 'the whole document',
+      requestId: 'req-1',
+    });
+
+    expect(runCalls).toHaveLength(1);
+    const call = runCalls[0];
+    expect(call.tabId).toBe('tab-1');
+    expect(call.sessionId).toBe('chat-session-1');
+    expect(call.cwd).toBe('/home/user/project');
+    expect(call.resume).toBe(true);
+    expect(call.silent).toBe(true);
+    expect(typeof call.onSilentResult).toBe('function');
+
+    // The prompt is the shared editPrompt's output (nonce-tagged, so compare
+    // structurally rather than byte-for-byte) prefixed with the anti-injection
+    // system framing — not a second, forked prompt builder.
+    expect(call.prompt).toContain('Rewrite the SELECTION below per the INSTRUCTION');
+    expect(call.prompt).toMatch(/<selection_[0-9a-f]+>\nold text\n<\/selection_[0-9a-f]+>/);
+    expect(call.prompt).toContain('deterministic document-rewrite assistant');
+  });
+
+  test('onSilentResult parses the reply and broadcasts docedit:session-result', () => {
+    docEditViaSession({
+      tabId: 'tab-2',
+      sessionId: 'chat-session-2',
+      cwd: '/home/user/project',
+      before: 'old text',
+      instruction: 'shorten it',
+      requestId: 'req-2',
+    });
+
+    const { onSilentResult } = runCalls[runCalls.length - 1];
+    onSilentResult('{"after":"new text"}');
+    expect(broadcasts).toHaveLength(1);
+    expect(broadcasts[0]).toEqual({
+      channel: 'docedit:session-result',
+      payload: { tabId: 'tab-2', requestId: 'req-2', ok: true, after: 'new text' },
+    });
+  });
+
+  test('onSilentResult reports a parse failure as ok:false', () => {
+    docEditViaSession({
+      tabId: 'tab-3',
+      sessionId: 'chat-session-3',
+      cwd: '/home/user/project',
+      before: 'old text',
+      instruction: 'shorten it',
+      requestId: 'req-3',
+    });
+
+    const { onSilentResult } = runCalls[runCalls.length - 1];
+    onSilentResult('not json at all');
+    expect(broadcasts).toHaveLength(1);
+    expect(broadcasts[0].payload.ok).toBe(false);
+    expect(broadcasts[0].payload.error).toBeTruthy();
+  });
+
+  test('splits off the stop-signal protocol and reports it as a clarification request', () => {
+    docEditViaSession({
+      tabId: 'tab-4',
+      sessionId: 'chat-session-4',
+      cwd: '/home/user/project',
+      before: 'old text',
+      instruction: 'shorten it',
+      requestId: 'req-4',
+    });
+
+    const { onSilentResult } = runCalls[runCalls.length - 1];
+    onSilentResult('<<<SM_NEEDS_INPUT>>>\n{"questions":["which section?"]}');
+    expect(broadcasts).toHaveLength(1);
+    expect(broadcasts[0].payload.ok).toBe(false);
+    expect(broadcasts[0].payload.error).toContain('which section?');
+  });
+
+  test('times out and broadcasts a failure if chatRunner never calls onSilentResult (error/timeout/cancel/collision on the silent lane)', () => {
+    vi.useFakeTimers();
+    try {
+      docEditViaSession({
+        tabId: 'tab-5',
+        sessionId: 'chat-session-5',
+        cwd: '/home/user/project',
+        before: 'old text',
+        instruction: 'shorten it',
+        requestId: 'req-5',
+      });
+
+      // chatRunner.run() is a no-op stub in this test (never invokes
+      // onSilentResult) — nothing should broadcast until the bound elapses.
+      expect(broadcasts).toHaveLength(0);
+
+      vi.advanceTimersByTime(120_000);
+      expect(broadcasts).toHaveLength(1);
+      expect(broadcasts[0]).toEqual({
+        channel: 'docedit:session-result',
+        payload: { tabId: 'tab-5', requestId: 'req-5', ok: false, error: 'timed out waiting on the background session' },
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
+
 describe('duplicateNameFor', () => {
   test('fresh name — no collision', () => {
     const result = duplicateNameFor('/tmp/dir', 'notes.txt', () => false);