fix(test): stop Windows star-route hangs and raise trash restore timeout

Route tests were spawning real gh.cmd and burning AUTH_TIMEOUT equal to
Bun's 5s deadline. Inject a fast fake via setStarDepsForTests, and give
the slow compressed trash restore 20s on Windows CI.

Author: Wibias

src/github/star-state.ts

@@ -80,6 +80,23 @@ async function spawnGh(args: string[], timeoutMs: number): Promise<{ status: num
 }
 
 const defaultDeps: StarDeps = { runGh: spawnGh, nowMs: () => Date.now() };
+/**
+ * Route tests call the real management dispatcher, which has no place to pass
+ * `StarDeps`. Without an override, Windows CI spawns the real `gh.cmd` shim and
+ * burns the full `AUTH_TIMEOUT_MS` — equal to Bun's default test timeout — so
+ * `GET /api/github/star` flakes as a 5s hang. Tests install a fast fake here.
+ */
+let overrideDeps: StarDeps | null = null;
+
+function resolveDeps(deps?: StarDeps): StarDeps {
+  return deps ?? overrideDeps ?? defaultDeps;
+}
+
+/** Test-only: swap the `gh` runner used when callers omit `deps`. Pass `null` to clear. */
+export function setStarDepsForTests(deps: StarDeps | null): void {
+  overrideDeps = deps;
+  invalidateStarStatusCache();
+}
 
 let cached: { timestamp: number; state: StarState } | null = null;
 /** Coalesces concurrent probes so parallel sidebar polls share one `gh` run. */
@@ -97,10 +114,11 @@ let generation = 0;
  * starred and 404 when not, so a non-zero exit is only meaningful once we know
  * the CLI is authenticated — hence the auth check first.
  */
-export async function probeStarState(deps: StarDeps = defaultDeps): Promise<StarState> {
-  const auth = await deps.runGh(["auth", "status", "--hostname", GH_HOSTNAME], AUTH_TIMEOUT_MS);
+export async function probeStarState(deps?: StarDeps): Promise<StarState> {
+  const resolved = resolveDeps(deps);
+  const auth = await resolved.runGh(["auth", "status", "--hostname", GH_HOSTNAME], AUTH_TIMEOUT_MS);
   if (!auth || auth.status !== 0) return "unauthenticated";
-  const starred = await deps.runGh(
+  const starred = await resolved.runGh(
     ["api", "--hostname", GH_HOSTNAME, `/user/starred/${STAR_REPO}`],
     API_TIMEOUT_MS,
   );
@@ -109,8 +127,9 @@ export async function probeStarState(deps: StarDeps = defaultDeps): Promise<Star
 }
 
 /** Cached star state; `gh` is only spawned when the cache is cold or expired. */
-export async function getStarStatus(deps: StarDeps = defaultDeps): Promise<StarStatus> {
-  const now = deps.nowMs();
+export async function getStarStatus(deps?: StarDeps): Promise<StarStatus> {
+  const resolved = resolveDeps(deps);
+  const now = resolved.nowMs();
   if (cached && now - cached.timestamp < CACHE_TTL_MS) {
     return { state: cached.state, repo: STAR_REPO, url: STAR_REPO_URL };
   }
@@ -123,7 +142,7 @@ export async function getStarStatus(deps: StarDeps = defaultDeps): Promise<StarS
     // The slot is cleared inside the same continuation that commits the cache. Using
     // `.finally()` for that defers it by a microtask, which leaves a window where the
     // next caller awaits an already-settled probe instead of starting a fresh one.
-    const probe = probeStarState(deps).then(
+    const probe = probeStarState(resolved).then(
       state => {
         if (inflight === probe) inflight = null;
         // A write landed while this read was in flight — its result is authoritative.
@@ -159,19 +178,20 @@ export function invalidateStarStatusCache(): void {
  * management API.
  */
 export async function starRepository(
-  deps: StarDeps = defaultDeps,
+  deps?: StarDeps,
 ): Promise<{ ok: boolean; status: StarStatus; code?: StarErrorCode }> {
-  const auth = await deps.runGh(["auth", "status", "--hostname", GH_HOSTNAME], AUTH_TIMEOUT_MS);
+  const resolved = resolveDeps(deps);
+  const auth = await resolved.runGh(["auth", "status", "--hostname", GH_HOSTNAME], AUTH_TIMEOUT_MS);
   if (!auth || auth.status !== 0) {
     generation += 1;
-    cached = { timestamp: deps.nowMs(), state: "unauthenticated" };
+    cached = { timestamp: resolved.nowMs(), state: "unauthenticated" };
     return {
       ok: false,
       status: { state: "unauthenticated", repo: STAR_REPO, url: STAR_REPO_URL },
       code: "gh_unavailable",
     };
   }
-  const result = await deps.runGh(
+  const result = await resolved.runGh(
     ["api", "--hostname", GH_HOSTNAME, "-X", "PUT", `/user/starred/${STAR_REPO}`],
     API_TIMEOUT_MS,
   );
@@ -186,6 +206,6 @@ export async function starRepository(
   // Authoritative: this call just starred the repo. Bumping the generation makes any
   // read that is still in flight discard its now-obsolete observation.
   generation += 1;
-  cached = { timestamp: deps.nowMs(), state: "starred" };
+  cached = { timestamp: resolved.nowMs(), state: "starred" };
   return { ok: true, status: { state: "starred", repo: STAR_REPO, url: STAR_REPO_URL } };
 }

tests/sidebar-routes.test.ts

@@ -1,20 +1,34 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { handleManagementAPI } from "../src/server/management-api";
-import { invalidateStarStatusCache } from "../src/github/star-state";
+import { setStarDepsForTests } from "../src/github/star-state";
 import type { OcxConfig } from "../src/types";
 
 /**
  * Route-level proof for the two sidebar endpoints. The unit tests cover the state
  * machine; this file checks that the routes are actually reachable through the
  * management dispatcher and that the serialized bytes carry no `gh` output, token,
  * or account identifier.
+ *
+ * Star probes install a fake `gh` runner: the real Windows `gh.cmd` shim can burn
+ * the full auth timeout, which equals Bun's default 5s test deadline.
  */
 const config = {
   port: 10100,
   defaultProvider: "openai",
   providers: {},
 } as OcxConfig;
 
+beforeEach(() => {
+  setStarDepsForTests({
+    runGh: async () => ({ status: 1 }),
+    nowMs: () => Date.now(),
+  });
+});
+
+afterEach(() => {
+  setStarDepsForTests(null);
+});
+
 async function call(
   method: string,
   pathname: string,
@@ -52,7 +66,6 @@ describe("GET /api/update/badge", () => {
 
 describe("GET /api/github/star", () => {
   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>;
@@ -62,7 +75,6 @@ describe("GET /api/github/star", () => {
   });
 
   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.

tests/storage-cleanup.test.ts

@@ -1441,7 +1441,7 @@ describe("listTrashEntries + restoreTrashEntry", () => {
       has_user_event: 1,
       archived: 1,
     });
-  });
+  }, { timeout: 20_000 });
 
   test.each([
     ["failAfterStateCommit", { failAfterStateCommit: true }, "db_reconcile_failed"],