@amg555/frameforge-mcp 2.7.6 → 2.7.8

package/.agent/skills/gstack-browse/test/poisoned-bundle-probe.test.ts

@@ -1,148 +0,0 @@
-/**
- * Unit tests for the extracted poisoned-bundle self-heal probe (#2242).
- *
- * probePoisonedChromiumBundle() detects a Chromium bundle mutated by the
- * pre-v1.64 in-place rebrand (Info.plist contains "GStack Browser"),
- * removes it so `playwright install chromium` actually re-downloads, and
- * throws a typed PoisonedBundleError with the remediation command.
- *
- * Contracts pinned here:
- *   - standard cache layout (chromium-<rev>/chrome-mac/<name>.app): the
- *     WHOLE revision dir is removed, INSTALLATION_COMPLETE marker included
- *     (leaving the marker makes the recommended re-fetch a no-op)
- *   - non-cache layout: the .app + sibling install markers are removed,
- *     nothing else
- *   - clean bundle: untouched, no throw
- *   - GSTACK_CHROMIUM_PATH bundles (custom/embedder) are NEVER deleted:
- *     the probe refuses to act on that executable, and both call sites
- *     (launchHeaded + handoff) only pass chromium.executablePath()
- *   - the rethrow guard at the call sites is typed (instanceof), not a
- *     fragile message-string match
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { probePoisonedChromiumBundle, PoisonedBundleError } from '../src/browser-manager';
-
-const SRC = fs.readFileSync(
-  path.join(import.meta.dir, '..', 'src', 'browser-manager.ts'),
-  'utf-8',
-);
-
-const POISONED_PLIST =
-  '<plist><dict><key>CFBundleName</key><string>GStack Browser</string></dict></plist>';
-const CLEAN_PLIST =
-  '<plist><dict><key>CFBundleName</key><string>Google Chrome for Testing</string></dict></plist>';
-
-let tmpDir: string;
-let savedCustomPath: string | undefined;
-
-/** Build <parentDir>/<name>.app with a plist and executable; return the executable path. */
-function makeApp(parentDir: string, plist: string): { appDir: string; exe: string } {
-  const appDir = path.join(parentDir, 'Google Chrome for Testing.app');
-  const macos = path.join(appDir, 'Contents', 'MacOS');
-  fs.mkdirSync(macos, { recursive: true });
-  fs.writeFileSync(path.join(appDir, 'Contents', 'Info.plist'), plist);
-  const exe = path.join(macos, 'Google Chrome for Testing');
-  fs.writeFileSync(exe, '#!/bin/sh\n', { mode: 0o755 });
-  return { appDir, exe };
-}
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'poison-probe-'));
-  savedCustomPath = process.env.GSTACK_CHROMIUM_PATH;
-  delete process.env.GSTACK_CHROMIUM_PATH;
-});
-
-afterEach(() => {
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-  if (savedCustomPath === undefined) delete process.env.GSTACK_CHROMIUM_PATH;
-  else process.env.GSTACK_CHROMIUM_PATH = savedCustomPath;
-});
-
-describe('probePoisonedChromiumBundle — poisoned cache bundle', () => {
-  test('standard cache layout: whole chromium-<rev> dir removed (markers included), typed error thrown', () => {
-    const revDir = path.join(tmpDir, 'ms-playwright', 'chromium-1234');
-    const { exe } = makeApp(path.join(revDir, 'chrome-mac'), POISONED_PLIST);
-    fs.writeFileSync(path.join(revDir, 'INSTALLATION_COMPLETE'), '');
-    fs.writeFileSync(path.join(revDir, 'DEPENDENCIES_VALIDATED'), '');
-
-    let caught: unknown;
-    try {
-      probePoisonedChromiumBundle(exe);
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PoisonedBundleError);
-    // The message is the user's remediation — it must carry the command.
-    expect((caught as Error).message).toContain('playwright install chromium');
-    // Whole revision dir gone: leaving INSTALLATION_COMPLETE behind makes
-    // `playwright install chromium` no-op ("is already downloaded") and the
-    // remediation we just printed would do nothing.
-    expect(fs.existsSync(revDir)).toBe(false);
-  });
-
-  test('non-cache layout: only the .app + sibling install markers removed, neighbors survive', () => {
-    const parentDir = path.join(tmpDir, 'custom-bundles');
-    const { appDir, exe } = makeApp(parentDir, POISONED_PLIST);
-    fs.writeFileSync(path.join(parentDir, 'INSTALLATION_COMPLETE'), '');
-    fs.writeFileSync(path.join(parentDir, 'DEPENDENCIES_VALIDATED'), '');
-    fs.writeFileSync(path.join(parentDir, 'unrelated.txt'), 'keep me');
-
-    expect(() => probePoisonedChromiumBundle(exe)).toThrow(PoisonedBundleError);
-    expect(fs.existsSync(appDir)).toBe(false);
-    expect(fs.existsSync(path.join(parentDir, 'INSTALLATION_COMPLETE'))).toBe(false);
-    expect(fs.existsSync(path.join(parentDir, 'DEPENDENCIES_VALIDATED'))).toBe(false);
-    // The parent dir itself and unrelated files are NOT swept.
-    expect(fs.readFileSync(path.join(parentDir, 'unrelated.txt'), 'utf-8')).toBe('keep me');
-  });
-});
-
-describe('probePoisonedChromiumBundle — clean and missing bundles', () => {
-  test('clean plist: untouched, no throw', () => {
-    const revDir = path.join(tmpDir, 'ms-playwright', 'chromium-1234');
-    const { appDir, exe } = makeApp(path.join(revDir, 'chrome-mac'), CLEAN_PLIST);
-    fs.writeFileSync(path.join(revDir, 'INSTALLATION_COMPLETE'), '');
-
-    expect(() => probePoisonedChromiumBundle(exe)).not.toThrow();
-    expect(fs.existsSync(path.join(appDir, 'Contents', 'Info.plist'))).toBe(true);
-    expect(fs.existsSync(path.join(revDir, 'INSTALLATION_COMPLETE'))).toBe(true);
-  });
-
-  test('no plist at the probed path: no-op, no throw (bundle not installed yet)', () => {
-    expect(() =>
-      probePoisonedChromiumBundle(path.join(tmpDir, 'nope.app', 'Contents', 'MacOS', 'nope')),
-    ).not.toThrow();
-  });
-});
-
-describe('probePoisonedChromiumBundle — GSTACK_CHROMIUM_PATH is never deleted', () => {
-  test('probe refuses to act on the GSTACK_CHROMIUM_PATH executable, even when poisoned', () => {
-    // A custom/embedder bundle (GStack Browser.app wrapper) legitimately
-    // contains "GStack Browser" in its plist — that is its branding, not
-    // cache poison. Deleting it would destroy the embedder's product.
-    const { appDir, exe } = makeApp(path.join(tmpDir, 'GStack Browser.app-parent'), POISONED_PLIST);
-    process.env.GSTACK_CHROMIUM_PATH = exe;
-
-    expect(() => probePoisonedChromiumBundle(exe)).not.toThrow();
-    expect(fs.existsSync(path.join(appDir, 'Contents', 'Info.plist'))).toBe(true);
-    expect(fs.existsSync(exe)).toBe(true);
-  });
-
-  test('caller contract: both headed launch paths probe chromium.executablePath() only', () => {
-    // launchHeaded + handoff each call the probe with the Playwright-cache
-    // path. No call site may ever pass the custom-bundle env var.
-    const calls = SRC.match(/probePoisonedChromiumBundle\(chromium\.executablePath\(\)\)/g) || [];
-    expect(calls.length).toBeGreaterThanOrEqual(2);
-    expect(SRC).not.toMatch(/probePoisonedChromiumBundle\([^)]*GSTACK_CHROMIUM_PATH/);
-  });
-});
-
-describe('typed rethrow guard at the call sites', () => {
-  test('instanceof PoisonedBundleError, not message-string sniffing', () => {
-    expect(SRC).not.toContain("includes('poisoned bundle')");
-    expect(SRC).toMatch(/instanceof PoisonedBundleError/);
-  });
-});

package/.agent/skills/gstack-browse/test/process-liveness-windows.test.ts

@@ -1,176 +0,0 @@
-import { describe, test, expect, spyOn } from 'bun:test';
-import * as childProcess from 'node:child_process';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { isProcessAlive } from '../src/error-handling';
-import { spawnTerminalAgent } from '../src/terminal-agent-control';
-
-// REGRESSION TEST for the Windows terminal-agent leak.
-//
-// Symptom (reported on Windows 11, 48GB box under a heavy parallel build):
-// a console window popped to the foreground every 60 seconds, and orphaned
-// `bun run terminal-agent.ts` processes accumulated at one per minute until
-// the machine ran out of committable memory.
-//
-// Root cause was a three-bug chain, each of which this file pins:
-//
-//   1. `isProcessAlive` shelled out to `tasklist` on Windows with a 3s
-//      timeout. A Bun.spawnSync that hits its timeout STILL RETURNS, carrying
-//      partial stdout — so the `.includes()` PID match came back false and a
-//      LIVE agent was reported dead. Measured tasklist latency was 700-1700ms
-//      idle, and far worse under memory pressure, so the timeout was reachable
-//      in ordinary use.
-//   2. That false negative made `killAgentByRecord` skip the kill (it
-//      validates liveness first) while the watchdog respawned anyway —
-//      leaking the survivor. Each orphan added memory pressure, slowing the
-//      next tasklist, producing the next false negative. Self-reinforcing.
-//   3. Neither the tasklist probe nor the agent spawn passed `windowsHide`,
-//      so every tick allocated a visible console and stole focus.
-//
-// The guard-window arithmetic bug that let this run unbounded instead of
-// tripping the crash-loop guard is pinned separately, in test 6.
-
-const SRC_DIR = path.resolve(import.meta.dir, '..', 'src');
-
-function readAllSourceFiles(): Array<{ file: string; content: string }> {
-  return fs
-    .readdirSync(SRC_DIR)
-    .filter((e) => e.endsWith('.ts'))
-    .map((e) => ({ file: e, content: fs.readFileSync(path.join(SRC_DIR, e), 'utf-8') }));
-}
-
-/** Strip line and block comments so static greps only see real code. */
-function stripComments(src: string): string {
-  return src.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
-}
-
-describe('process liveness probe (Windows terminal-agent leak)', () => {
-  test('1. isProcessAlive reports the current process alive', () => {
-    expect(isProcessAlive(process.pid)).toBe(true);
-  });
-
-  test('2. isProcessAlive reports an unused PID dead', () => {
-    // Below Linux PID_MAX_LIMIT, far above any realistic Windows/macOS PID.
-    expect(isProcessAlive(2147483646)).toBe(false);
-  });
-
-  test('2b. EPERM means ALIVE: an unsignalable-but-existing PID is not dead (T2)', () => {
-    // signal-0 to a process we lack permission over throws EPERM — the
-    // process EXISTS, we just can't signal it. Treating EPERM as "dead" is
-    // the false negative that leaked agents. PID 1 (launchd/init) on POSIX
-    // and PID 4 (System) on Windows always exist and are either signalable
-    // or EPERM — both must read as alive.
-    expect(isProcessAlive(process.platform === 'win32' ? 4 : 1)).toBe(true);
-  });
-
-  test('3. isProcessAlive spawns NO subprocess on ANY platform (signal-0, #1952)', () => {
-    // The heart of the bug: a liveness probe that forks is slow enough to
-    // time out, and a timed-out probe silently answers "dead". Signal 0
-    // cannot time out because it never leaves the process. Node maps
-    // process.kill(pid, 0) to an OpenProcess existence check on Windows —
-    // and the Windows daemon runs under Node (server-node.mjs +
-    // bun-polyfill), so the POSIX idiom is portable and the win32 tasklist
-    // branch is GONE (it caused both the false negatives above and the
-    // per-tick console flash of #1952).
-    const origSpawn = (Bun as any).spawn;
-    const origSpawnSync = (Bun as any).spawnSync;
-    const spawns: string[] = [];
-    (Bun as any).spawn = (...args: any[]) => { spawns.push(`spawn:${JSON.stringify(args[0])}`); return origSpawn(...args); };
-    (Bun as any).spawnSync = (...args: any[]) => { spawns.push(`spawnSync:${JSON.stringify(args[0])}`); return origSpawnSync(...args); };
-    try {
-      isProcessAlive(process.pid);
-      isProcessAlive(2147483646);
-      expect(spawns).toEqual([]);
-    } finally {
-      (Bun as any).spawn = origSpawn;
-      (Bun as any).spawnSync = origSpawnSync;
-    }
-  });
-
-  test('4. no source file probes liveness via tasklist — signal-0 is the only probe (#1952)', () => {
-    // Static tripwire: a tasklist existence check ANYWHERE in src/
-    // resurrects both the false-negative class (#2414: a timed-out spawnSync
-    // still returns, with partial stdout, so a live process reads as dead)
-    // and the per-tick console flash (#1952). isProcessAlive uses
-    // process.kill(pid, 0) on every platform; nothing gets an exemption.
-    const offenders: string[] = [];
-    for (const { file, content } of readAllSourceFiles()) {
-      const code = stripComments(content);
-      // `PID eq` is the existence-probe form specifically. Other tasklist
-      // uses (e.g. IMAGENAME filters for browser detection) are unaffected.
-      if (/tasklist/.test(code) && /PID eq/.test(code)) offenders.push(file);
-    }
-    expect(offenders).toEqual([]);
-  });
-
-  test('5. spawnTerminalAgent passes windowsHide so no console is shown', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-hide-'));
-    const script = path.join(tmpDir, 'fake-agent.ts');
-    fs.writeFileSync(script, '// no-op\n');
-    const origSpawn = (Bun as any).spawn;
-    const originalProbe = Bun.spawnSync;
-    const originalWindowsProbe = childProcess.spawnSync;
-    const probe = spyOn(Bun, 'spawnSync').mockImplementation(((command: string[], options: any) => {
-      if (command[0] === 'ps' && command[2] === String(process.pid)) {
-        return { exitCode: 0, stdout: Buffer.from('fixture-owner-start'), stderr: Buffer.alloc(0) };
-      }
-      return originalProbe(command, options);
-    }) as typeof Bun.spawnSync);
-    const windowsProbe = spyOn(childProcess, 'spawnSync').mockImplementation(((command: string, args: string[], options: any) => {
-      if (command === 'powershell.exe') {
-        const owner = args.join(' ').includes(`ProcessId = ${process.pid}'`);
-        return { status: 0, stdout: JSON.stringify(owner ? { CreationDate: 'fixture-owner-start', CommandLine: 'test-owner' } : null), stderr: '' };
-      }
-      return originalWindowsProbe(command, args, options);
-    }) as typeof childProcess.spawnSync);
-    const exited = Promise.resolve(0);
-    let captured: any = null;
-    (Bun as any).spawn = (_cmd: any, opts: any) => {
-      captured = opts;
-      return { pid: 2147483647, exited, kill() {}, unref() {} };
-    };
-    try {
-      expect(() => spawnTerminalAgent({
-        stateFile: path.join(tmpDir, 'state.json'),
-        serverPort: 12345,
-        ownerPid: process.pid,
-        cwd: tmpDir,
-        scriptPath: script,
-      })).toThrow('terminal-agent process identity is unavailable');
-      expect(captured).not.toBeNull();
-      expect(captured.windowsHide).toBe(true);
-      // Owner-PID lifetime tie (#2019): the agent polls this and exits when
-      // its owning browse server dies, so it can't be adopted by PID 1.
-      expect(captured.env.BROWSE_OWNER_PID).toBe(String(process.pid));
-      expect(captured.env.BROWSE_OWNER_START_TIME).toBe('fixture-owner-start');
-      // Detached background daemon — must not inherit a terminal either.
-      expect(captured.stdio).toEqual(['ignore', 'ignore', 'ignore']);
-      await exited;
-      expect(fs.existsSync(path.join(tmpDir, 'terminal-agent-pid'))).toBe(false);
-    } finally {
-      (Bun as any).spawn = origSpawn;
-      windowsProbe.mockRestore();
-      probe.mockRestore();
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  test('6. respawn guard window spans enough ticks for the guard to fire', () => {
-    // The guard was `RESPAWN_GUARD_WINDOW_MS = 60_000` against a 60_000ms
-    // tick, allowing at most ONE respawn in the window — so the
-    // `>= RESPAWN_GUARD_MAX (3)` trip condition was unreachable and a steady
-    // one-per-tick leak never self-limited. Assert the window is derived from
-    // the tick rather than fixed.
-    const src = fs.readFileSync(path.join(SRC_DIR, 'server.ts'), 'utf-8');
-    const match = src.match(/const RESPAWN_GUARD_WINDOW_MS =([\s\S]{0,160}?);/);
-    expect(match).not.toBeNull();
-    expect(match![1]).toContain('AGENT_WATCHDOG_TICK_MS');
-
-    // Pin the arithmetic itself: at the default tick, three respawns must fit.
-    const tick = 60_000;
-    const guardMax = 3;
-    const windowMs = Math.max(60_000, tick * (guardMax + 2));
-    expect(windowMs).toBeGreaterThanOrEqual(tick * guardMax);
-  });
-});

package/.agent/skills/gstack-browse/test/proxy-config.test.ts

@@ -1,189 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { parseProxyConfig, computeConfigHash, ProxyConfigError } from '../src/proxy-config';
-import { extractGlobalFlags } from '../src/cli';
-
-describe('parseProxyConfig', () => {
-  test('parses socks5 URL with embedded creds', () => {
-    const cfg = parseProxyConfig({
-      proxyUrl: 'socks5://alice:secret@host.example.com:1080',
-    });
-    expect(cfg.scheme).toBe('socks5');
-    expect(cfg.host).toBe('host.example.com');
-    expect(cfg.port).toBe(1080);
-    expect(cfg.userId).toBe('alice');
-    expect(cfg.password).toBe('secret');
-    expect(cfg.hasAuth).toBe(true);
-  });
-
-  test('parses URL-only env-credentials', () => {
-    const cfg = parseProxyConfig({
-      proxyUrl: 'socks5://host.example.com:1080',
-      envUser: 'env-user',
-      envPass: 'env-pass',
-    });
-    expect(cfg.userId).toBe('env-user');
-    expect(cfg.password).toBe('env-pass');
-    expect(cfg.hasAuth).toBe(true);
-  });
-
-  test('parses URL-only no-auth', () => {
-    const cfg = parseProxyConfig({ proxyUrl: 'http://proxy.corp:3128' });
-    expect(cfg.scheme).toBe('http');
-    expect(cfg.hasAuth).toBe(false);
-    expect(cfg.userId).toBeUndefined();
-  });
-
-  test('D9: refuses on mixed cred sources (env + URL)', () => {
-    expect(() => parseProxyConfig({
-      proxyUrl: 'socks5://alice:secret@host:1080',
-      envUser: 'env-user',
-      envPass: 'env-pass',
-    })).toThrow(/proxy creds set in both env.*and URL/);
-  });
-
-  test('D9: refuses when env has only password and URL has user', () => {
-    // Asymmetric mixing still counts.
-    expect(() => parseProxyConfig({
-      proxyUrl: 'socks5://alice@host:1080',
-      envPass: 'env-pass',
-    })).toThrow(/pick one source/);
-  });
-
-  test('rejects malformed URL', () => {
-    expect(() => parseProxyConfig({ proxyUrl: 'not-a-url' }))
-      .toThrow(ProxyConfigError);
-  });
-
-  test('rejects unsupported scheme', () => {
-    expect(() => parseProxyConfig({ proxyUrl: 'ftp://host:21' }))
-      .toThrow(/unsupported proxy scheme/);
-  });
-
-  test('decodes URL-encoded creds', () => {
-    const cfg = parseProxyConfig({
-      proxyUrl: 'socks5://user%40example.com:p%40ss%21@host:1080',
-    });
-    expect(cfg.userId).toBe('user@example.com');
-    expect(cfg.password).toBe('p@ss!');
-  });
-});
-
-describe('computeConfigHash', () => {
-  test('same inputs → same hash', () => {
-    const a = computeConfigHash({ proxyUrl: 'socks5://host:1080', headed: true });
-    const b = computeConfigHash({ proxyUrl: 'socks5://host:1080', headed: true });
-    expect(a).toBe(b);
-  });
-
-  test('different proxy → different hash', () => {
-    const a = computeConfigHash({ proxyUrl: 'socks5://host:1080', headed: false });
-    const b = computeConfigHash({ proxyUrl: 'socks5://other:1080', headed: false });
-    expect(a).not.toBe(b);
-  });
-
-  test('different headed → different hash', () => {
-    const a = computeConfigHash({ proxyUrl: null, headed: false });
-    const b = computeConfigHash({ proxyUrl: null, headed: true });
-    expect(a).not.toBe(b);
-  });
-
-  test('strips creds before hashing (cred-stable hash)', () => {
-    // Same proxy host, different creds → same hash. We don't want the hash
-    // to change just because the user rotated their password.
-    const a = computeConfigHash({ proxyUrl: 'socks5://alice:pass1@host:1080', headed: false });
-    const b = computeConfigHash({ proxyUrl: 'socks5://alice:pass2@host:1080', headed: false });
-    expect(a).toBe(b);
-  });
-
-  test('null proxy + headed=false → stable hash', () => {
-    const hash = computeConfigHash({ proxyUrl: null, headed: false });
-    expect(hash).toMatch(/^[a-f0-9]{16}$/);
-  });
-});
-
-describe('extractGlobalFlags', () => {
-  const ENV_EMPTY: NodeJS.ProcessEnv = {};
-
-  test('strips --proxy and --headed from args', () => {
-    const result = extractGlobalFlags(
-      ['goto', 'https://example.com', '--proxy', 'socks5://h:1080', '--headed'],
-      ENV_EMPTY,
-    );
-    expect(result.args).toEqual(['goto', 'https://example.com']);
-    expect(result.proxyUrl).toContain('socks5://h:1080');
-    expect(result.headed).toBe(true);
-  });
-
-  test('supports --proxy=value form', () => {
-    const result = extractGlobalFlags(
-      ['goto', 'https://x', '--proxy=socks5://h:1080'],
-      ENV_EMPTY,
-    );
-    expect(result.proxyUrl).toContain('socks5://h:1080');
-    expect(result.args).toEqual(['goto', 'https://x']);
-  });
-
-  test('no flags → empty proxy + headed=false + non-empty hash', () => {
-    const result = extractGlobalFlags(['goto', 'https://x'], ENV_EMPTY);
-    expect(result.proxyUrl).toBeNull();
-    expect(result.headed).toBe(false);
-    expect(result.configHash).toMatch(/^[a-f0-9]{16}$/);
-  });
-
-  test('redactedProxyUrl masks creds from --proxy URL', () => {
-    const result = extractGlobalFlags(
-      ['goto', 'https://x', '--proxy', 'socks5://alice:secret@host:1080'],
-      ENV_EMPTY,
-    );
-    expect(result.redactedProxyUrl).not.toContain('alice');
-    expect(result.redactedProxyUrl).not.toContain('secret');
-    expect(result.redactedProxyUrl).toContain('***');
-    expect(result.redactedProxyUrl).toContain('host:1080');
-  });
-
-  test('D9: throws on mixed cred sources', () => {
-    expect(() => extractGlobalFlags(
-      ['goto', 'https://x', '--proxy', 'socks5://alice:secret@host:1080'],
-      { BROWSE_PROXY_USER: 'env-user', BROWSE_PROXY_PASS: 'env-pass' } as NodeJS.ProcessEnv,
-    )).toThrow(ProxyConfigError);
-  });
-
-  test('--proxy without value → throws', () => {
-    expect(() => extractGlobalFlags(
-      ['goto', 'https://x', '--proxy'],
-      ENV_EMPTY,
-    )).toThrow(ProxyConfigError);
-  });
-
-  test('env-only creds resolve into canonical proxyUrl', () => {
-    const result = extractGlobalFlags(
-      ['goto', 'https://x', '--proxy', 'socks5://host:1080'],
-      { BROWSE_PROXY_USER: 'envuser', BROWSE_PROXY_PASS: 'envpass' } as NodeJS.ProcessEnv,
-    );
-    // proxyUrl should now have the env creds embedded (URL-encoded).
-    expect(result.proxyUrl).toContain('envuser');
-    expect(result.proxyUrl).toContain('envpass');
-    expect(result.proxyUrl).toContain('host:1080');
-  });
-
-  test('configHash is stable across cred rotations', () => {
-    const a = extractGlobalFlags(
-      ['goto', 'x', '--proxy', 'socks5://u1:p1@host:1080'],
-      ENV_EMPTY,
-    );
-    const b = extractGlobalFlags(
-      ['goto', 'x', '--proxy', 'socks5://u2:p2@host:1080'],
-      ENV_EMPTY,
-    );
-    expect(a.configHash).toBe(b.configHash);
-  });
-
-  test('configHash changes between proxied vs no-proxy', () => {
-    const a = extractGlobalFlags(['goto', 'x'], ENV_EMPTY);
-    const b = extractGlobalFlags(
-      ['goto', 'x', '--proxy', 'socks5://host:1080'],
-      ENV_EMPTY,
-    );
-    expect(a.configHash).not.toBe(b.configHash);
-  });
-});

package/.agent/skills/gstack-browse/test/proxy-env-daemon.test.ts

@@ -1,137 +0,0 @@
-/**
- * #915 end to end: the CLI resolves the proxy from the standard variables and
- * the daemon's Chromium navigates through it, across launch, reuse and
- * restart. A local HTTP proxy answers every proxied request itself, so a page
- * at a name that does not resolve loads only through the proxy; a loopback
- * page loads directly. NO_PROXY is part of the daemon config, so a change to it
- * alone is refused instead of silently reusing the daemon.
- */
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import * as fs from 'node:fs';
-import * as http from 'node:http';
-import * as os from 'node:os';
-import * as path from 'node:path';
-
-const CLI = path.resolve(import.meta.dir, '../src/cli.ts');
-const PROXIED_HOST = 'proxied.gstack-915.test';
-
-let scratch = '';
-let stateFile = '';
-let proxy: http.Server;
-let proxyUrl = '';
-let direct: ReturnType<typeof Bun.serve>;
-const proxiedHosts: string[] = [];
-
-beforeAll(async () => {
-  scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'browse-proxy-env-'));
-  stateFile = path.join(scratch, 'state', 'browse.json');
-  proxy = http.createServer((req, res) => {
-    const host = new URL(req.url ?? '/', 'http://unknown').hostname;
-    proxiedHosts.push(host);
-    res.writeHead(200, { 'Content-Type': 'text/html' });
-    res.end(`<!doctype html><html><body><p>via proxy for ${host}</p></body></html>`);
-  });
-  proxy.on('connect', (_req, socket) => socket.end('HTTP/1.1 502 Bad Gateway\r\n\r\n'));
-  await new Promise<void>(resolve => proxy.listen(0, '127.0.0.1', () => resolve()));
-  proxyUrl = `http://127.0.0.1:${(proxy.address() as { port: number }).port}`;
-  direct = Bun.serve({ hostname: '127.0.0.1', port: 0, fetch: () => new Response('<!doctype html><html><body><p>direct loopback page</p></body></html>', { headers: { 'Content-Type': 'text/html' } }) });
-});
-
-afterAll(async () => {
-  await browse(['stop'], {});
-  if (fs.existsSync(stateFile)) {
-    try { process.kill(JSON.parse(fs.readFileSync(stateFile, 'utf8')).pid, 'SIGKILL'); } catch {}
-  }
-  try { direct.stop(true); } catch {}
-  await new Promise<void>(resolve => proxy.close(() => resolve()));
-  fs.rmSync(scratch, { recursive: true, force: true });
-});
-
-async function browse(args: string[], extraEnv: Record<string, string>) {
-  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'),
-    PLAYWRIGHT_BROWSERS_PATH: process.env.PLAYWRIGHT_BROWSERS_PATH || path.join(os.homedir(), ...(process.platform === 'darwin' ? ['Library', 'Caches'] : ['.cache']), 'ms-playwright'),
-    BROWSE_STATE_FILE: stateFile,
-    BROWSE_PARENT_PID: '0',
-  }, extraEnv);
-  const cli = Bun.spawn([process.execPath, CLI, ...args], { cwd: scratch, env, stdin: 'ignore', stdout: 'pipe', stderr: 'pipe' });
-  const timer = setTimeout(() => cli.kill('SIGKILL'), 60_000);
-  const [code, stdout, stderr] = await Promise.all([cli.exited, new Response(cli.stdout).text(), new Response(cli.stderr).text()]);
-  clearTimeout(timer);
-  return { code, stdout, stderr, out: stdout + stderr };
-}
-
-const daemonPid = () => JSON.parse(fs.readFileSync(stateFile, 'utf8')).pid as number;
-
-describe.skipIf(process.platform === 'win32')('#915 proxy from the environment, across launch, reuse and restart', () => {
-  let firstPid = 0;
-
-  test('launch: HTTP_PROXY routes Chromium through the proxy and names its source once', async () => {
-    const r = await browse(['goto', `http://${PROXIED_HOST}/`], { HTTP_PROXY: proxyUrl });
-    expect(r.code, r.out).toBe(0);
-    expect(r.stderr).toContain(`Starting server with proxy ${proxyUrl}/ from HTTP_PROXY...`);
-    expect(proxiedHosts).toContain(PROXIED_HOST);
-    const text = await browse(['text'], { HTTP_PROXY: proxyUrl });
-    expect(text.stdout).toContain(`via proxy for ${PROXIED_HOST}`);
-    firstPid = daemonPid();
-    const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
-    expect(state).toMatchObject({ proxy: `${proxyUrl}/`, proxySource: 'HTTP_PROXY', proxyBypass: 'localhost,127.0.0.1,[::1]' });
-  }, 120_000);
-
-  test('reuse: the same environment reuses the daemon, and loopback stays direct', async () => {
-    const before = proxiedHosts.length;
-    const r = await browse(['goto', `http://127.0.0.1:${direct.port}/`], { http_proxy: proxyUrl });
-    expect(r.code, r.out).toBe(0);
-    expect(r.stderr).not.toContain('Starting server');
-    expect(daemonPid()).toBe(firstPid);
-    expect((await browse(['text'], { http_proxy: proxyUrl })).stdout).toContain('direct loopback page');
-    expect(proxiedHosts.length).toBe(before);
-  }, 120_000);
-
-  test('a NO_PROXY-only change is refused with the variable, both settings and the remedies', async () => {
-    const r = await browse(['text'], { HTTP_PROXY: proxyUrl, NO_PROXY: PROXIED_HOST });
-    expect(r.code).toBe(1);
-    expect(r.stderr).toContain('different proxy settings (NO_PROXY differs)');
-    expect(r.stderr).toContain(`daemon:  proxy ${proxyUrl}/ from HTTP_PROXY, bypassing localhost,127.0.0.1,[::1]`);
-    expect(r.stderr).toContain(`session: proxy ${proxyUrl}/ from HTTP_PROXY, bypassing *.${PROXIED_HOST},${PROXIED_HOST},localhost,127.0.0.1,[::1]`);
-    expect(r.stderr).toContain("run 'browse stop'");
-    expect(r.stderr).toContain('BROWSER.md#proxy-from-environment');
-    expect(daemonPid()).toBe(firstPid);
-  }, 120_000);
-
-  test('BROWSE_PROXY_URL=direct against a proxied daemon is refused, naming the variable', async () => {
-    const r = await browse(['text'], { HTTP_PROXY: proxyUrl, BROWSE_PROXY_URL: 'direct' });
-    expect(r.code).toBe(1);
-    expect(r.stderr).toContain('(HTTP_PROXY differs)');
-    expect(r.stderr).toContain('session: no proxy (BROWSE_PROXY_URL=direct)');
-    expect(r.stderr).toContain("run 'browse stop'");
-  }, 120_000);
-
-  test('restart: after browse stop, the new NO_PROXY applies to the new daemon', async () => {
-    expect((await browse(['stop'], {})).code).toBe(0);
-    const before = proxiedHosts.length;
-    const r = await browse(['goto', `http://${PROXIED_HOST}/`], { HTTP_PROXY: proxyUrl, NO_PROXY: `${PROXIED_HOST},corp.internal` });
-    expect(r.stderr).toContain(`Starting server with proxy ${proxyUrl}/ from HTTP_PROXY...`);
-    expect(daemonPid()).not.toBe(firstPid);
-    expect(r.out).not.toContain(`via proxy for ${PROXIED_HOST}`);
-    expect(proxiedHosts.length).toBe(before);
-  }, 120_000);
-
-  test('a curl-style HTTPS_PROXY warns and falls back to direct instead of failing', async () => {
-    expect((await browse(['stop'], {})).code).toBe(0);
-    const before = proxiedHosts.length;
-    const r = await browse(['goto', `http://127.0.0.1:${direct.port}/`], { HTTPS_PROXY: 'user:secret@proxy.corp:8080' });
-    expect(r.code, r.out).toBe(0);
-    expect(r.stderr).toContain('warning: HTTPS_PROXY is not a proxy URL browse can use');
-    expect(r.stderr).toContain('BROWSE_PROXY_URL=direct');
-    expect(r.out).not.toContain('secret');
-    expect(r.stderr).toContain('Starting server...');
-    expect(proxiedHosts.length).toBe(before);
-    expect(JSON.parse(fs.readFileSync(stateFile, 'utf8')).proxy).toBeUndefined();
-  }, 120_000);
-});