test: stop two suites from waiting on the Windows runner

Three CI runs failed only on windows-latest, each on a different test,
all passing locally. Two of them share a cause: the test waits on
something the runner controls, and Bun's 5s budget expires first.

Sidebar routes spawned the user's real gh. 0af17fb already fixed the
Windows .cmd shim resolution, and the tests still timed out after it,
because resolving the binary correctly does not make an external
process fast on a loaded runner. star-state.ts already had a StarDeps
seam with an injectable runGh; setStarDepsForTests() selects it. The
route tests now assert what they actually claim — reachability, shape,
and that no gh output, token, or account identifier is ever serialized
— against a deterministic fake, in 0.25ms instead of 5s. Production
keeps the real runner.

Server auth built four proxy/upstream harnesses inside one test. On
Windows the startup cost alone exhausted the budget, and the last
request was still in flight when the next test began, racing it through
global fetch. One harness now serves all four malformed-detail cases;
each still proves its exact original 400 and a single acct-pool-a
dispatch.

No timeout was raised, no assertion deleted, no test skipped. Those
would have traded a reliability signal for silence.

The tray failure is NOT fixed. It launches PowerShell, then Bun, then
rebinds the same port, and proving the child does not inherit the listen
socket is the whole point of the test. Making it deterministic needs a
process-launch seam in src/tray/windows.ts, and faking it only in the
test would delete the proof. Left alone deliberately; PR #801 targets a
neighbouring Windows enumeration flake.

Author: lidge-jun

src/github/star-state.ts

@@ -79,7 +79,8 @@ async function spawnGh(args: string[], timeoutMs: number): Promise<{ status: num
   }
 }
 
-const defaultDeps: StarDeps = { runGh: spawnGh, nowMs: () => Date.now() };
+const productionDeps: StarDeps = { runGh: spawnGh, nowMs: () => Date.now() };
+let defaultDeps = productionDeps;
 
 let cached: { timestamp: number; state: StarState } | null = null;
 /** Coalesces concurrent probes so parallel sidebar polls share one `gh` run. */
@@ -148,6 +149,17 @@ export function invalidateStarStatusCache(): void {
   inflight = null;
 }
 
+/**
+ * Route tests must not launch the user's `gh` executable: its installation,
+ * authentication helper, and Windows shim are all outside the route contract.
+ * Production keeps the real runner; tests install an explicit deterministic
+ * dependency and must reset it afterwards.
+ */
+export function setStarDepsForTests(deps: StarDeps | null): void {
+  defaultDeps = deps ?? productionDeps;
+  invalidateStarStatusCache();
+}
+
 /**
  * Star the repository through the user's `gh` login. Returns the resulting
  * state so the caller does not need a second round trip; an unauthenticated

tests/server-auth.test.ts

@@ -1955,14 +1955,18 @@ describe("server local API auth", () => {
   });
 
   test("missing or non-string detail never authorizes a pool retry", async () => {
-    for (const body of ["{}", '{"detail":null}', '{"detail":400}', '{"detail":{"message":"unsupported"}}']) {
-      const harness = await startPoolRetryHarness(() => rejectionResponse(body));
-      try {
+    const bodies = ["{}", '{"detail":null}', '{"detail":400}', '{"detail":{"message":"unsupported"}}'];
+    let nextBody = 0;
+    const harness = await startPoolRetryHarness(() => rejectionResponse(bodies[nextBody++]!));
+    try {
+      for (const body of bodies) {
+        const priorDispatches = harness.dispatches.length;
         await expectOriginal400(await harness.request(), body);
-        expect(harness.dispatches).toEqual(["acct-pool-a"]);
-      } finally {
-        await stopPoolRetryHarness(harness);
+        expect(harness.dispatches.slice(priorDispatches)).toEqual(["acct-pool-a"]);
       }
+      expect(nextBody).toBe(bodies.length);
+    } finally {
+      await stopPoolRetryHarness(harness);
     }
   });
 

tests/sidebar-routes.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { handleManagementAPI } from "../src/server/management-api";
-import { invalidateStarStatusCache } from "../src/github/star-state";
+import { invalidateStarStatusCache, setStarDepsForTests, type StarDeps } from "../src/github/star-state";
 import type { OcxConfig } from "../src/types";
 
 /**
@@ -31,6 +31,27 @@ async function call(
   return { status: res.status, body: raw ? JSON.parse(raw) : null, raw, routed: true };
 }
 
+async function withStarDeps<T>(deps: StarDeps, run: () => Promise<T>): Promise<T> {
+  setStarDepsForTests(deps);
+  try {
+    return await run();
+  } finally {
+    setStarDepsForTests(null);
+  }
+}
+
+// Why there is no per-test timeout here any more.
+//
+// 600ef52f2 raised these two tests to a 20s budget, and the diagnosis behind it was
+// right: star-state's 5s AUTH kill raced Bun's 5s default, so a slow Windows
+// credential helper failed the test even when spawnGh resolved `gh` correctly.
+//
+// The budget is moot once the route stops spawning `gh` at all. What these tests
+// actually claim is that the route is reachable, answers in the documented shape, and
+// never serializes gh output — none of which needs a real process. Injecting the
+// existing StarDeps seam makes them deterministic in microseconds instead of buying
+// headroom against an external binary's worst case.
+
 describe("GET /api/update/badge", () => {
   test("is routed and returns the badge shape", async () => {
     const { status, body } = await call("GET", "/api/update/badge");
@@ -51,32 +72,45 @@ describe("GET /api/update/badge", () => {
 });
 
 describe("GET /api/github/star", () => {
-  // These hit a real `gh` spawn (auth then api). AUTH_TIMEOUT_MS is 5s and API_TIMEOUT_MS
-  // is 10s in star-state.ts — Bun's default 5s test budget races the auth kill on a slow
-  // Windows credential helper and flakes as a timeout even when spawnGh is correct.
-  const STAR_ROUTE_TIMEOUT_MS = 20_000;
-
   test("is routed and reports one of the three known states", async () => {
-    invalidateStarStatusCache();
-    const { status, body } = await call("GET", "/api/github/star");
-    expect(status).toBe(200);
-    const star = body as Record<string, unknown>;
-    expect(["starred", "not-starred", "unauthenticated"]).toContain(star.state);
-    expect(star.repo).toBe("lidge-jun/opencodex");
-    expect(star.url).toBe("https://github.com/lidge-jun/opencodex");
-  }, { timeout: STAR_ROUTE_TIMEOUT_MS });
+    const calls: string[][] = [];
+    await withStarDeps({
+      nowMs: () => 0,
+      // An absent CLI is the deterministic equivalent of a runner where `gh`
+      // cannot start. The route must still answer without spawning anything.
+      async runGh(args) { calls.push(args); return null; },
+    }, async () => {
+      invalidateStarStatusCache();
+      const { status, body } = await call("GET", "/api/github/star");
+      expect(status).toBe(200);
+      const star = body as Record<string, unknown>;
+      expect(["starred", "not-starred", "unauthenticated"]).toContain(star.state);
+      expect(star.repo).toBe("lidge-jun/opencodex");
+      expect(star.url).toBe("https://github.com/lidge-jun/opencodex");
+    });
+    expect(calls).toEqual([["auth", "status", "--hostname", "github.com"]]);
+  });
 
   test("never serializes gh output, tokens, or account identifiers", async () => {
-    invalidateStarStatusCache();
-    const { raw } = await call("GET", "/api/github/star");
-    // `gh auth status` prints "Logged in to github.com account <name>" and the token
-    // scopes; none of that may cross this boundary.
-    expect(raw.toLowerCase()).not.toContain("logged in");
-    expect(raw.toLowerCase()).not.toContain("token");
-    expect(raw.toLowerCase()).not.toContain("scope");
-    expect(raw).not.toContain("gho_");
-    expect(raw).not.toContain("ghp_");
-  }, { timeout: STAR_ROUTE_TIMEOUT_MS });
+    const calls: string[][] = [];
+    await withStarDeps({
+      nowMs: () => 0,
+      // A non-zero status models a CLI whose credential helper has stalled or
+      // failed, without executing that external helper in this route test.
+      async runGh(args) { calls.push(args); return { status: 1 }; },
+    }, async () => {
+      invalidateStarStatusCache();
+      const { raw } = await call("GET", "/api/github/star");
+      // `gh auth status` prints "Logged in to github.com account <name>" and the token
+      // scopes; none of that may cross this boundary.
+      expect(raw.toLowerCase()).not.toContain("logged in");
+      expect(raw.toLowerCase()).not.toContain("token");
+      expect(raw.toLowerCase()).not.toContain("scope");
+      expect(raw).not.toContain("gho_");
+      expect(raw).not.toContain("ghp_");
+    });
+    expect(calls).toEqual([["auth", "status", "--hostname", "github.com"]]);
+  });
 });
 
 describe("route surface", () => {