claude-code-session-manager 0.35.3 → 0.35.4

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

@@ -0,0 +1,137 @@
+/**
+ * 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 120 node --test src/main/__tests__/chat-mcp-consent-notice.test.cjs
+ */
+
+'use strict';
+
+delete process.env.SM_CHAT_CONCURRENCY;
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+function writeStub(lines) {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = lines.map((l) => `process.stdout.write(${JSON.stringify(JSON.stringify(l))} + "\\n");`).join('\n');
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\nprocess.exit(0);\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+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: process.cwd(), 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: process.cwd(), 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__/mcpStatus.test.cjs

@@ -0,0 +1,61 @@
+/**
+ * mcpStatus.test.cjs — unit tests for the `claude mcp list` output parser.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/mcpStatus.test.cjs
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const { parseMcpList } = require('../mcpStatus.cjs');
+
+const SAMPLE = `Checking MCP server health…
+
+claude.ai Gmail: https://gmailmcp.googleapis.com/mcp/v1 - ✔ Connected
+fetch: uvx mcp-server-fetch - ✔ Connected
+n8n: bash /home/bilko/.config/n8n-mcp/run.sh - ✘ Failed to connect
+session-manager-scheduler: node scripts/scheduler-mcp-server.cjs - ⏸ Pending approval (run \`claude\` to approve)
+claude_design: https://api.anthropic.com/v1/design/mcp (HTTP) - ✔ Connected
+claude.ai Google Drive: https://drivemcp.googleapis.com/mcp/v1 - ! Needs authentication
+`;
+
+test('parses the captured claude mcp list sample', () => {
+  const servers = parseMcpList(SAMPLE);
+  assert.ok(servers.length >= 6, `expected >=6 servers, got ${servers.length}`);
+
+  const byName = Object.fromEntries(servers.map((s) => [s.name, s]));
+
+  assert.equal(byName['claude.ai Gmail'].status, 'connected');
+  assert.equal(byName['fetch'].status, 'connected');
+  assert.equal(byName['n8n'].status, 'failed');
+  assert.equal(byName['session-manager-scheduler'].status, 'pending');
+  assert.equal(byName['claude_design'].status, 'connected');
+  assert.equal(byName['claude_design'].transport, 'http');
+  assert.equal(byName['claude.ai Google Drive'].status, 'needs-auth');
+});
+
+test('ignores the header and blank lines', () => {
+  const servers = parseMcpList(SAMPLE);
+  assert.ok(!servers.some((s) => /Checking MCP server health/i.test(s.name)));
+});
+
+test('defaults transport to stdio for non-HTTP targets', () => {
+  const servers = parseMcpList(SAMPLE);
+  const byName = Object.fromEntries(servers.map((s) => [s.name, s]));
+  assert.equal(byName['n8n'].transport, 'stdio');
+  assert.equal(byName['fetch'].transport, 'stdio');
+});
+
+test('returns [] (not a throw) on empty input', () => {
+  assert.deepEqual(parseMcpList(''), []);
+});
+
+test('returns [] (not a throw) on garbage input', () => {
+  assert.deepEqual(parseMcpList('this is not\na valid mcp list output\n12345'), []);
+});
+
+test('returns [] on non-string input without throwing', () => {
+  assert.deepEqual(parseMcpList(null), []);
+  assert.deepEqual(parseMcpList(undefined), []);
+});

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/chatRunner.cjs

@@ -26,6 +26,7 @@
  *   chat:run:complete   { tabId, sessionId, finalMessage }
  *   chat:run:needs-input { tabId, sessionId, questions, raw }
  *   chat:run:error      { tabId, sessionId, message }
+ *   chat:run:notice     { tabId, sessionId, message }        — informational, not terminal
  */
 
 const { spawn } = require('node:child_process');
@@ -71,6 +72,32 @@ function parseStopSignal(finalText) {
   }
 }
 
+// ─── MCP consent-denial detection ──────────────────────────────────────────
+// Best-effort substring heuristic over known CLI phrasing — NOT a documented
+// stream-json schema field. Confirmed by extracting strings from the compiled
+// `claude` CLI binary (2.1.207): a non-interactive/`-p` run that hits an
+// MCP server requiring first-party consent (e.g. `claude_design`) throws a
+// tool error whose message is exactly:
+//   "<tool label> The user hasn't granted this — run /design consent to
+//   grant it (it can't be approved automatically in this permission mode)."
+// which surfaces to stdout as a `tool_result` block (is_error: true) inside a
+// `type: "user"` stream-json event. Since consent flows exist for MCP servers
+// beyond `claude_design`, match on the generic phrasing rather than the
+// design-specific slash command.
+const MCP_CONSENT_DENIAL_MARKERS = [
+  "hasn't granted this",
+  'run /design consent',
+  'connect to claude design',
+  'requires consent',
+  'needs a claude.ai credential',
+];
+
+function hasMcpConsentDenial(text) {
+  if (typeof text !== 'string' || !text) return false;
+  const lower = text.toLowerCase();
+  return MCP_CONSENT_DENIAL_MARKERS.some((marker) => lower.includes(marker));
+}
+
 // Instruction prepended to every prompt. Tells the agent how to signal that
 // it needs clarification vs. having completed the task.
 const STOP_SIGNAL_INSTRUCTION =
@@ -188,6 +215,24 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume }) {
       broadcast(channel, payload);
     };
 
+    // Separate one-shot guard for the MCP-consent notice (orthogonal to
+    // terminalSent — a run can hit this mid-stream and still legitimately
+    // finish with a normal complete/error afterward).
+    let noticeSent = false;
+    const emitNoticeOnce = () => {
+      if (noticeSent) return;
+      noticeSent = true;
+      broadcast('chat:run:notice', {
+        tabId,
+        sessionId,
+        message:
+          'This run needs interactive consent for an MCP server (e.g. Claude Design), which ' +
+          "can't be granted in chat mode because stdin is closed for headless runs. Open a " +
+          'raw terminal session for this tab ("Back to chat" toggle) and grant consent there, ' +
+          'then retry.',
+      });
+    };
+
     const claudeBin = resolveClaudeBin();
     const childEnv = cleanChildEnv({ PATH: pathWithUserBins() });
 
@@ -285,6 +330,21 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume }) {
             broadcast('chat:run:tool-use', { tabId, id: block.id, ...classified });
           }
         }
+      } else if (event.type === 'user') {
+        // Tool results come back as content blocks on a synthetic "user" event.
+        // An MCP consent-denial surfaces here as an is_error tool_result whose
+        // text carries one of MCP_CONSENT_DENIAL_MARKERS.
+        const content = Array.isArray(event.message?.content) ? event.message.content : [];
+        for (const block of content) {
+          if (block.type !== 'tool_result') continue;
+          const inner = block.content;
+          const text = typeof inner === 'string'
+            ? inner
+            : Array.isArray(inner)
+              ? inner.filter((c) => c?.type === 'text' && typeof c.text === 'string').map((c) => c.text).join('\n')
+              : '';
+          if (hasMcpConsentDenial(text)) emitNoticeOnce();
+        }
       } else if (event.type === 'result') {
         // Use the authoritative `result` field when available; fall back to
         // accumulated assistant text (same content, different source).

package/src/main/index.cjs

@@ -14,6 +14,7 @@ const transcripts = require('./transcripts.cjs');
 const usageMatrix = require('./usageMatrix.cjs');
 const sessionsStore = require('./sessionsStore.cjs');
 const billing = require('./usage.cjs');
+const { probeMcpStatus } = require('./mcpStatus.cjs');
 const logs = require('./logs.cjs');
 const crashDiagnostics = require('./crashDiagnostics.cjs');
 // Start the local minidump collector before app-ready (required by Electron).
@@ -408,6 +409,10 @@ ipcMain.handle('app:launch-mode', () => ({
   cwd: process.cwd(),
 }));
 
+// MCP Servers tab (PRD 456 consumes this): probes live connection status via
+// `claude mcp list`. Read-only, single in-flight call — no polling.
+ipcMain.handle('mcp:status', () => probeMcpStatus());
+
 ipcMain.handle('app:engage-rules-path', () => process.env.SESSION_MANAGER_ENGAGE_RULES || null);
 
 // Boot diagnostics — renderer polls these to surface toasts when `claude` isn't

package/src/main/mcpStatus.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * mcpStatus.cjs — probes live MCP server connection status by shelling out to
+ * `claude mcp list` (a plain subcommand, no LLM call — no --model pin needed).
+ *
+ * Read-only, non-polling: only runs on explicit renderer request (mcp:status
+ * IPC). Coalesces concurrent callers onto a single in-flight probe so bursts
+ * don't fan out into parallel `claude` processes.
+ */
+
+const { spawn } = require('node:child_process');
+const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
+
+const PROBE_TIMEOUT_MS = 30_000;
+
+// One server line: "<name>: <target> - <glyph> <status text>"
+const LINE_RE = /^(.+?):\s(.+?)\s-\s(\S+)\s*(.*)$/;
+
+/**
+ * Pure parser — no I/O. Extracts { name, target, transport, status } per
+ * server line. Ignores the "Checking MCP server health…" header and blank
+ * lines. Never throws: unparseable input yields [].
+ */
+function parseMcpList(stdout) {
+  if (!stdout || typeof stdout !== 'string') return [];
+  const servers = [];
+  for (const rawLine of stdout.split('\n')) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.toLowerCase().startsWith('checking mcp server health')) continue;
+    const m = LINE_RE.exec(line);
+    if (!m) continue;
+    const [, name, target, glyph, statusText] = m;
+    const transport = /\(HTTP\)$/.test(target) || /^https?:\/\//i.test(target) ? 'http' : 'stdio';
+    let status;
+    if (glyph === '✔') status = 'connected';
+    else if (glyph === '✘') status = 'failed';
+    else if (glyph === '!') status = 'needs-auth';
+    else if (glyph === '⏸') status = 'pending';
+    else status = 'unknown';
+    servers.push({ name: name.trim(), target: target.trim(), transport, status, statusText: statusText.trim() });
+  }
+  return servers;
+}
+
+let inFlight = null;
+
+/** Spawns `claude mcp list`, parses it. Resolves — never rejects. */
+function runProbe() {
+  return new Promise((resolve) => {
+    let bin;
+    try { bin = resolveClaudeBin(); } catch (e) {
+      resolve({ ok: false, servers: [], error: `claude not found: ${e?.message}`, checkedAt: Date.now() });
+      return;
+    }
+    let child;
+    try {
+      child = spawn(bin, ['mcp', 'list'], { env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (e) {
+      resolve({ ok: false, servers: [], error: e?.message || 'spawn error', checkedAt: Date.now() });
+      return;
+    }
+    let out = '';
+    let err = '';
+    const MAX_OUT_BYTES = 1 * 1024 * 1024;
+    let settled = false;
+    const finish = (result) => { if (!settled) { settled = true; clearTimeout(timer); resolve(result); } };
+    const timer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch { /* */ }
+      finish({ ok: false, servers: [], error: 'timeout', checkedAt: Date.now() });
+    }, PROBE_TIMEOUT_MS);
+    child.stdout.on('data', (d) => { if (out.length < MAX_OUT_BYTES) out += d; });
+    child.stderr.on('data', (d) => { if (err.length < MAX_OUT_BYTES) err += d; });
+    child.on('error', (e) => { finish({ ok: false, servers: [], error: e?.message || 'spawn error', checkedAt: Date.now() }); });
+    child.on('close', (code) => {
+      if (code !== 0 && !out) {
+        finish({ ok: false, servers: [], error: err.slice(0, 500) || `exit ${code}`, checkedAt: Date.now() });
+        return;
+      }
+      finish({ ok: true, servers: parseMcpList(out), checkedAt: Date.now() });
+    });
+  });
+}
+
+/** Public entry point. Coalesces concurrent callers onto one in-flight probe. */
+function probeMcpStatus() {
+  if (inFlight) return inFlight;
+  inFlight = runProbe().finally(() => { inFlight = null; });
+  return inFlight;
+}
+
+module.exports = { probeMcpStatus, parseMcpList };