@amg555/frameforge-mcp 2.7.6 → 2.7.8

package/.agent/skills/gstack-browse/test/cli-chain-stdin.test.ts

@@ -1,122 +0,0 @@
-/**
- * #3039: `chain` with no arguments reads its JSON flow from stdin. On Windows
- * an awaited Bun.stdin.text() inside the CLI's un-awaited main() let the
- * process exit 0 before reading, so a replayed flow "passed" with nothing
- * sent to the daemon. The CLI reads stdin synchronously; this drives the real
- * CLI against a stub daemon (the Windows free lane runs it natively). No flow
- * (empty input, a terminal, an unreadable stdin) is a usage error before
- * ensureServer(), so it never boots a daemon.
- */
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-
-import { CHAIN_NO_FLOW_ANCHOR, readChainFlow } from '../src/cli';
-
-const CLI = path.resolve(import.meta.dir, '../src/cli.ts');
-
-describe('#3039: chain reads its flow from piped stdin', () => {
-  let scratch: string;
-  let daemon: ReturnType<typeof Bun.serve>;
-  let received: Array<{ command: string; args: string[] }>;
-  let hits: string[];
-
-  beforeEach(() => {
-    scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-chain-stdin-'));
-    received = [];
-    hits = [];
-    daemon = Bun.serve({
-      hostname: '127.0.0.1',
-      port: 0,
-      fetch: async (req) => {
-        const url = new URL(req.url);
-        hits.push(url.pathname);
-        if (url.pathname === '/health') return Response.json({ status: 'healthy' });
-        if (url.pathname === '/command') {
-          const body = await req.json();
-          received.push(body);
-          return body.args?.[0] ? new Response('chain ran') : new Response('Usage: echo \'[["goto","url"]]\' | browse chain', { status: 400 });
-        }
-        return new Response('not found', { status: 404 });
-      },
-    });
-  });
-
-  afterEach(() => {
-    try { daemon.stop(true); } catch {}
-    fs.rmSync(scratch, { recursive: true, force: true });
-  });
-
-  async function runChain(stdin: string | 'ignore', opts: { daemon?: boolean } = {}) {
-    const stateFile = path.join(scratch, 'browse.json');
-    if (opts.daemon !== false) {
-      fs.writeFileSync(stateFile, JSON.stringify({ pid: process.pid, port: daemon.port, token: 'chain-stdin-test', mode: 'launched' }));
-    }
-    const env: Record<string, string> = {};
-    for (const [key, value] of Object.entries(process.env)) {
-      if (value !== undefined && !/^(BROWSE_|GSTACK_|PLAYWRIGHT_)/.test(key)) env[key] = value;
-    }
-    // Browser dependencies unavailable: a daemon boot attempt could not succeed.
-    Object.assign(env, { HOME: scratch, GSTACK_HOME: path.join(scratch, '.gstack'), BROWSE_STATE_FILE: stateFile,
-      PLAYWRIGHT_BROWSERS_PATH: path.join(scratch, 'no-browsers') });
-    const cli = Bun.spawn([process.execPath, CLI, 'chain'], {
-      cwd: scratch, env, stdin: stdin === 'ignore' ? 'ignore' : new TextEncoder().encode(stdin), stdout: 'pipe', stderr: 'pipe',
-    });
-    const timer = setTimeout(() => cli.kill('SIGKILL'), 30_000);
-    const [code, stdout, stderr] = await Promise.all([cli.exited, new Response(cli.stdout).text(), new Response(cli.stderr).text()]);
-    clearTimeout(timer);
-    return { code, out: stdout + stderr };
-  }
-
-  test('a piped flow reaches the daemon as the chain argument', async () => {
-    const flow = '[["js","1+1"]]';
-    const r = await runChain(`${flow}\n`);
-    expect(received).toEqual([{ command: 'chain', args: [flow] }]);
-    expect(r.out).toContain('chain ran');
-    expect(r.code).toBe(0);
-  }, 45_000);
-
-  test('empty stdin is a usage error, never a silent exit 0, and never reaches the daemon', async () => {
-    const r = await runChain('');
-    expect(r.code).toBe(1);
-    expect(r.out).toContain('[browse] chain: no flow to run (stdin was empty).');
-    expect(r.out).toContain('Usage: echo');
-    expect(r.out).toContain(CHAIN_NO_FLOW_ANCHOR);
-    expect(hits).toEqual([]);
-  }, 45_000);
-
-  test('with no daemon, whitespace-only or closed stdin exits 1 without booting one', async () => {
-    for (const stdin of ['  \n\t\n', 'ignore'] as const) {
-      const r = await runChain(stdin, { daemon: false });
-      expect(r.code).toBe(1);
-      expect(r.out).toContain('[browse] chain: no flow to run (stdin was empty).');
-      expect(fs.existsSync(path.join(scratch, 'browse.json'))).toBe(false);
-      expect(fs.existsSync(path.join(scratch, '.gstack'))).toBe(false);
-    }
-  }, 45_000);
-});
-
-describe('readChainFlow: no flow is a usage error', () => {
-  test('a terminal never reads stdin', () => {
-    let read = false;
-    const r = readChainFlow(true, () => { read = true; return '[["text"]]'; });
-    expect(read).toBe(false);
-    expect(r).toEqual({ ok: false, error: expect.stringContaining('no flow to run (stdin is a terminal)') });
-  });
-
-  test('a read error (EAGAIN, EOF) is a usage error naming the code', () => {
-    for (const code of ['EAGAIN', 'EOF']) {
-      const r = readChainFlow(false, () => { throw Object.assign(new Error(code), { code }); });
-      expect(r.ok).toBe(false);
-      if (!r.ok) {
-        expect(r.error).toContain(`no flow to run (stdin could not be read (${code}))`);
-        expect(r.error).toContain('Usage: echo');
-      }
-    }
-  });
-
-  test('piped input is trimmed and returned', () => {
-    expect(readChainFlow(false, () => '  [["text"]]\n')).toEqual({ ok: true, flow: '[["text"]]' });
-  });
-});

package/.agent/skills/gstack-browse/test/cli-config-mismatch-message.test.ts

@@ -1,72 +0,0 @@
-/**
- * #3030: when another session started the project's daemon with --headed or
- * --proxy, a plain call is refused (by design: a silent restart would drop
- * tabs and logins). The refusal must not tell a caller who passed no flags
- * to "apply --proxy/--headed".
- */
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-
-const CLI = path.resolve(import.meta.dir, '../src/cli.ts');
-
-describe('#3030: config-mismatch refusal names who started the daemon', () => {
-  let scratch: string;
-  let daemon: ReturnType<typeof Bun.serve>;
-
-  beforeEach(() => {
-    scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-mismatch-'));
-    daemon = Bun.serve({
-      hostname: '127.0.0.1', port: 0,
-      fetch: (req) => new URL(req.url).pathname === '/health' ? Response.json({ status: 'healthy' }) : new Response('unexpected', { status: 500 }),
-    });
-  });
-  afterEach(() => { try { daemon.stop(true); } catch {} fs.rmSync(scratch, { recursive: true, force: true }); });
-
-  async function run(args: string[]) {
-    const stateFile = path.join(scratch, 'browse.json');
-    fs.writeFileSync(stateFile, JSON.stringify({ pid: process.pid, port: daemon.port, token: 't', mode: 'headed', configHash: 'started-by-another-session' }));
-    const env: Record<string, string> = {};
-    for (const [key, value] of Object.entries(process.env)) if (value !== undefined && !/^(BROWSE_|GSTACK_)/.test(key)) env[key] = value;
-    Object.assign(env, { HOME: scratch, GSTACK_HOME: path.join(scratch, '.gstack'), BROWSE_STATE_FILE: stateFile });
-    const cli = Bun.spawn([process.execPath, CLI, ...args], { cwd: scratch, env, stdin: 'ignore', stdout: 'pipe', stderr: 'pipe' });
-    const timer = setTimeout(() => cli.kill('SIGKILL'), 30_000);
-    const [code, out, err] = await Promise.all([cli.exited, new Response(cli.stdout).text(), new Response(cli.stderr).text()]);
-    clearTimeout(timer);
-    return { code, out: out + err };
-  }
-
-  test('a plain call is told another session started it, and both remedies', async () => {
-    const r = await run(['text']);
-    expect(r.code).toBe(1);
-    expect(r.out).toContain('running with --headed/--proxy (started by another session)');
-    expect(r.out).toContain("pass the same flags to use it, or run 'browse disconnect'");
-    expect(r.out).not.toContain('to apply --proxy/--headed');
-    expect(r.out).toContain('BROWSER.md, "Daemon discipline": https://github.com/garrytan/gstack/blob/main/BROWSER.md#headed-mode--proxy--browser-native-downloads-v12800');
-  }, 45_000);
-
-  test('a call that passed a different flag keeps the apply-via-disconnect hint', async () => {
-    const r = await run(['--proxy', 'http://127.0.0.1:9', 'text']);
-    expect(r.code).toBe(1);
-    expect(r.out).toContain("run 'browse disconnect' first to apply --proxy/--headed");
-  }, 45_000);
-});
-
-describe('#3030: BROWSER.md says how to enable WebGL', () => {
-  const browserMd = fs.readFileSync(path.resolve(import.meta.dir, '../../BROWSER.md'), 'utf8');
-
-  test('the GSTACK_DISABLE_GPU row states the effect and the only recognized value', () => {
-    const row = browserMd.split('\n').find(line => line.startsWith('| `GSTACK_DISABLE_GPU`')) ?? '';
-    expect(row).toContain('also disables WebGL');
-    expect(row).toContain('Set `GSTACK_DISABLE_GPU=off` to enable WebGL (`off` is the only recognized value).');
-  });
-
-  test('the Daemon discipline paragraph sits under the heading the refusal links to', () => {
-    const heading = browserMd.indexOf('### Headed mode + proxy + browser-native downloads (v1.28.0.0)');
-    const discipline = browserMd.indexOf('**Daemon discipline.**');
-    expect(heading).toBeGreaterThan(-1);
-    expect(discipline).toBeGreaterThan(heading);
-    expect(browserMd.slice(heading + 3, discipline).replace(/```[\s\S]*?```/g, '')).not.toMatch(/\n#{1,3} /);
-  });
-});

package/.agent/skills/gstack-browse/test/cli-lock.test.ts

@@ -1,120 +0,0 @@
-/**
- * #1084 diagnostics — merged-design shape.
- *
- * Main's smell wave pinned a log-and-return-null acquireServerLock; this
- * branch keeps the typed ServerLockError + bounded-retry design (fully pinned
- * in server-lock-errors.test.ts). This file re-expresses the non-redundant
- * assertion intents from the wave's test against the kept design:
- *   - unexpected open failures surface the REAL errno + lock path (typed
- *     throw), never phantom "another process holds the lock" contention;
- *   - holder-PID read failures surface errno + lock path the same way;
- *   - genuine live contention stays SILENT (null return, no stderr noise).
- * Exact duplicates of server-lock-errors.test.ts coverage (stale-lock
- * reacquire, ENOENT self-heal, EACCES throw) are deliberately not repeated.
- */
-import { describe, expect, test } from 'bun:test';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { acquireServerLock, ServerLockError } from '../src/cli';
-
-function withTempDir<T>(fn: (dir: string) => T): T {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-lock-'));
-  try {
-    return fn(dir);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-}
-
-function captureErrors<T>(fn: () => T): { result: T; messages: string[] } {
-  const original = console.error;
-  const messages: string[] = [];
-  console.error = (...args: unknown[]) => {
-    messages.push(args.map(String).join(' '));
-  };
-  try {
-    return { result: fn(), messages };
-  } finally {
-    console.error = original;
-  }
-}
-
-describe('browse CLI server lock diagnostics (#1084)', () => {
-  test('unexpected open failures throw ServerLockError with the real errno — not phantom lock contention', () => {
-    if (process.platform === 'win32') return; // ENOTDIR errno mapping differs on Windows
-    withTempDir((dir) => {
-      // A FILE where a directory is expected: open('wx') fails ENOTDIR — an
-      // errno that is neither contention (EEXIST) nor the self-healing
-      // missing-dir case (ENOENT). The old code's bare catch would have
-      // reported "another process holds the lock" forever.
-      const blocker = path.join(dir, 'blocker');
-      fs.writeFileSync(blocker, 'not a directory\n');
-      const lockPath = path.join(blocker, 'browse.json.lock');
-
-      let thrown: any = null;
-      try {
-        acquireServerLock(lockPath);
-      } catch (err) {
-        thrown = err;
-      }
-      expect(thrown).toBeInstanceOf(ServerLockError);
-      expect(thrown.code).toBe('ENOTDIR');
-      expect(thrown.message).toContain('E_SERVER_LOCK (ENOTDIR)');
-      expect(thrown.message).toContain(lockPath);
-    });
-  });
-
-  test('returns null silently when a live process holds the lock', () => {
-    withTempDir((dir) => {
-      const lockPath = path.join(dir, 'browse.json.lock');
-      fs.writeFileSync(lockPath, `${process.pid}\n`);
-
-      const { result, messages } = captureErrors(() => acquireServerLock(lockPath));
-
-      expect(result).toBeNull();
-      expect(messages).toEqual([]);
-    });
-  });
-
-  test('holder PID read failures throw ServerLockError with code and lock path', () => {
-    withTempDir((dir) => {
-      // Lock path exists but is a DIRECTORY: open('wx') → EEXIST (looks like
-      // contention), then the holder-PID read fails EISDIR. The kept design
-      // surfaces that errno + path in a typed error instead of retrying or
-      // reporting phantom contention.
-      const lockPath = path.join(dir, 'browse.json.lock');
-      fs.mkdirSync(lockPath);
-
-      let thrown: any = null;
-      try {
-        acquireServerLock(lockPath);
-      } catch (err) {
-        thrown = err;
-      }
-      expect(thrown).toBeInstanceOf(ServerLockError);
-      expect(thrown.code).toBe('EISDIR');
-      expect(thrown.message).toContain('E_SERVER_LOCK (EISDIR)');
-      expect(thrown.message).toContain(lockPath);
-    });
-  });
-});
-
-// #2732 absorption (wave-added test): cli.ts's profile-lock cleanup and orphan
-// kill must resolve the profile dir through the canonical resolver — a
-// hardcoded ~/.gstack/chromium-profile here silently ignored $CHROMIUM_PROFILE
-// and $GSTACK_HOME, so `browse stop` unlinked locks and SIGKILLed a PID
-// belonging to an UNRELATED browser whenever a custom profile was active.
-// resolveChromiumProfile's env behavior is pinned in browse/test/config.test.ts;
-// this pins the cli.ts wiring to it.
-describe('chromiumProfileDir wiring (#2732)', () => {
-  const cliSrc = fs.readFileSync(path.join(import.meta.dir, '..', 'src', 'cli.ts'), 'utf-8');
-
-  test('cli.ts delegates to resolveChromiumProfile', () => {
-    expect(cliSrc).toMatch(/function chromiumProfileDir\(\): string \{\s*return resolveChromiumProfile\(\);/);
-  });
-
-  test('no hardcoded chromium-profile path remains in cli.ts', () => {
-    expect(cliSrc).not.toMatch(/['"]\.gstack['"],\s*['"]chromium-profile['"]/);
-  });
-});

package/.agent/skills/gstack-browse/test/cli-loopback-no-proxy.test.ts

@@ -1,77 +0,0 @@
-/**
- * G4 (#494): with HTTP_PROXY set, the CLI's loopback calls to its own daemon
- * went through the proxy, so the daemon never looked healthy. The CLI appends
- * loopback to NO_PROXY (keeping the user's entries) before its first fetch.
- */
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { withLoopbackNoProxy } from '../src/cli';
-
-const CLI = path.resolve(import.meta.dir, '../src/cli.ts');
-
-describe('withLoopbackNoProxy', () => {
-  test('appends loopback names to an existing list without replacing it', () => {
-    expect(withLoopbackNoProxy({ NO_PROXY: 'corp.internal, .example.com' })).toBe('corp.internal,.example.com,127.0.0.1,localhost,::1');
-    expect(withLoopbackNoProxy({ no_proxy: 'corp.internal' })).toBe('corp.internal,127.0.0.1,localhost,::1');
-    expect(withLoopbackNoProxy({})).toBe('127.0.0.1,localhost,::1');
-    expect(withLoopbackNoProxy({ NO_PROXY: 'localhost,127.0.0.1,::1' })).toBe('localhost,127.0.0.1,::1');
-  });
-});
-
-describe('CLI → daemon behind a proxy that fails every request', () => {
-  let scratch: string;
-  let proxy: ReturnType<typeof Bun.serve>;
-  let proxied = 0;
-
-  beforeEach(() => {
-    scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-no-proxy-'));
-    proxied = 0;
-    proxy = Bun.serve({ hostname: '127.0.0.1', port: 0, fetch: () => { proxied++; return new Response('proxy refuses', { status: 502 }); } });
-  });
-
-  afterEach(() => {
-    try { proxy.stop(true); } catch {}
-    const stateFile = path.join(scratch, 'state', 'browse.json');
-    if (fs.existsSync(stateFile)) {
-      try { process.kill(JSON.parse(fs.readFileSync(stateFile, 'utf-8')).pid, 'SIGKILL'); } catch {}
-    }
-    fs.rmSync(scratch, { recursive: true, force: true });
-  });
-
-  test.skipIf(process.platform === 'win32')('status reaches the daemon directly and the daemon keeps the user NO_PROXY entries', async () => {
-    const stateFile = path.join(scratch, 'state', 'browse.json');
-    const stub = path.join(scratch, 'stub-server.ts');
-    fs.writeFileSync(stub, `
-      import * as fs from 'node:fs';
-      const server = Bun.serve({ hostname: '127.0.0.1', port: 0, fetch: () => Response.json({ status: 'healthy' }) });
-      fs.writeFileSync(process.env.BROWSE_STATE_FILE!, JSON.stringify({
-        pid: process.pid, port: server.port, token: 'no-proxy-test', mode: 'launched', noProxy: process.env.NO_PROXY,
-      }));
-      setTimeout(() => server.stop(true), 5000);
-    `);
-    const env: Record<string, string> = {};
-    for (const [key, value] of Object.entries(process.env)) {
-      if (value !== undefined && !/^(BROWSE_|GSTACK_|NO_PROXY$|no_proxy$|HTTPS?_PROXY$|https?_proxy$|ALL_PROXY$|all_proxy$)/.test(key)) env[key] = value;
-    }
-    Object.assign(env, {
-      HOME: scratch,
-      GSTACK_HOME: path.join(scratch, '.gstack'),
-      BROWSE_STATE_FILE: stateFile,
-      BROWSE_SERVER_SCRIPT: stub,
-      BROWSE_PARENT_PID: '0',
-      BROWSE_START_TIMEOUT: '8000',
-      HTTP_PROXY: `http://127.0.0.1:${proxy.port}`,
-      http_proxy: `http://127.0.0.1:${proxy.port}`,
-      NO_PROXY: 'corp.internal',
-    });
-    const cli = Bun.spawn([process.execPath, CLI, 'status'], { cwd: scratch, env, stdout: 'pipe', stderr: 'pipe' });
-    const timer = setTimeout(() => cli.kill('SIGKILL'), 30_000);
-    const [code, stdout, stderr] = await Promise.all([cli.exited, new Response(cli.stdout).text(), new Response(cli.stderr).text()]);
-    clearTimeout(timer);
-    expect(code, stdout + stderr).toBe(0);
-    expect(proxied).toBe(0);
-    expect(JSON.parse(fs.readFileSync(stateFile, 'utf-8')).noProxy).toBe('corp.internal,127.0.0.1,localhost,::1');
-  }, 45_000);
-});

package/.agent/skills/gstack-browse/test/cli-setsid-daemonize.test.ts

@@ -1,75 +0,0 @@
-/**
- * Coverage for #1612 — macOS/Linux server must survive sandboxed-shell
- * harnesses by becoming its own session leader (setsid).
- *
- * Pre-#1612, Bun.spawn().unref() removed the child from Bun's event loop
- * but did NOT call setsid(). When the CLI ran inside Claude Code's
- * per-command sandbox, Conductor, or CI step runners, the session leader's
- * exit sent SIGHUP to every PID in the session, killing the bun server.
- *
- * The fix routes macOS/Linux spawn through Node's child_process.spawn with
- * detached:true, which calls setsid() so the server becomes its own session
- * leader (PPID=1 on Linux, similar reparenting on Darwin).
- *
- * The actual setsid syscall is hard to assert in a unit test without a
- * real spawn — testing here is static: the cli.ts source must use the
- * Node spawn path on macOS/Linux, with detached:true and .unref(). If a
- * future refactor reverts to Bun.spawn().unref() on the macOS/Linux branch
- * the regression returns and these tests fail.
- */
-import { describe, expect, test } from "bun:test";
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-const ROOT = path.resolve(import.meta.dir, "..", "..");
-const CLI = path.join(ROOT, "browse", "src", "cli.ts");
-
-function read(): string {
-  return fs.readFileSync(CLI, "utf-8");
-}
-
-describe("#1612 macOS/Linux daemonize via Node setsid path", () => {
-  test("cli.ts imports nodeSpawn from child_process (Node spawn alias)", () => {
-    const body = read();
-    // The fix relies on Node's child_process.spawn (which calls setsid on
-    // detached:true), aliased to avoid name collision with Bun.spawn. Match
-    // either `nodeSpawn` or `spawn as nodeSpawn` to be flexible to the
-    // exact import style.
-    expect(body).toMatch(/(spawn as nodeSpawn|nodeSpawn\s*[,}])/);
-    expect(body).toMatch(/from\s+['"]child_process['"]/);
-  });
-
-  test("non-Windows branch uses nodeSpawn(...).unref() with detached:true", () => {
-    const body = read();
-    // Find the non-Windows branch and assert it uses the Node spawn alias
-    // with detached:true. Match the pattern `nodeSpawn(...) ... detached:true`.
-    expect(body).toMatch(/nodeSpawn\([\s\S]{0,500}detached:\s*true/);
-    expect(body).toMatch(/nodeSpawn\([\s\S]{0,500}\.unref\(\)/);
-  });
-
-  test("non-Windows branch comment documents setsid/SIGHUP root cause", () => {
-    const body = read();
-    // The comment block must mention setsid() so a future refactor sees the
-    // why before changing the spawn call.
-    expect(body).toMatch(/setsid/);
-    expect(body).toMatch(/SIGHUP/);
-  });
-
-  test("the spawn call on macOS/Linux is nodeSpawn, not Bun.spawn", () => {
-    const body = read();
-    // Strip line comments before regex matching, so the "Bun.spawn().unref()"
-    // mentions inside the explanatory comment don't trigger false positives.
-    const codeOnly = body
-      .split("\n")
-      .filter((line) => !line.trim().startsWith("//"))
-      .join("\n");
-    // Find the non-Windows branch. The `} else {` block following the
-    // Windows branch. We then require its first ~400 chars contain a
-    // nodeSpawn() call and NOT a Bun.spawn() call (excluding the comment).
-    const nonWindowsStart = codeOnly.indexOf("nodeSpawn('bun'");
-    expect(nonWindowsStart).toBeGreaterThan(-1);
-    const slice = codeOnly.slice(nonWindowsStart, nonWindowsStart + 400);
-    expect(slice).toMatch(/nodeSpawn\(/);
-    expect(slice).not.toMatch(/Bun\.spawn\(/);
-  });
-});

package/.agent/skills/gstack-browse/test/cli-start-final-healthcheck.test.ts

@@ -1,77 +0,0 @@
-/**
- * Coverage for #1846 — `browse` CLI must not report "Server failed to start
- * within Ns" when the detached daemon actually came up healthy a moment later.
- *
- * The spawned server is `detached: true` + `.unref()`'d, so it keeps booting
- * independently of the CLI's poll loop. On a loaded machine (the issue repro is
- * Windows under load) the loop's budget can elapse in the gap between its last
- * health tick and the daemon becoming ready — the very next `browse status`
- * then shows a healthy, listening server. #1732 only widened the budget; the
- * throw site itself still fired on timeout regardless of real health.
- *
- * Two invariants are defended here:
- *   1. `startServer` does a final readState()+isServerHealthy() re-check before
- *      the timeout throw (structural — removes the false negative at any budget).
- *   2. The startup budget is env-overridable via BROWSE_START_TIMEOUT, matching
- *      the BROWSE_* tunable convention (BROWSE_PORT, BROWSE_IDLE_TIMEOUT, ...).
- *
- * (1) is a static source invariant (live spawn cycles belong in the e2e tier);
- * (2) is exercised behaviorally against the exported pure helper.
- */
-import { describe, expect, test } from 'bun:test';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { resolveStartTimeout } from '../src/cli';
-
-const CLI = path.join(import.meta.dir, '..', 'src', 'cli.ts');
-const read = (): string => fs.readFileSync(CLI, 'utf-8');
-
-describe('#1846 startServer false-negative on a late-healthy detached daemon', () => {
-  test('a final health re-check sits between the poll loop and the timeout throw', () => {
-    const src = read();
-    const throwIdx = src.indexOf('Server failed to start within');
-    expect(throwIdx).toBeGreaterThan(-1);
-
-    // The startServer poll loop ends at its `await Bun.sleep(100)`; the final
-    // re-check must live AFTER that loop and BEFORE the timeout throw.
-    const loopEnd = src.lastIndexOf('await Bun.sleep(100)', throwIdx);
-    expect(loopEnd).toBeGreaterThan(-1);
-    const between = src.slice(loopEnd, throwIdx);
-
-    // It must re-read state and re-probe health, then be able to return — i.e.
-    // a genuine recovery path, not just a comment.
-    expect(between).toContain('readState()');
-    expect(between).toMatch(/isServerHealthy\([^)]*\)/);
-    expect(between).toMatch(/return\s+\w+;/);
-  });
-
-  test('the re-check returns the recovered state rather than swallowing it', () => {
-    const src = read();
-    // Guard against a refactor that probes health but forgets to return the
-    // state (which would re-introduce the false negative).
-    expect(src).toMatch(/if\s*\([^)]*await\s+isServerHealthy\([^)]*\)\)\s*\{\s*return\s+\w+;/);
-  });
-});
-
-describe('#1846 BROWSE_START_TIMEOUT env override (resolveStartTimeout)', () => {
-  const platformDefault = resolveStartTimeout({} as NodeJS.ProcessEnv);
-
-  test('platform default is a positive millisecond budget when unset', () => {
-    expect(platformDefault).toBeGreaterThan(0);
-  });
-
-  test('honors a positive BROWSE_START_TIMEOUT override', () => {
-    expect(resolveStartTimeout({ BROWSE_START_TIMEOUT: '42000' } as NodeJS.ProcessEnv)).toBe(42000);
-  });
-
-  test('falls back to the platform default for non-positive / unparseable values', () => {
-    for (const bad of ['0', '-5', 'abc', '', '   ']) {
-      expect(resolveStartTimeout({ BROWSE_START_TIMEOUT: bad } as NodeJS.ProcessEnv)).toBe(platformDefault);
-    }
-  });
-
-  test('MAX_START_WAIT is wired through resolveStartTimeout (no stray hardcoded constant)', () => {
-    const src = read();
-    expect(src).toMatch(/const\s+MAX_START_WAIT\s*=\s*resolveStartTimeout\(\)/);
-  });
-});