claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,190 +0,0 @@
-/**
- * queueStoreMachineStateRecovery.test.cjs — a torn `scheduler-machine.json`
- * must recover instead of poisoning every read with `unreadable` (which
- * halts tickQueue/runDueJobs machine-wide — the user-visible "Run now"
- * hard error "queue.json is unreadable — scheduling halted").
- *
- * fixtures/scheduler-machine.json.corrupt-1789147548 is a byte-for-byte copy
- * of the REAL torn file recovered live on 2026-09-11 — not hand-typed. Its
- * shape: a complete, valid, parseable object (paused: null) followed by the
- * orphaned tail of a longer previous write (an incomplete `resumeAt` string
- * fragment with no reconstructable `"paused"` object around it).
- *
- * Never writes to the real ~/.claude/session-manager/ — HOME is pointed at a
- * fresh temp dir per test and the module is re-required so its module-level
- * MACHINE_STATE_PATH constant is recomputed against it.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/queueStoreMachineStateRecovery.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const FIXTURE = path.join(__dirname, 'fixtures', 'scheduler-machine.json.corrupt-1789147548');
-
-// queueStore.cjs is required via Node's own require() (this is a .cjs file,
-// not transformed ESM) and bakes os.homedir() into a top-level const
-// (MACHINE_STATE_PATH, MACHINE_STATE_LOG_CWD) at first require. vi.resetModules()
-// only resets vitest's ESM module graph, so it does NOT clear Node's own
-// require.cache — purge it directly (same pattern as historyRollup.test.cjs)
-// or every test after the first keeps pointing at the FIRST test's tmpHome.
-function purgeRequireCache() {
-  try { delete require.cache[require.resolve('../queueStore.cjs')]; } catch { /* not loaded yet */ }
-}
-
-const realHome = process.env.HOME;
-let tmpHome;
-let queueStore;
-let machineStatePath;
-
-beforeEach(() => {
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'queueStore-home-'));
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-  fs.mkdirSync(path.join(tmpHome, 'Projects', 'session-manager'), { recursive: true });
-  process.env.HOME = tmpHome;
-  purgeRequireCache();
-  queueStore = require('../queueStore.cjs');
-  machineStatePath = queueStore.MACHINE_STATE_PATH;
-  expect(machineStatePath.startsWith(tmpHome)).toBe(true); // sanity: never the real file
-});
-
-afterEach(async () => {
-  process.env.HOME = realHome;
-  purgeRequireCache();
-  await fsp.rm(tmpHome, { recursive: true, force: true }).catch(() => {});
-});
-
-test('findLongestValidJsonPrefix recovers the complete leading object from the real torn fixture', () => {
-  const raw = fs.readFileSync(FIXTURE, 'utf8');
-  const result = queueStore.findLongestValidJsonPrefix(raw);
-  expect(result).not.toBeNull();
-  expect(result.prefixLength).toBeLessThan(raw.length); // there really is an orphaned tail
-  expect(result.value.paused).toBeNull();
-  expect(result.value.lastRunAt).toBe('2026-09-11T10:00:14.441Z');
-  expect(result.value.config.concurrencyCap).toBe(4);
-});
-
-test('readMergedSync recovers a torn machine-state file instead of marking it unreadable', () => {
-  fs.copyFileSync(FIXTURE, machineStatePath);
-
-  const state = queueStore.readMergedSync();
-
-  expect(state.unreadable).toBeUndefined();
-  expect(state.machineStateRecovered).toBe(true);
-  expect(state.machineStateRecoveryMode).toBe('prefix');
-  expect(state.paused).toBeNull();
-  expect(state.lastRunAt).toBe('2026-09-11T10:00:14.441Z');
-
-  // The file is rewritten atomically from the recovered object — a second
-  // read must come back clean with no recovery flag.
-  const rewritten = fs.readFileSync(machineStatePath, 'utf8');
-  expect(() => JSON.parse(rewritten)).not.toThrow();
-  const second = queueStore.readMergedSync();
-  expect(second.machineStateRecovered).toBeUndefined();
-  expect(second.paused).toBeNull();
-});
-
-test('a file with no valid JSON prefix at all falls back to defaults, never to unreadable', () => {
-  fs.writeFileSync(machineStatePath, 'not json at all {{{ this never balances');
-
-  const state = queueStore.readMergedSync();
-
-  expect(state.unreadable).toBeUndefined();
-  expect(state.machineStateRecovered).toBe(true);
-  expect(state.machineStateRecoveryMode).toBe('default');
-  expect(state.config).toEqual({});
-  expect(state.paused).toBeNull();
-
-  // Rewritten to a clean, parseable default doc so the engine keeps ticking.
-  const rewritten = fs.readFileSync(machineStatePath, 'utf8');
-  expect(() => JSON.parse(rewritten)).not.toThrow();
-});
-
-test('a genuinely missing file is a legitimately empty first-boot state, not a recovery', () => {
-  const state = queueStore.readMergedSync();
-  expect(state.unreadable).toBeUndefined();
-  expect(state.machineStateRecovered).toBeUndefined();
-});
-
-test('readMerged (async) recovers the same real fixture', async () => {
-  fs.copyFileSync(FIXTURE, machineStatePath);
-
-  const state = await queueStore.readMerged();
-
-  expect(state.unreadable).toBeUndefined();
-  expect(state.machineStateRecovered).toBe(true);
-  expect(state.machineStateRecoveryMode).toBe('prefix');
-  expect(state.lastRunAt).toBe('2026-09-11T10:00:14.441Z');
-});
-
-// ---------- per-cwd shard quarantine (never recover, never write) ----------
-
-function makeProject(name, jobs) {
-  const cwd = path.join(tmpHome, 'Projects', name);
-  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  const file = path.join(stateDir, 'queue.json');
-  if (jobs) fs.writeFileSync(file, JSON.stringify({ jobs }));
-  const slugDir = path.join(tmpHome, '.claude', 'projects', `slug-${name}`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 't.jsonl'), JSON.stringify({ cwd }) + '\n');
-  return { cwd, file };
-}
-
-const TORN = '{"jobs":[{"slug":"a","status":"running"}]} {"jobs":[{"slug":"a","stat';
-const goodJob = (slug, cwd) => ({
-  slug, status: 'pending', prdPath: `/x/${slug}.md`, cwd, scheduledFor: null, createdAt: new Date().toISOString(),
-});
-
-test('a torn shard is quarantined per cwd; the machine-level `unreadable` stays unset and the sibling shard still loads', () => {
-  const good = makeProject('good', [goodJob('g1', path.join(tmpHome, 'Projects', 'good'))]);
-  const torn = makeProject('torn');
-  fs.writeFileSync(torn.file, TORN);
-  const opts = { projectsDir: path.join(tmpHome, '.claude', 'projects') };
-
-  const state = queueStore.readMergedSync(opts);
-
-  expect(state.unreadable).toBeUndefined();
-  expect(state.unreadableCwds).toHaveLength(1);
-  expect(state.unreadableCwds[0]).toMatchObject({ cwd: torn.cwd, file: torn.file });
-  expect(typeof state.unreadableCwds[0].error).toBe('string');
-  expect(state.jobs.map((j) => j.slug)).toEqual(['g1']);
-  expect(state.sourceCwds).not.toContain(torn.cwd);
-});
-
-test('readMerged (async) quarantines the same way', async () => {
-  const torn = makeProject('torn2');
-  fs.writeFileSync(torn.file, TORN);
-  const state = await queueStore.readMerged({ projectsDir: path.join(tmpHome, '.claude', 'projects') });
-  expect(state.unreadable).toBeUndefined();
-  expect(state.unreadableCwds.map((u) => u.cwd)).toEqual([torn.cwd]);
-});
-
-test('writeSplit leaves a torn shard byte-identical even when merged rows carry its cwd, and still writes healthy shards', async () => {
-  const good = makeProject('good3', [goodJob('g1', path.join(tmpHome, 'Projects', 'good3'))]);
-  const torn = makeProject('torn3');
-  fs.writeFileSync(torn.file, TORN);
-  const before = fs.readFileSync(torn.file);
-  const opts = { projectsDir: path.join(tmpHome, '.claude', 'projects') };
-
-  const state = await queueStore.readMerged(opts);
-  state.jobs.push(goodJob('intruder', torn.cwd)); // a row that claims the torn cwd
-  state.jobs[0].status = 'running';
-  await queueStore.writeSplit(state, good.cwd);
-
-  expect(fs.readFileSync(torn.file).equals(before)).toBe(true);
-  const written = JSON.parse(fs.readFileSync(good.file, 'utf8'));
-  expect(written.jobs.map((j) => j.status)).toEqual(['running']);
-});
-
-test('writeSplit never re-creates a quarantined shard that has no file at all', async () => {
-  const ghost = makeProject('ghost');
-  const state = { config: {}, jobs: [goodJob('x', ghost.cwd)], sourceCwds: [], unreadableCwds: [{ cwd: ghost.cwd, file: ghost.file, error: 'x' }] };
-  await queueStore.writeSplit(state, ghost.cwd);
-  expect(fs.existsSync(ghost.file)).toBe(false);
-});

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

@@ -1,39 +0,0 @@
-'use strict';
-
-// Run: timeout 60 npx vitest run src/main/lib/__tests__/quietMachineLease.test.cjs
-
-const assert = require('node:assert/strict');
-const lease = require('../quietMachineLease.cjs');
-
-afterEach(() => {
-  lease.__resetForTests();
-});
-
-test('free lease: isHeld false, acquire succeeds and reports the holder', () => {
-  assert.equal(lease.isHeld(), false);
-  assert.equal(lease.acquire('101-quiet'), true);
-  assert.equal(lease.isHeld(), true);
-  assert.equal(lease.holder(), '101-quiet');
-});
-
-test('a second acquire while held fails — exclusive by construction', () => {
-  assert.equal(lease.acquire('101-quiet'), true);
-  assert.equal(lease.acquire('102-other'), false);
-  assert.equal(lease.holder(), '101-quiet');
-});
-
-test('release frees the lease so the next acquire can succeed', () => {
-  lease.acquire('101-quiet');
-  assert.equal(lease.release('101-quiet'), true);
-  assert.equal(lease.isHeld(), false);
-  assert.equal(lease.acquire('102-other'), true);
-});
-
-test('release is idempotent: releasing an unheld lease, or a slug that does not hold it, is a no-op', () => {
-  assert.equal(lease.release('nobody'), false);
-  lease.acquire('101-quiet');
-  assert.equal(lease.release('wrong-slug'), false);
-  assert.equal(lease.isHeld(), true);
-  assert.equal(lease.release('101-quiet'), true);
-  assert.equal(lease.release('101-quiet'), false);
-});

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

@@ -1,88 +0,0 @@
-/**
- * rateLimitWindow.test.cjs — resolveBindingRateLimitReset: reads the log's
- * OWN rate_limit_event windows and returns the reset of whichever window
- * actually bound (utilization >= 1.0), not the billing endpoint's five_hour
- * assumption (PRD 1118).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/rateLimitWindow.test.cjs
- */
-
-'use strict';
-
-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');
-const { resolveBindingRateLimitReset } = require('../rateLimitWindow.cjs');
-
-// Repo-tracked, byte-for-byte copy of the real incident log (2026-09-05
-// starry-night-ships 429) so this test is hermetic — CI, a fresh clone, or
-// this machine's own run-log retention sweep (runLogRetention.test.cjs)
-// pruning the live copy must not turn this red for reasons unrelated to the
-// code under test.
-const TRACKED_FIXTURE = path.join(__dirname, 'fixtures', '204-mercury-steam-horse.log.txt');
-const REAL_FIXTURE_LIVE_PATH = '/home/bilko/.claude/session-manager/scheduled-plans/runs/2026-09-05T16-32-18-381Z/204-mercury-steam-horse.log';
-
-test('tracked fixture (verbatim copy of the real incident log): seven_day_overage_included (utilization 1.0) binds, not five_hour', () => {
-  const reset = resolveBindingRateLimitReset(TRACKED_FIXTURE);
-  assert.strictEqual(reset, 1789059600);
-  assert.notStrictEqual(reset, 1788643800);
-});
-
-test('tracked fixture is byte-identical to the live incident log, when present on this machine', () => {
-  if (!fs.existsSync(REAL_FIXTURE_LIVE_PATH)) return; // machine-local artifact, not guaranteed to exist
-  assert.strictEqual(
-    fs.readFileSync(TRACKED_FIXTURE, 'utf8'),
-    fs.readFileSync(REAL_FIXTURE_LIVE_PATH, 'utf8'),
-  );
-});
-
-function writeTmpLog(lines) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rate-limit-window-test-'));
-  const file = path.join(dir, 'job.log');
-  fs.writeFileSync(file, lines.map((l) => (typeof l === 'string' ? l : JSON.stringify(l))).join('\n') + '\n');
-  return file;
-}
-
-test('no rate_limit_event in log → null', () => {
-  const logPath = writeTmpLog(['[scheduler] starting job', '{"type":"system","subtype":"init"}']);
-  assert.strictEqual(resolveBindingRateLimitReset(logPath), null);
-});
-
-test('rate_limit_event present but no window at/above 1.0 utilization → null', () => {
-  const logPath = writeTmpLog([
-    { type: 'rate_limit_event', rate_limit_info: { unifiedWindows: {
-      five_hour: { utilization: 0, resetsAt: 1788643800 },
-      seven_day: { utilization: 0.59, resetsAt: 1789059600 },
-    } } },
-  ]);
-  assert.strictEqual(resolveBindingRateLimitReset(logPath), null);
-});
-
-test('multiple windows bind in the last event → the LATEST reset wins', () => {
-  const logPath = writeTmpLog([
-    { type: 'rate_limit_event', rate_limit_info: { unifiedWindows: {
-      five_hour: { utilization: 1.0, resetsAt: 1000 },
-      seven_day: { utilization: 1.0, resetsAt: 2000 },
-    } } },
-  ]);
-  assert.strictEqual(resolveBindingRateLimitReset(logPath), 2000);
-});
-
-test('uses the LAST rate_limit_event in the log, not the first', () => {
-  const logPath = writeTmpLog([
-    { type: 'rate_limit_event', rate_limit_info: { unifiedWindows: {
-      seven_day: { utilization: 0.3, resetsAt: 111 },
-    } } },
-    { type: 'other' },
-    { type: 'rate_limit_event', rate_limit_info: { unifiedWindows: {
-      seven_day_overage_included: { utilization: 1.0, resetsAt: 999 },
-    } } },
-  ]);
-  assert.strictEqual(resolveBindingRateLimitReset(logPath), 999);
-});
-
-test('missing file → null (best-effort, matches readTail contract)', () => {
-  assert.strictEqual(resolveBindingRateLimitReset('/nonexistent/path/job.log'), null);
-});