claude-code-session-manager 0.87.0 → 0.88.0

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

@@ -0,0 +1,157 @@
+/**
+ * usageSingleFlight.test.cjs — usage.cjs's fetchUsage() is the single owner
+ * of caching, single-flight de-duplication, and the shared usageCircuit for
+ * the /api/oauth/usage meter. Before this, the renderer's billing:fetch IPC
+ * handler owned the 30s OK-cache alone and the scheduler's pollLoop called
+ * fetchUsage() directly with no cache/dedup — two independent request
+ * streams against a rate-limiting endpoint, and a success on one path never
+ * reset the other's failure streak. This suite proves: (1) concurrent
+ * fetchUsage() callers coalesce into exactly one network fetch, (2) a
+ * success resets the shared circuit's streak regardless of which "caller"
+ * triggered the preceding failures, and (3) a 429's Retry-After suppresses
+ * the next request until it elapses.
+ *
+ * Never hits the live billing endpoint — global.fetch is stubbed throughout,
+ * and HOME is pointed at a scratch dir so no real credentials/cache file on
+ * this machine is ever read.
+ *
+ * usage.cjs (and config.cjs/credentials.cjs, which it requires) are loaded
+ * via Node's own require() — this is a .cjs test, not transformed ESM — so
+ * vi.mock()/vi.resetModules() do NOT intercept them the way they would for
+ * an ESM import graph; both also bake os.homedir() into module-level
+ * constants at first require (config.cjs's allowedRoots/WRITE_PREFIXES,
+ * usage.cjs's CACHE_PATH, credentials.cjs's CREDS_PATH). So this suite
+ * follows historyRollup.test.cjs's pattern instead: swap $HOME to a fresh
+ * tmp dir with a valid, far-from-expiry fake credentials file, purge
+ * Node's require.cache for every affected module, and re-require fresh
+ * each test.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/usageSingleFlight.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function jsonResponse(status, body, headers = {}) {
+  return {
+    status,
+    ok: status >= 200 && status < 300,
+    text: async () => JSON.stringify(body),
+    json: async () => body,
+    headers: { get: (k) => headers[k.toLowerCase()] ?? null },
+  };
+}
+
+const usagePayload = { five_hour: { utilization: 10, resets_at: null }, seven_day: { utilization: 10, resets_at: null }, seven_day_sonnet: null, seven_day_opus: null, extra_usage: null };
+
+const MODULES_TO_RELOAD = [
+  '../usage.cjs',
+  '../config.cjs',
+  '../lib/credentials.cjs',
+  '../lib/usageCircuit.cjs',
+];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+let realHome;
+let tmpHome;
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'usage-single-flight-test-'));
+  process.env.HOME = tmpHome;
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  fs.writeFileSync(
+    path.join(tmpHome, '.claude', '.credentials.json'),
+    JSON.stringify({
+      claudeAiOauth: {
+        accessToken: 'test-access-token',
+        refreshToken: 'test-refresh-token',
+        expiresAt: Date.now() + 1_000 * 60 * 60 * 24, // 24h out — never "expiring soon"
+        subscriptionType: 'max',
+        rateLimitTier: 'default_claude_max_20x',
+      },
+    }),
+  );
+  purgeRequireCache();
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+  purgeRequireCache();
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test('two concurrent fetchUsage() calls produce exactly one HTTP fetch', async () => {
+  const { fetchUsage } = require('../usage.cjs');
+  let fetchCalls = 0;
+  vi.stubGlobal('fetch', vi.fn(async () => {
+    fetchCalls++;
+    // Slow enough that both callers are guaranteed to be in-flight together.
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    return jsonResponse(200, usagePayload);
+  }));
+
+  const [a, b] = await Promise.all([fetchUsage(), fetchUsage()]);
+
+  expect(fetchCalls).toBe(1);
+  expect(a.kind).toBe('ok');
+  expect(b.kind).toBe('ok');
+});
+
+test('an ok result resets the shared circuit streak built up by prior failures', async () => {
+  const usage = require('../usage.cjs');
+  const circuit = usage.__usageCircuitForTest;
+
+  let call = 0;
+  vi.stubGlobal('fetch', vi.fn(async () => {
+    call++;
+    if (call <= 3) return jsonResponse(500, { error: 'boom' });
+    return jsonResponse(200, usagePayload);
+  }));
+
+  // Three consecutive transient failures — simulating the scheduler's poller
+  // failing repeatedly — trip the circuit open.
+  await usage.fetchUsage();
+  await usage.fetchUsage();
+  await usage.fetchUsage();
+  expect(circuit.state()).toBe('open');
+
+  // A later success — as if it came from the renderer's independent
+  // billing:fetch call, but reached through the SAME shared fetchUsage() —
+  // must reset the streak the scheduler's calls built up, since both
+  // callers share one circuit instance.
+  const ok = await usage.fetchUsage();
+  expect(ok.kind).toBe('ok');
+  expect(circuit.state()).toBe('closed');
+});
+
+test('a 429 with Retry-After suppresses the next request until it elapses', async () => {
+  const usage = require('../usage.cjs');
+
+  let fetchCalls = 0;
+  vi.stubGlobal('fetch', vi.fn(async () => {
+    fetchCalls++;
+    return jsonResponse(429, { error: { type: 'rate_limit_error' } }, { 'retry-after': '60' });
+  }));
+
+  const first = await usage.fetchUsage();
+  expect(first.kind).toBe('meter_rate_limited');
+  expect(first.retryAfterMs).toBe(60_000);
+
+  const second = await usage.fetchUsage();
+  expect(second.kind).toBe('meter_rate_limited');
+  expect(second.suppressed).toBe(true);
+  // No second network call — the suppression window hasn't elapsed.
+  expect(fetchCalls).toBe(1);
+});

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

@@ -46,7 +46,7 @@ test('WORK_TYPES matches the tag ids declared in tagLibrary.ts TAG_LIBRARY, in o
   expect(tagMatches).toEqual(WORK_TYPES);
 });
 
-test('api.d.ts tag unions (line ~1166 and ~1687) both contain exactly the same 6 values', () => {
+test('api.d.ts tag unions both contain exactly the same 6 values', () => {
   const src = fs.readFileSync(API_D_TS_PATH, 'utf8');
   const unionMatches = [...src.matchAll(/tag\?:\s*((?:'[^']+'\s*\|?\s*)+);/g)].map((m) =>
     m[1]

package/src/main/bilkoHost.cjs

@@ -46,6 +46,10 @@ const {
 const WRITER = 'bilko-host';
 const PROJECT_PAGE_LENSES = new Set(['home', 'marketing', 'feature', 'architecture']);
 
+function homePagePath(cwd) {
+  return opsPath(cwd, 'project-pages', 'home.html');
+}
+
 function bilkoHostDir(cwd) {
   return opsPath(cwd, 'bilko-host');
 }
@@ -103,9 +107,10 @@ async function writeDocuments(cwd, documents) {
 async function get({ cwd }) {
   const realCwd = config.validatePath(cwd);
 
-  const marketingResult = await config.readText(
-    opsPath(realCwd, 'project-pages', 'output', 'marketing.html'),
-  );
+  // The single Project Home page (project-pages/home.html) seeds the root
+  // document. `hasMarketingPage` is the renderer's legacy field name for
+  // "a root-document source page exists".
+  const marketingResult = await config.readText(homePagePath(realCwd));
   const pkgResult = await config.readJson(path.join(realCwd, 'package.json'));
   const pkg = pkgResult.exists && !pkgResult.parseError ? pkgResult.data : null;
 
@@ -142,15 +147,15 @@ async function get({ cwd }) {
   };
 }
 
-/** Seeds documents.json with a single root document (the Marketing Project Page) if it doesn't exist yet. */
+/** Seeds documents.json with a single root document (the Project Home page, home.html) if it doesn't exist yet. */
 async function ensureSeededDocuments(cwd) {
   const existing = await readDocuments(cwd);
   if (existing) return existing;
   const seeded = [{
     id: crypto.randomUUID(),
     subpath: '',
-    title: 'Project (Marketing)',
-    source: { kind: 'project-page-lens', lens: 'marketing' },
+    title: 'Project (Home)',
+    source: { kind: 'project-page-lens', lens: 'home' },
     addedAt: new Date().toISOString(),
   }];
   await writeDocuments(cwd, seeded);
@@ -215,8 +220,12 @@ async function removeDocument({ cwd, id }) {
 
 async function resolveDocumentHtml(cwd, doc) {
   if (doc.source.kind === 'project-page-lens') {
+    // Only `home` is generated now (one home.html); the other lens names
+    // are legacy and resolve to their old output/<lens>.html if one exists.
     const result = await config.readText(
-      opsPath(cwd, 'project-pages', 'output', `${doc.source.lens}.html`),
+      doc.source.lens === 'home'
+        ? homePagePath(cwd)
+        : opsPath(cwd, 'project-pages', 'output', `${doc.source.lens}.html`),
     );
     if (!result.exists) {
       throw new Error(`document "${doc.title}" points at the ${doc.source.lens} Project Page, but it hasn't been generated yet`);

package/src/main/build-info.json

@@ -0,0 +1,8 @@
+{
+  "version": "0.88.0",
+  "gitSha": "8b723b765b5cb9f867b2ae244011b54ab3c81ef0",
+  "gitShortSha": "8b723b7",
+  "gitBranch": "HEAD",
+  "builtAt": "2026-09-19T14:31:26.080Z",
+  "dirty": false
+}

package/src/main/chatRunner.cjs

@@ -44,7 +44,7 @@
 
 const { spawn } = require('node:child_process');
 const { ipcMain } = require('electron');
-const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
+const { resolveClaudeBin, claudeSpawnTarget } = require('./lib/claudeBin.cjs');
 const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const { recordExchange } = require('./exchanges.cjs');
 const { classifyToolUse } = require('./lib/toolUseClassify.cjs');
@@ -571,7 +571,9 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     // real-time NDJSON streaming; stderr piped for error-message capture.
     let child;
     try {
-      child = spawn(claudeBin, args, {
+      const target = claudeSpawnTarget('chat', sessionId, claudeBin);
+      child = spawn(target.command, args, {
+        ...(target.argv0 ? { argv0: target.argv0 } : {}),
         cwd: execCwd,
         env: childEnv,
         stdio: ['ignore', 'pipe', 'pipe'],

package/src/main/config.cjs

@@ -148,9 +148,8 @@ function validateWrite(realAbs) {
       //                    (PRD 825; scheduler.cjs remote.writePrd)
       //   project-brief    projectBrief.cjs's brief.json (PRD 837)
       //   bilko-host       bilkoHost.cjs's bundle prep
-      //   project-pages    projectHomeAdminRoutes.cjs's app-side render path
-      //                    (summary.json/picks.json/output/*; PRD:
-      //                    project-home-admin-routes)
+      //   project-pages    projectHomeAdminRoutes.cjs's project_home_write
+      //                    path (home.html)
       // Paths come from opsOwnership.opsPath (PRD 1082) — the one ops-root
       // resolver — which THROWS for an ephemeral root (a linked worktree that
       // pty.cjs registered as an allowed root for its spawn cwd, or

package/src/main/docEdit.cjs

@@ -17,7 +17,8 @@
 const { ipcMain } = require('electron');
 const { spawn } = require('node:child_process');
 const crypto = require('node:crypto');
-const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
+const { resolveClaudeBin, claudeSpawnTarget } = require('./lib/claudeBin.cjs');
+const { withProcRole } = require('./lib/cleanEnv.cjs');
 const { extractJson } = require('./lib/extractJson.cjs');
 const { assertInsideHome } = require('./lib/insideHome.cjs');
 const { expandHome } = require('./lib/expandHome.cjs');
@@ -99,7 +100,8 @@ function runClaude(prompt, { model = 'sonnet', timeoutMs = 90_000, systemPrompt
     // stdin MUST be closed ('ignore') — `claude -p` otherwise blocks waiting
     // for piped stdin and returns empty. SM_KG_INTERNAL=1 tells the
     // prompt-logging hook to skip this invocation.
-    const child = spawn(bin, args, { env: { ...process.env, SM_KG_INTERNAL: '1' }, stdio: ['ignore', 'pipe', 'pipe'] });
+    const target = claudeSpawnTarget('aux', 'docedit', bin);
+    const child = spawn(target.command, args, { env: withProcRole({ ...process.env, SM_KG_INTERNAL: '1' }, 'aux'), stdio: ['ignore', 'pipe', 'pipe'], ...(target.argv0 ? { argv0: target.argv0 } : {}) });
     let out = '';
     let err = '';
     // Cap accumulated stdout — the model output shouldn't grow `out` without