claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/lib/__tests__/buildTarget.test.cjs

@@ -1,52 +0,0 @@
-// buildTarget.cjs — resolves a project's publish destination for 'build'-tagged Epics.
-// vitest globals (test/beforeEach/afterEach) — same convention as the other .cjs tests.
-const assert = require('node:assert');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { resolveBuildTarget } = require('../buildTarget.cjs');
-
-let tmpDir;
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-build-target-'));
-});
-afterEach(() => {
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-
-test('explicit config file present is returned verbatim', () => {
-  const archDir = path.join(tmpDir, 'session-manager-operations', 'architecture');
-  fs.mkdirSync(archDir, { recursive: true });
-  const config = {
-    registry: 'npm',
-    packageName: 'my-pkg',
-    versionBumpPolicy: 'conventional-commits',
-    gates: ['typecheck'],
-  };
-  fs.writeFileSync(path.join(archDir, 'build-target.json'), JSON.stringify(config));
-
-  assert.deepEqual(resolveBuildTarget(tmpDir), config);
-});
-
-test('no config but package.json has name and is not private auto-discovers', () => {
-  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({ name: 'auto-pkg' }));
-
-  assert.deepEqual(resolveBuildTarget(tmpDir), {
-    registry: 'npm',
-    packageName: 'auto-pkg',
-    versionBumpPolicy: 'conventional-commits',
-    gates: [],
-    discovered: true,
-  });
-});
-
-test('no config and package.json is private returns null', () => {
-  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({ name: 'priv-pkg', private: true }));
-
-  assert.equal(resolveBuildTarget(tmpDir), null);
-});
-
-test('no config and no package.json returns null', () => {
-  assert.equal(resolveBuildTarget(tmpDir), null);
-});

package/src/main/lib/__tests__/childWithLog.test.cjs

@@ -1,321 +0,0 @@
-// PRD 1065 — post-exit process-group sweep. A detached job's descendants must
-// not outlive the job (2026-08-31 starry-night-ships incident: orphaned test
-// batteries reparented to init after their job exited normally).
-import { describe, it, expect, afterEach } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const { openLog, withChildAndLog, POST_EXIT_GROUP_SWEEP_GRACE_MS } = require('../childWithLog.cjs');
-
-let dir;
-
-afterEach(() => {
-  if (dir) fs.rmSync(dir, { recursive: true, force: true });
-  dir = undefined;
-});
-
-describe('childWithLog post-exit group sweep (PRD 1065)', () => {
-  it.skipIf(process.platform !== 'linux')(
-    'kills a detached child\'s backgrounded grandchild after exit + grace',
-    async () => {
-      dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-child-sweep-'));
-      const logPath = path.join(dir, 'job.log');
-      const pidFile = path.join(dir, 'grandchild.pid');
-      const { fd, safeLog, closeFd } = openLog(logPath);
-
-      const exited = new Promise((resolve) => {
-        withChildAndLog({
-          fd,
-          logPath,
-          safeLog,
-          closeFd,
-          spawn: {
-            command: 'sh',
-            args: [
-              '-c',
-              `sleep 30 & echo $! > ${pidFile}; exec sleep 0.2`,
-            ],
-            options: { detached: true },
-          },
-          onExit: () => resolve(),
-        });
-      });
-
-      await exited;
-
-      // Grandchild pid file is written by a backgrounded subshell that may
-      // race the parent's own exit; give it a moment to land.
-      for (let i = 0; i < 20 && !fs.existsSync(pidFile); i++) {
-        await new Promise((r) => setTimeout(r, 50));
-      }
-      expect(fs.existsSync(pidFile)).toBe(true);
-      const grandchildPid = Number(fs.readFileSync(pidFile, 'utf8').trim());
-      expect(Number.isInteger(grandchildPid) && grandchildPid > 1).toBe(true);
-
-      // Wait past the SIGTERM->SIGKILL grace window.
-      await new Promise((r) => setTimeout(r, POST_EXIT_GROUP_SWEEP_GRACE_MS + 1000));
-
-      expect(() => process.kill(grandchildPid, 0)).toThrow();
-    },
-    15000,
-  );
-});
-
-// PRD 1110 — the sweep above kills silently; onExit must also report what it
-// swept so a project whose jobs leak repeatedly can see it instead of
-// inferring it from ps.
-describe('childWithLog onExit leakedDescendants reporting (PRD 1110)', () => {
-  it.skipIf(process.platform !== 'linux')(
-    'reports the same backgrounded grandchild the sweep reaped',
-    async () => {
-      dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-child-leak-'));
-      const logPath = path.join(dir, 'job.log');
-      const pidFile = path.join(dir, 'grandchild.pid');
-      const { fd, safeLog, closeFd } = openLog(logPath);
-
-      const exitInfo = await new Promise((resolve) => {
-        withChildAndLog({
-          fd,
-          logPath,
-          safeLog,
-          closeFd,
-          spawn: {
-            command: 'sh',
-            args: [
-              '-c',
-              `sleep 30 & echo $! > ${pidFile}; exec sleep 0.2`,
-            ],
-            options: { detached: true },
-          },
-          onExit: (info) => resolve(info),
-        });
-      });
-
-      for (let i = 0; i < 20 && !fs.existsSync(pidFile); i++) {
-        await new Promise((r) => setTimeout(r, 50));
-      }
-      const grandchildPid = Number(fs.readFileSync(pidFile, 'utf8').trim());
-
-      expect(Array.isArray(exitInfo.leakedDescendants)).toBe(true);
-      expect(exitInfo.leakedDescendants.length).toBeGreaterThan(0);
-      const found = exitInfo.leakedDescendants.find((p) => p.pid === grandchildPid);
-      expect(found).toBeTruthy();
-      expect(found.comm).toBeTruthy();
-      expect(typeof found.pcpu).toBe('number');
-      expect(typeof found.etimes).toBe('number');
-
-      // Let the sweep's SIGTERM->SIGKILL cascade finish so the grandchild
-      // doesn't leak past this test.
-      await new Promise((r) => setTimeout(r, POST_EXIT_GROUP_SWEEP_GRACE_MS + 1000));
-    },
-    15000,
-  );
-
-  it.skipIf(process.platform !== 'linux')(
-    'reports [] for a clean job that leaked nothing',
-    async () => {
-      dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-child-clean-'));
-      const logPath = path.join(dir, 'job.log');
-      const { fd, safeLog, closeFd } = openLog(logPath);
-
-      const exitInfo = await new Promise((resolve) => {
-        withChildAndLog({
-          fd,
-          logPath,
-          safeLog,
-          closeFd,
-          spawn: {
-            command: 'sh',
-            args: ['-c', 'exit 0'],
-            options: { detached: true },
-          },
-          onExit: (info) => resolve(info),
-        });
-      });
-
-      expect(exitInfo.leakedDescendants).toEqual([]);
-    },
-    15000,
-  );
-});
-
-// PRD 1353 — async enumeration must never block/alter the kill cascade, and a
-// throwing watchdog must not break the wall-clock kill path.
-describe('childWithLog async enumeration + guarded watchdog (PRD 1353)', () => {
-  const { _deps } = require('../childWithLog.cjs');
-  const realExecFile = _deps.execFile;
-  afterEach(() => { _deps.execFile = realExecFile; });
-
-  it.skipIf(process.platform !== 'linux')(
-    'enumeration failure omits the report, logs, and still kills the group',
-    async () => {
-      dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-child-enumfail-'));
-      const logPath = path.join(dir, 'job.log');
-      const pidFile = path.join(dir, 'grandchild.pid');
-      const { fd, safeLog, closeFd } = openLog(logPath);
-      _deps.execFile = (_c, _a, _o, cb) => { setImmediate(() => cb(new Error('ps boom'))); };
-
-      const exitInfo = await new Promise((resolve) => {
-        withChildAndLog({
-          fd, logPath, safeLog, closeFd,
-          spawn: {
-            command: 'sh',
-            args: ['-c', `sleep 30 & echo $! > ${pidFile}; exec sleep 0.2`],
-            options: { detached: true },
-          },
-          onExit: (info) => { info.safeLog('onExit-ran\n'); resolve(info); },
-        });
-      });
-      expect(exitInfo.leakedDescendants).toEqual([]);
-      for (let i = 0; i < 20 && !fs.existsSync(pidFile); i++) await new Promise((r) => setTimeout(r, 50));
-      const gc = Number(fs.readFileSync(pidFile, 'utf8').trim());
-      await new Promise((r) => setTimeout(r, 500)); // SIGTERM lands immediately, no grace wait
-      expect(() => process.kill(gc, 0)).toThrow();
-      expect(fs.readFileSync(logPath, 'utf8')).toContain('enumeration failed');
-    },
-    15000,
-  );
-
-  function runWatchdog(wd) {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-child-wd-'));
-    const logPath = path.join(dir, 'job.log');
-    const { fd, safeLog, closeFd } = openLog(logPath);
-    let handle;
-    const done = new Promise((resolve) => {
-      handle = withChildAndLog({
-        fd, logPath, safeLog, closeFd,
-        spawn: { command: 'sleep', args: ['5'], options: {} },
-        watchdogs: [{ label: 'w', intervalMs: 20, ...wd }],
-        onExit: resolve,
-      });
-    });
-    return { logPath, handle, done };
-  }
-
-  it('a throwing shouldFire does not stop a later tick firing the action', async () => {
-    let calls = 0;
-    let fired = 0;
-    const { handle, logPath, done } = runWatchdog({
-      shouldFire: () => { calls++; if (calls < 3) throw new Error('sf boom'); return true; },
-      action: (ctx) => { fired++; ctx.killedByWatchdog = 'w'; ctx.killTree('SIGTERM'); },
-    });
-    const info = await done;
-    expect(fired).toBe(1);
-    expect(info.killedByWatchdog).toBe('w');
-    expect(fs.readFileSync(logPath, 'utf8')).toContain('watchdog "w" threw: sf boom');
-    handle.cancel();
-  }, 10000);
-
-  it('a throwing action clears its interval and is logged', async () => {
-    let should = 0;
-    let acts = 0;
-    const { handle, logPath, done } = runWatchdog({
-      shouldFire: () => { should++; return true; },
-      action: () => { acts++; throw new Error('act boom'); },
-    });
-    await new Promise((r) => setTimeout(r, 200));
-    expect(acts).toBe(1);
-    expect(should).toBe(1);
-    expect(fs.readFileSync(logPath, 'utf8')).toContain('watchdog "w" threw: act boom');
-    handle.cancel();
-    await done;
-  }, 10000);
-});
-
-// PRD 1370 — enumerate BEFORE SIGTERM; no-enumeration paths stay synchronous.
-describe('childWithLog sweep ordering + sync paths (PRD 1370)', () => {
-  const { _deps } = require('../childWithLog.cjs');
-  const realExecFile = _deps.execFile;
-  const realKill = process.kill;
-  afterEach(() => { _deps.execFile = realExecFile; process.kill = realKill; });
-
-  function setup(name) {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), name));
-    const logPath = path.join(dir, 'job.log');
-    return { logPath, ...openLog(logPath) };
-  }
-
-  it.skipIf(process.platform !== 'linux').each([
-    ['successful', (cb) => cb(null, 'PID PGRP %CPU ELAPSED COMMAND\n')],
-    ['failing', (cb) => cb(new Error('ps boom'))],
-  ])('SIGTERM waits for the %s enumeration', async (label, respond) => {
-    const { logPath, fd, safeLog, closeFd } = setup('sm-child-order-');
-    let psCb;
-    _deps.execFile = (_c, _a, _o, cb) => { psCb = cb; };
-    const groupKills = [];
-    process.kill = (pid, sig) => {
-      if (pid < -1 && sig === 'SIGTERM') { groupKills.push(pid); return true; }
-      return realKill.call(process, pid, sig);
-    };
-    let info;
-    const done = new Promise((resolve) => {
-      withChildAndLog({
-        fd, logPath, safeLog, closeFd,
-        spawn: { command: 'sh', args: ['-c', 'exit 0'], options: { detached: true } },
-        onExit: (i) => { info = i; resolve(); },
-      });
-    });
-    for (let i = 0; i < 100 && !psCb; i++) await new Promise((r) => setTimeout(r, 20));
-    expect(psCb).toBeTruthy();
-    await new Promise((r) => setTimeout(r, 100));
-    expect(groupKills).toEqual([]);
-    respond(psCb);
-    await done; // onExit runs only after the kill was issued
-    expect(groupKills.length).toBe(1);
-    expect(info.leakedDescendants).toEqual([]);
-    if (label === 'failing') expect(fs.readFileSync(logPath, 'utf8')).toContain('enumeration failed');
-  }, 15000);
-
-  it('runs onExit synchronously when the spawn throws', () => {
-    const { logPath, fd, safeLog, closeFd } = setup('sm-child-spawnfail-');
-    let ran = false;
-    const r = withChildAndLog({
-      fd, logPath, safeLog, closeFd,
-      spawn: { command: 'sh', args: [], options: { cwd: '/nonexistent\0bad', detached: true } },
-      onExit: (i) => { ran = i.spawnFailed === true; },
-    });
-    expect(r.child).toBeNull();
-    expect(ran).toBe(true);
-  });
-
-  it.skipIf(process.platform !== 'linux')('a throwing deferred onExit is logged and still closes the fd', async () => {
-    const { logPath, fd, safeLog, closeFd } = setup('sm-child-throw-');
-    _deps.execFile = (_c, _a, _o, cb) => { setImmediate(() => cb(null, 'h\n')); };
-    const unhandled = [];
-    const h = (e) => unhandled.push(e);
-    process.on('unhandledRejection', h);
-    let closed = false;
-    const wrapClose = () => { closed = true; closeFd(); };
-    await new Promise((resolve) => {
-      withChildAndLog({
-        fd, logPath, safeLog, closeFd: wrapClose,
-        spawn: { command: 'sh', args: ['-c', 'exit 0'], options: { detached: true } },
-        onExit: () => { setImmediate(resolve); throw new Error('exit boom'); },
-      });
-    });
-    await new Promise((r) => setTimeout(r, 50));
-    process.off('unhandledRejection', h);
-    expect(unhandled).toEqual([]);
-    expect(closed).toBe(true);
-    expect(fs.readFileSync(logPath, 'utf8')).toContain('onExit threw: exit boom');
-  }, 15000);
-
-  it('a throwing synchronous onExit is logged, closes the fd, and is re-thrown', async () => {
-    const { logPath, fd, safeLog, closeFd } = setup('sm-child-throw-sync-');
-    let closed = false;
-    const wrapClose = () => { closed = true; closeFd(); };
-    const thrown = await new Promise((resolve) => {
-      const onUncaught = (e) => { process.off('uncaughtException', onUncaught); resolve(e); };
-      process.on('uncaughtException', onUncaught);
-      withChildAndLog({
-        fd, logPath, safeLog, closeFd: wrapClose,
-        spawn: { command: 'sh', args: ['-c', 'exit 0'] },
-        onExit: () => { throw new Error('exit boom'); },
-      });
-    });
-    expect(thrown.message).toBe('exit boom');
-    expect(closed).toBe(true);
-    expect(fs.readFileSync(logPath, 'utf8')).toContain('onExit threw: exit boom');
-  }, 15000);
-});

package/src/main/lib/__tests__/coldBootPromptSessionsWrite.test.cjs

@@ -1,87 +0,0 @@
-/**
- * coldBootPromptSessionsWrite.test.cjs — regression coverage for the
- * "Epics marked Completed come back Open" bug.
- *
- * config.cjs's allowedRoots starts as just {os.homedir()}, and
- * validateWrite() explicitly skips the homedir root (a project cwd must be
- * registered via addAllowedRoot() before writeJson()/writeTextAtomic() will
- * accept a write under it). addAllowedRoot's only callers used to be pty.cjs
- * (Terminal spawn) and lib/prdCreate.cjs — never the Epic persistence path —
- * so on a cold boot, before any Terminal/PRD activity for a project, both
- * mergeActiveIndex's own write and the renderer's Epic-archive write
- * (config:write-json of promptSessionArchivePath) were silently rejected.
- *
- * Both cases below use a tmp dir INSIDE the homedir so validatePath (the
- * READ boundary, satisfied by the homedir root alone) succeeds while
- * validateWrite (which skips the homedir root, per config.cjs:113) still
- * requires an explicit per-project root registration — reproducing the
- * exact cold-boot gap without needing an out-of-home tmp root.
- *
- * Run: timeout 300 npx vitest run src/main/lib/__tests__/coldBootPromptSessionsWrite.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { mergeActiveIndex } = require('../activeIndexMerge.cjs');
-const { readActiveIndex } = require('../epicMint.cjs');
-const config = require('../../config.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkColdBootCwd(prefix) {
-  // Deliberately under homedir (so validatePath's read boundary passes via
-  // the default homedir root) and deliberately NOT registered via
-  // config.addAllowedRoot() — simulates the exact state of allowedRoots
-  // right after app boot, before any Terminal/PRD activity for this project.
-  const cwd = await fsp.mkdtemp(path.join(os.homedir(), prefix));
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-function session(id, overrides = {}) {
-  return {
-    id,
-    cwd: overrides.cwd || '/proj',
-    goalText: overrides.goalText || `goal for ${id}`,
-    claudeSessionId: overrides.claudeSessionId || `claude-${id}`,
-    status: overrides.status || 'active',
-    createdAt: overrides.createdAt || '2026-08-06T13:48:00.000Z',
-    completedAt: overrides.completedAt ?? null,
-  };
-}
-
-test('mergeActiveIndex writes active-index.json on a cold boot with only the homedir registered', async () => {
-  const cwd = await mkColdBootCwd('.sm-test-activeindex-coldboot-');
-  const s = session('psess-coldboot-1');
-
-  await mergeActiveIndex(cwd, { sessions: { [s.id]: s }, events: {} });
-
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[s.id]).toEqual(s);
-});
-
-// Mirrors what the 'config:write-json' IPC handler now does before calling
-// writeJson (config.cjs's registerPromptSessionsRoot) — the main-process fix
-// for state/promptSessions.ts's markCompleted -> writeJson(promptSessionArchivePath).
-test('an Epic archive write succeeds on a cold boot with only the homedir registered', async () => {
-  const cwd = await mkColdBootCwd('.sm-test-archive-coldboot-');
-  const archivePath = path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'psess-archived-1.json');
-  const archive = { ...session('psess-archived-1', { status: 'completed' }), completedAt: '2026-08-06T14:00:00.000Z' };
-
-  config.registerPromptSessionsRoot(archivePath);
-  await config.writeJson(archivePath, archive, { writer: 'epics' });
-
-  const result = await config.readJson(archivePath);
-  expect(result.exists).toBe(true);
-  expect(result.data).toEqual(archive);
-});

package/src/main/lib/__tests__/crashTelemetry.test.cjs

@@ -1,103 +0,0 @@
-/**
- * crashTelemetry.test.cjs — unit tests for the electron-free crash-report tap
- * crashDiagnostics.cjs's render-process-gone / child-process-gone hooks and
- * unclean-shutdown postmortem call into.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/crashTelemetry.test.cjs
- */
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const { reportCrash } = require('../crashTelemetry.cjs');
-
-const tmpDirs = [];
-let originalHome;
-let originalSmTelemetrySpool;
-
-afterEach(async () => {
-  if (originalHome !== undefined) process.env.HOME = originalHome;
-  if (originalSmTelemetrySpool === undefined) delete process.env.SM_TELEMETRY_SPOOL; else process.env.SM_TELEMETRY_SPOOL = originalSmTelemetrySpool;
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkHome() {
-  originalHome = process.env.HOME;
-  originalSmTelemetrySpool = process.env.SM_TELEMETRY_SPOOL;
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-crash-telemetry-home-'));
-  tmpDirs.push(dir);
-  process.env.HOME = dir;
-  // Explicit opt-in: overrides the test-environment no-op guard so this
-  // suite's real telemetryClient calls actually persist into an isolated dir.
-  process.env.SM_TELEMETRY_SPOOL = path.join(dir, '.claude', 'session-manager');
-  return dir;
-}
-
-function freshClient() {
-  for (const p of ['../telemetryClient.cjs', '../../config.cjs', '../telemetrySettings.cjs', '../machineProfile.cjs']) {
-    const resolved = require.resolve(p);
-    delete require.cache[resolved];
-  }
-  const client = require('../telemetryClient.cjs');
-  client._setMachineProfileBuilder(async () => ({
-    appVersion: '0.83.0', platform: 'linux', arch: 'x64', machineDigest: 'deadbeefcafe',
-  }));
-  return client;
-}
-
-async function readQueueLines(client) {
-  const fs = require('node:fs/promises');
-  try {
-    const raw = await fs.readFile(client.queuePath(), 'utf8');
-    return raw.split('\n').filter(Boolean).map((l) => JSON.parse(l));
-  } catch (e) {
-    if (e.code === 'ENOENT') return [];
-    throw e;
-  }
-}
-
-test('reportCrash names the record "crash.<reason>"', async () => {
-  await mkHome();
-  const client = freshClient();
-  await reportCrash({ reason: 'oom', meta: { type: 'render' }, deps: { telemetryClient: client } });
-  const [rec] = await readQueueLines(client);
-  expect(rec.wire.name).toBe('crash.oom');
-  client.shutdown();
-});
-
-test('a crash record carries the full attribution stamp: appVersion, platform, arch, machineDigest', async () => {
-  await mkHome();
-  const client = freshClient();
-  await reportCrash({ reason: 'killed', meta: { type: 'child', name: 'gpu' }, deps: { telemetryClient: client } });
-  const [rec] = await readQueueLines(client);
-  expect(rec.wire.version).toBe('0.83.0');
-  expect(rec.wire.context.platform).toBeTruthy();
-  expect(rec.wire.context.arch).toBeTruthy();
-  expect(rec.wire.context.machineDigest).toBeTruthy();
-  client.shutdown();
-});
-
-test('the unclean-shutdown postmortem is reported as crash.unclean-shutdown with the last memory sample', async () => {
-  await mkHome();
-  const client = freshClient();
-  await reportCrash({
-    reason: 'unclean-shutdown',
-    meta: { lastTotalMb: 1800, lastMainRssMb: 900, lastTop: ['renderer:900MB'] },
-    deps: { telemetryClient: client },
-  });
-  const [rec] = await readQueueLines(client);
-  expect(rec.wire.name).toBe('crash.unclean-shutdown');
-  expect(rec.wire.context.lastTotalMb).toBe(1800);
-  client.shutdown();
-});
-
-test('reportCrash never throws even when the injected telemetryClient throws', () => {
-  const throwingClient = { reportError: () => { throw new Error('telemetry boom'); } };
-  expect(() => reportCrash({ reason: 'oom', meta: {}, deps: { telemetryClient: throwingClient } })).not.toThrow();
-});

package/src/main/lib/__tests__/credentials-futile-refresh.test.cjs

@@ -1,115 +0,0 @@
-/**
- * credentials-futile-refresh.test.cjs — the 2026-09-23 credential-refresh
- * storm. On this machine the OAuth creds were expired with NO refresh token
- * (expiredAtMs 1775277875159). Every 15 s billing poll called refreshIfNeeded,
- * which tried the OAuth grant (instant 'unsupported' — no refresh token),
- * then spawned `claude --version` as a CLI fallback (which shares the same
- * missing token, so it can't help either), then logged auth_failed_expired —
- * the identical triple, forever, spawning a doomed child process each time.
- *
- * The fix: a futile-refresh short-circuit. When the token is expired AND has
- * no refresh token, refreshIfNeeded re-reads once (to catch an out-of-band
- * `claude login`) and otherwise returns the auth verdict WITHOUT the OAuth
- * call or the CLI-fallback spawn, logging at most once per cooldown window.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/credentials-futile-refresh.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterAll } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// credentials.cjs freezes CREDS_PATH and REFRESH_LOG_PATH from os.homedir() at
-// require time. os.homedir() honors $HOME on POSIX, so point HOME at a temp
-// dir BEFORE the require (not in beforeEach — that runs too late) so both the
-// creds file we write and the log the code writes resolve under our sandbox.
-const originalHome = process.env.HOME;
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-cred-futile-'));
-process.env.HOME = tmpHome;
-
-const credentials = require('../credentials.cjs');
-const { isRefreshFutile, refreshIfNeeded, __resetFutileRefreshThrottle } = credentials;
-
-const CREDS_FILE = path.join(tmpHome, '.claude', '.credentials.json');
-const LOG_FILE = path.join(tmpHome, '.claude', 'session-manager', 'credential-refresh.log');
-
-function writeCreds(oauth) {
-  fs.mkdirSync(path.dirname(CREDS_FILE), { recursive: true });
-  fs.writeFileSync(CREDS_FILE, JSON.stringify({ claudeAiOauth: oauth }), 'utf8');
-}
-
-function readLogLines() {
-  try {
-    return fs.readFileSync(LOG_FILE, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
-  } catch {
-    return [];
-  }
-}
-
-beforeEach(() => {
-  // Clean slate per test: no stale creds file, no carried-over log or throttle.
-  try { fs.unlinkSync(CREDS_FILE); } catch { /* absent */ }
-  try { fs.unlinkSync(LOG_FILE); } catch { /* absent */ }
-  __resetFutileRefreshThrottle();
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-test('isRefreshFutile: expired + no refresh token is futile; anything else is not', () => {
-  const past = Date.now() - 60_000;
-  const future = Date.now() + 60 * 60_000;
-  expect(isRefreshFutile({ accessToken: 'a', expiresAt: past })).toBe(true);
-  // Has a refresh token → OAuth grant is worth attempting, not futile.
-  expect(isRefreshFutile({ accessToken: 'a', expiresAt: past, refreshToken: 'r' })).toBe(false);
-  // Not expired → not futile even without a refresh token.
-  expect(isRefreshFutile({ accessToken: 'a', expiresAt: future })).toBe(false);
-});
-
-test('a futile refresh returns an auth verdict without spawning the CLI fallback, and logs the no-refresh-token event once', async () => {
-  writeCreds({ accessToken: 'expired', expiresAt: Date.now() - 60_000 }); // expired, no refreshToken
-
-  const res = await refreshIfNeeded();
-
-  expect(res.kind).toBe('auth');
-  expect(res.message).toMatch(/no refresh token/i);
-  expect(typeof res.expiredAt).toBe('number');
-
-  const events = readLogLines().map((e) => e.event);
-  // The distinctive no-refresh-token event fires...
-  expect(events).toContain('auth_failed_expired_no_refresh_token');
-  // ...and the storm's spawn/oauth triple never runs.
-  expect(events).not.toContain('cli_fallback_ok');
-  expect(events).not.toContain('cli_fallback_failed');
-  expect(events).not.toContain('oauth_refresh_unsupported');
-});
-
-test('repeated polls in the cooldown window do NOT re-log — the every-15s storm is suppressed', async () => {
-  writeCreds({ accessToken: 'expired', expiresAt: Date.now() - 60_000 });
-
-  // Simulate several poll cycles back-to-back (as pollLoop would, every 15 s).
-  for (let i = 0; i < 5; i++) {
-    const res = await refreshIfNeeded();
-    expect(res.kind).toBe('auth');
-  }
-
-  const futileLogs = readLogLines().filter((e) => e.event === 'auth_failed_expired_no_refresh_token');
-  expect(futileLogs.length).toBe(1); // once, not five times
-});
-
-test('an out-of-band `claude login` (fresh creds on disk) is picked up on the next call', async () => {
-  writeCreds({ accessToken: 'expired', expiresAt: Date.now() - 60_000 });
-  expect((await refreshIfNeeded()).kind).toBe('auth');
-
-  // User runs `claude` in a terminal → fresh creds land on disk.
-  writeCreds({ accessToken: 'fresh', expiresAt: Date.now() + 60 * 60_000 });
-
-  const res = await refreshIfNeeded();
-  expect(res.kind).toBe('ok');
-  expect(res.creds.accessToken).toBe('fresh');
-});