@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/gstack-browse/test/server-route-auth-blackbox.test.ts

@@ -1,270 +0,0 @@
-/**
- * Black-box auth matrix for the browse daemon's HTTP surface.
- *
- * Drives buildFetchHandler(...).fetchLocal / fetchTunnel for every route the
- * daemon serves, on both surfaces, with no token, a wrong token, the root
- * token, a scoped token and the view-only SSE cookie. Denials assert the exact
- * status, body and content type the server returns; allowed credentials assert
- * that the response is not one of the gate denials (the handler was reached).
- *
- * This file is deliberately independent of how server.ts is organized: it was
- * written against the if-chain server and must pass unchanged against the
- * route-table server. Do not edit it to follow a refactor; a failing row here
- * means a route's observable auth behavior changed.
- */
-
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import * as crypto from 'crypto';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { buildFetchHandler, GSTACK_EXTENSION_ID, type ServerConfig, type ServerHandle } from '../src/server';
-import { __resetRegistry, __resetConnectRateLimit, createToken } from '../src/token-registry';
-import { mintSseSessionToken, SSE_COOKIE_NAME } from '../src/sse-session-cookie';
-import { BrowserManager } from '../src/browser-manager';
-import { resolveConfig } from '../src/config';
-import { usePrivateStateRoot } from '../../test/helpers/private-state-root';
-
-usePrivateStateRoot();
-
-const fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-route-blackbox-'));
-const fixtureConfig = resolveConfig({ BROWSE_STATE_FILE: path.join(fixtureDir, 'state/browse.json') });
-
-type Cred = 'none' | 'wrong' | 'root' | 'scoped' | 'sse-cookie';
-const CREDS: Cred[] = ['none', 'wrong', 'root', 'scoped', 'sse-cookie'];
-
-interface Denial { status: number; body: string; contentType: string }
-const JSON_CT = 'application/json';
-const json = (status: number, body: unknown): Denial => ({ status, body: JSON.stringify(body), contentType: JSON_CT });
-
-const UNAUTHORIZED = json(401, { error: 'Unauthorized' });
-const ROOT_REQUIRED = json(403, { error: 'Root token required' });
-const FORBIDDEN = json(403, { error: 'Forbidden' });
-const MINT_ROOT_ONLY = json(403, { error: 'Only the root token can mint sub-tokens' });
-const TUNNEL_NOT_FOUND = json(404, { error: 'Not found' });
-const TUNNEL_ROOT_REJECTED = json(403, {
-  error: 'Root token rejected on tunnel surface',
-  hint: 'Remote agents must pair via /connect to receive a scoped token.',
-});
-// A bare string Response carries no explicit Content-Type header until Bun serializes it.
-const LOCAL_NOT_FOUND: Denial = { status: 404, body: 'Not found', contentType: '' };
-const PICKER_ACCESS_DENIED: Denial = {
-  status: 403, body: 'Access denied. Open the cookie picker from gstack.', contentType: 'text/plain',
-};
-const GATE_DENIALS = [UNAUTHORIZED, ROOT_REQUIRED, FORBIDDEN, MINT_ROOT_ONLY, TUNNEL_NOT_FOUND, TUNNEL_ROOT_REJECTED];
-
-/**
- * How a route authenticates today, as observed from outside. `open` routes
- * admit every credential; the rest deny every credential except the listed
- * ones with the listed denial.
- */
-type Policy =
-  | { kind: 'open' }
-  | { kind: 'deny'; allow: Cred[]; denial: Denial };
-
-const OPEN: Policy = { kind: 'open' };
-const ROOT_BEARER: Policy = { kind: 'deny', allow: ['root'], denial: UNAUTHORIZED };
-const ROOT_TOKEN: Policy = { kind: 'deny', allow: ['root'], denial: ROOT_REQUIRED };
-const SCOPED: Policy = { kind: 'deny', allow: ['root', 'scoped'], denial: UNAUTHORIZED };
-const ROOT_OR_SSE_COOKIE: Policy = { kind: 'deny', allow: ['root', 'sse-cookie'], denial: UNAUTHORIZED };
-
-interface RouteRow {
-  method: string;
-  path: string;
-  /** Request body for every credential; keeps allowed calls on a cheap, side-effect-free branch. */
-  body?: string;
-  local: Policy;
-  /** True for the two paths the tunnel surface admits (TUNNEL_PATHS). */
-  tunnel?: 'connect' | 'command';
-  /** SSE responses stream forever; the test cancels them after the status line. */
-  stream?: boolean;
-}
-
-const ROUTES: RouteRow[] = [
-  { method: 'GET', path: '/connect', local: OPEN, tunnel: 'connect' },
-  { method: 'POST', path: '/connect', body: '{}', local: OPEN, tunnel: 'connect' },
-  { method: 'GET', path: '/cookie-picker', local: { kind: 'deny', allow: [], denial: PICKER_ACCESS_DENIED } },
-  { method: 'GET', path: '/cookie-picker/imported', local: ROOT_BEARER },
-  { method: 'OPTIONS', path: '/cookie-picker/imported', local: OPEN },
-  { method: 'GET', path: '/welcome', local: OPEN },
-  { method: 'POST', path: '/extension-token', local: { kind: 'deny', allow: [], denial: FORBIDDEN } },
-  { method: 'GET', path: '/health', local: OPEN },
-  { method: 'POST', path: '/pty-session', local: ROOT_BEARER },
-  { method: 'POST', path: '/pty-session/reattach', body: '{}', local: ROOT_BEARER },
-  { method: 'POST', path: '/pty-restart', body: '{}', local: ROOT_BEARER },
-  { method: 'POST', path: '/pty-dispose', body: '{}', local: ROOT_BEARER },
-  { method: 'POST', path: '/internal/lease-refresh', body: '{}', local: ROOT_BEARER },
-  { method: 'POST', path: '/pty-inject-scan', local: ROOT_BEARER },
-  { method: 'POST', path: '/token', body: 'not json', local: { kind: 'deny', allow: ['root'], denial: MINT_ROOT_ONLY } },
-  { method: 'DELETE', path: '/token/matrix-nobody', local: ROOT_TOKEN },
-  { method: 'GET', path: '/agents', local: ROOT_TOKEN },
-  { method: 'POST', path: '/pair', body: 'not json', local: ROOT_TOKEN },
-  { method: 'POST', path: '/tunnel/start', local: ROOT_TOKEN },
-  { method: 'POST', path: '/sse-session', local: ROOT_BEARER },
-  { method: 'GET', path: '/refs', local: ROOT_BEARER },
-  { method: 'GET', path: '/activity/stream', local: ROOT_OR_SSE_COOKIE, stream: true },
-  { method: 'GET', path: '/activity/history', local: ROOT_BEARER },
-  { method: 'POST', path: '/batch', body: '{"commands":[]}', local: SCOPED },
-  { method: 'GET', path: '/file', local: SCOPED },
-  { method: 'POST', path: '/command', body: '{"command":"__matrix_unknown__"}', local: SCOPED, tunnel: 'command' },
-  { method: 'POST', path: '/inspector/pick', body: '{}', local: ROOT_BEARER },
-  { method: 'GET', path: '/inspector', local: ROOT_BEARER },
-  { method: 'POST', path: '/inspector/apply', body: '{}', local: ROOT_BEARER },
-  { method: 'POST', path: '/inspector/reset', local: ROOT_BEARER },
-  { method: 'GET', path: '/inspector/history', local: ROOT_BEARER },
-  // /memory and /inspector/events sit behind the blanket root-bearer check, so
-  // the SSE cookie their handlers mention never reaches them today.
-  { method: 'GET', path: '/memory', local: ROOT_BEARER },
-  { method: 'GET', path: '/inspector/events', local: ROOT_BEARER, stream: true },
-];
-
-/** Requests no route accepts: unknown paths and known paths with a method no route takes. */
-const UNMATCHED: Array<{ method: string; path: string }> = [
-  { method: 'GET', path: '/no-such-route' },
-  { method: 'POST', path: '/no-such-route' },
-  { method: 'GET', path: '/command' },
-  { method: 'GET', path: '/pty-session' },
-  { method: 'PUT', path: '/token' },
-  { method: 'GET', path: '/token/someone' },
-  { method: 'GET', path: '/inspector/pick' },
-  { method: 'POST', path: '/inspector' },
-  { method: 'PUT', path: '/connect' },
-  { method: 'DELETE', path: '/command' },
-];
-
-let handle: ServerHandle;
-let rootToken = '';
-let scopedToken = '';
-let sseCookie = '';
-const savedPairAgent = process.env.GSTACK_PAIR_AGENT;
-
-beforeAll(() => {
-  // /tunnel/start's allowed branch must stop at the consent gate, never ngrok.
-  process.env.GSTACK_PAIR_AGENT = 'off';
-  __resetRegistry();
-  rootToken = 'route-blackbox-' + crypto.randomBytes(16).toString('hex');
-  const cfg: ServerConfig = {
-    authToken: rootToken,
-    browsePort: 34567,
-    config: fixtureConfig,
-    browserManager: new BrowserManager(),
-    ownsTerminalAgent: false,
-    startTime: Date.now(),
-  };
-  handle = buildFetchHandler(cfg);
-  scopedToken = createToken({ clientId: 'matrix-agent', scopes: ['read', 'write'] }).token;
-  sseCookie = mintSseSessionToken().token;
-});
-
-afterAll(() => {
-  if (savedPairAgent === undefined) delete process.env.GSTACK_PAIR_AGENT;
-  else process.env.GSTACK_PAIR_AGENT = savedPairAgent;
-  fs.rmSync(fixtureDir, { recursive: true, force: true });
-});
-
-function credHeaders(cred: Cred): Record<string, string> {
-  switch (cred) {
-    case 'none': return {};
-    case 'wrong': return { Authorization: `Bearer ${'w'.repeat(rootToken.length)}` };
-    case 'root': return { Authorization: `Bearer ${rootToken}` };
-    case 'scoped': return { Authorization: `Bearer ${scopedToken}` };
-    case 'sse-cookie': return { Cookie: `${SSE_COOKIE_NAME}=${sseCookie}` };
-  }
-}
-
-async function call(
-  surface: 'local' | 'tunnel',
-  method: string,
-  urlPath: string,
-  headers: Record<string, string>,
-  body?: string,
-  stream = false,
-): Promise<{ status: number; body: string; contentType: string }> {
-  __resetConnectRateLimit();
-  const req = new Request(`http://127.0.0.1:34567${urlPath}`, {
-    method,
-    headers: body !== undefined ? { 'Content-Type': 'application/json', ...headers } : headers,
-    body: method === 'GET' || method === 'HEAD' ? undefined : body,
-  });
-  const resp = surface === 'local' ? await handle.fetchLocal(req, null) : await handle.fetchTunnel(req, null);
-  const contentType = resp.headers.get('content-type') ?? '';
-  if (stream && resp.status === 200) {
-    await resp.body?.cancel();
-    return { status: resp.status, body: '<stream>', contentType };
-  }
-  return { status: resp.status, body: await resp.text(), contentType };
-}
-
-function expectDenial(got: { status: number; body: string; contentType: string }, want: Denial): void {
-  expect({ status: got.status, body: got.body }).toEqual({ status: want.status, body: want.body });
-  expect(got.contentType).toBe(want.contentType);
-}
-
-function expectReached(got: { status: number; body: string }): void {
-  for (const d of GATE_DENIALS) {
-    expect(got.status === d.status && got.body === d.body, `gate denial ${d.status} ${d.body}`).toBe(false);
-  }
-}
-
-function tunnelPolicy(route: RouteRow): Policy | Denial {
-  if (route.tunnel === 'connect') return OPEN;
-  if (route.tunnel === 'command') return { kind: 'deny', allow: ['scoped'], denial: UNAUTHORIZED };
-  return TUNNEL_NOT_FOUND;
-}
-
-describe('browse route auth matrix (black-box)', () => {
-  for (const route of ROUTES) {
-    for (const cred of CREDS) {
-      test(`local ${route.method} ${route.path} with ${cred}`, async () => {
-        const got = await call('local', route.method, route.path, credHeaders(cred), route.body, route.stream);
-        const p = route.local;
-        if (p.kind === 'open' || p.allow.includes(cred)) expectReached(got);
-        else expectDenial(got, p.denial);
-      });
-
-      test(`tunnel ${route.method} ${route.path} with ${cred}`, async () => {
-        const got = await call('tunnel', route.method, route.path, credHeaders(cred), route.body, route.stream);
-        const p = tunnelPolicy(route);
-        if ('status' in p) return expectDenial(got, p);
-        if (cred === 'root') return expectDenial(got, TUNNEL_ROOT_REJECTED);
-        if (p.kind === 'open' || p.allow.includes(cred)) expectReached(got);
-        else expectDenial(got, p.denial);
-      });
-    }
-  }
-
-  test('POST /pty-dispose accepts the root token in the body (sendBeacon path)', async () => {
-    const got = await call('local', 'POST', '/pty-dispose', {}, JSON.stringify({ authToken: rootToken }));
-    expect(got.status).toBe(200);
-    expect(JSON.parse(got.body)).toEqual({ ok: true });
-    const wrong = await call('local', 'POST', '/pty-dispose', {}, JSON.stringify({ authToken: 'w'.repeat(rootToken.length) }));
-    expectDenial(wrong, UNAUTHORIZED);
-  });
-
-  test('POST /extension-token releases the token only to the pinned Origin on a loopback Host', async () => {
-    const origin = `chrome-extension://${GSTACK_EXTENSION_ID}`;
-    const ok = await call('local', 'POST', '/extension-token', { Origin: origin, Host: '127.0.0.1:34567' });
-    expect(ok.status).toBe(200);
-    expect(JSON.parse(ok.body)).toEqual({ token: rootToken });
-    expectDenial(await call('local', 'POST', '/extension-token', { Origin: 'chrome-extension://someone-else', Host: '127.0.0.1:34567' }), FORBIDDEN);
-    expectDenial(await call('local', 'POST', '/extension-token', { Origin: origin, Host: 'evil.example:34567' }), FORBIDDEN);
-    expectDenial(await call('tunnel', 'POST', '/extension-token', { Origin: origin, Host: '127.0.0.1:34567' }), TUNNEL_NOT_FOUND);
-  });
-
-  for (const row of UNMATCHED) {
-    for (const cred of CREDS) {
-      test(`unmatched local ${row.method} ${row.path} with ${cred}`, async () => {
-        const got = await call('local', row.method, row.path, credHeaders(cred), row.method === 'GET' ? undefined : '{}');
-        expectDenial(got, cred === 'root' ? LOCAL_NOT_FOUND : UNAUTHORIZED);
-      });
-
-      test(`unmatched tunnel ${row.method} ${row.path} with ${cred}`, async () => {
-        const got = await call('tunnel', row.method, row.path, credHeaders(cred), row.method === 'GET' ? undefined : '{}');
-        const onTunnelPath = row.path === '/connect' || row.path === '/command';
-        if (!onTunnelPath) return expectDenial(got, TUNNEL_NOT_FOUND);
-        if (cred === 'root') return expectDenial(got, TUNNEL_ROOT_REJECTED);
-        expectDenial(got, UNAUTHORIZED);
-      });
-    }
-  }
-});

package/.agent/skills/gstack-browse/test/server-route-dispatch-ratchet.test.ts

@@ -1,129 +0,0 @@
-/**
- * Ratchet (b): browse routes are dispatched only by the route table.
- *
- * Scans buildFetchHandler's listener code (browse/src/server.ts) and the
- * route modules (browse/src/routes/*.ts) for pathname comparisons. Every one
- * must be the table's matcher or the tunnel-surface filter, listed with a
- * reason in browse/test/fixtures/route-dispatch-allowlist.json (keyed on file
- * plus matched line text, never line numbers). terminal-agent.ts, cli.ts and
- * memory-command.ts are separate listeners and out of scope. Also checks that
- * every table entry declares auth and surfaces and that gstack registers no
- * beforeRoute overlay of its own (overlays are for embedders).
- */
-
-import { describe, test, expect } from 'bun:test';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { ROUTES } from '../src/routes';
-
-const ROOT = path.resolve(import.meta.dir, '..', '..');
-const ALLOWLIST_PATH = 'browse/test/fixtures/route-dispatch-allowlist.json';
-
-interface AllowEntry { file: string; match: string; reason?: string }
-interface Violation { file: string; line: number; text: string }
-
-const PATHNAME_DISPATCH = /\bpathname\s*(?:===|!==|==|!=)|(?:===|!==|==|!=)\s*(?:url\.)?pathname\b|\bpathname\.startsWith\(|\.has\(\s*(?:url\.)?pathname\s*\)/;
-const COMMENT_LINE = /^\s*(?:\/\/|\*|\/\*)/;
-
-export function scanRouteDispatch(files: Array<{ file: string; source: string }>, allowlist: AllowEntry[]): Violation[] {
-  const allowed = new Set(allowlist.map(e => `${e.file}\0${e.match}`));
-  const violations: Violation[] = [];
-  for (const { file, source } of files) {
-    source.split('\n').forEach((raw, i) => {
-      if (COMMENT_LINE.test(raw) || !PATHNAME_DISPATCH.test(raw)) return;
-      const text = raw.trim();
-      if (!allowed.has(`${file}\0${text}`)) violations.push({ file, line: i + 1, text });
-    });
-  }
-  return violations;
-}
-
-export function formatViolations(violations: Violation[]): string {
-  return [
-    'Route dispatch outside the browse route table:',
-    ...violations.map(v => `  ${v.file}:${v.line}  ${v.text}`),
-    'Rule: every browse HTTP route is dispatched by the route table, because an inline pathname check bypasses the one auth gate and the declared surfaces.',
-    'Fix: add a route-table entry with auth and surfaces (shape in browse/src/routes/table.ts) instead of comparing url.pathname.',
-    `Allowlist: ${ALLOWLIST_PATH} — only for the tunnel-surface filter and the table's own matcher; every entry needs a reason.`,
-  ].join('\n');
-}
-
-function entriesWithoutReason(allowlist: AllowEntry[]): AllowEntry[] {
-  return allowlist.filter(e => typeof e.reason !== 'string' || e.reason.trim().length === 0);
-}
-
-function listenerSources(): Array<{ file: string; source: string }> {
-  const routeDir = path.join(ROOT, 'browse/src/routes');
-  const files = ['browse/src/server.ts', ...fs.readdirSync(routeDir).filter(f => f.endsWith('.ts')).map(f => `browse/src/routes/${f}`)];
-  return files.map(file => ({ file, source: fs.readFileSync(path.join(ROOT, file), 'utf-8') }));
-}
-
-const ALLOWLIST: AllowEntry[] = JSON.parse(fs.readFileSync(path.join(ROOT, ALLOWLIST_PATH), 'utf-8'));
-
-describe('ratchet (b): route dispatch goes through the table', () => {
-  test('no pathname comparison outside the table matcher and the tunnel filter', () => {
-    const violations = scanRouteDispatch(listenerSources(), ALLOWLIST);
-    if (violations.length) throw new Error(formatViolations(violations));
-  });
-
-  test('every allowlist entry carries a reason and still matches a line', () => {
-    const missing = entriesWithoutReason(ALLOWLIST);
-    if (missing.length) throw new Error(`Allowlist entries without a reason in ${ALLOWLIST_PATH}:\n${missing.map(e => `  ${e.file}  ${e.match}`).join('\n')}`);
-    const sources = new Map(listenerSources().map(s => [s.file, s.source.split('\n').map(l => l.trim())]));
-    for (const e of ALLOWLIST) expect(sources.get(e.file)?.includes(e.match), `${e.file}  ${e.match}`).toBe(true);
-  });
-
-  test('every table entry declares auth and surfaces', () => {
-    for (const r of ROUTES) {
-      expect(typeof r.auth, `${r.method} ${r.path}`).toBe('string');
-      expect(Array.isArray(r.surfaces) && r.surfaces.length > 0, `${r.method} ${r.path}`).toBe(true);
-    }
-  });
-
-  test('gstack registers no beforeRoute overlay of its own', () => {
-    const code = fs.readFileSync(path.join(ROOT, 'browse/src/server.ts'), 'utf-8')
-      .split('\n').filter(l => !COMMENT_LINE.test(l)).join('\n');
-    expect(code).not.toMatch(/\bbeforeRoute\s*:/);
-  });
-});
-
-describe('ratchet (b) self-test', () => {
-  const planted = {
-    file: 'browse/src/routes/planted.ts',
-    source: [
-      "import { json } from './table';",
-      'export function sneaky(url: URL) {',
-      "  if (url.pathname === '/backdoor') return json({ ok: true });",
-      '}',
-    ].join('\n'),
-  };
-
-  test('a planted inline route fails with file:line, the Fix, and the allowlist path', () => {
-    const violations = scanRouteDispatch([planted], ALLOWLIST);
-    expect(violations).toEqual([{ file: planted.file, line: 3, text: "if (url.pathname === '/backdoor') return json({ ok: true });" }]);
-    const message = formatViolations(violations);
-    expect(message).toContain("browse/src/routes/planted.ts:3  if (url.pathname === '/backdoor')");
-    expect(message).toContain('Fix: add a route-table entry with auth and surfaces');
-    expect(message).toContain(ALLOWLIST_PATH);
-  });
-
-  test('startsWith and Set.has dispatch are caught too; comments are not', () => {
-    const source = [
-      "// url.pathname === '/documented' in a comment",
-      "if (url.pathname.startsWith('/prefix')) {}",
-      'if (PATHS.has(url.pathname)) {}',
-    ].join('\n');
-    expect(scanRouteDispatch([{ file: 'x.ts', source }], []).map(v => v.line)).toEqual([2, 3]);
-  });
-
-  test('allowlist entries are keyed on text, so inserting a line above one still passes', () => {
-    const entry = { file: 'browse/src/server.ts', match: 'const allowed = TUNNEL_PATHS.has(url.pathname);', reason: 'tunnel filter' };
-    const shifted = { file: entry.file, source: `// new line\nconst x = 1;\n    ${entry.match}\n` };
-    expect(scanRouteDispatch([shifted], [entry])).toEqual([]);
-  });
-
-  test('an allowlist entry without a reason is rejected', () => {
-    expect(entriesWithoutReason([{ file: 'a.ts', match: 'x' }, { file: 'b.ts', match: 'y', reason: ' ' }, { file: 'c.ts', match: 'z', reason: 'ok' }]))
-      .toEqual([{ file: 'a.ts', match: 'x' }, { file: 'b.ts', match: 'y', reason: ' ' }]);
-  });
-});

package/.agent/skills/gstack-browse/test/server-route-table.test.ts

@@ -1,238 +0,0 @@
-/**
- * Route-table contract tests (stubbed handlers).
- *
- * Every entry in ROUTES runs through the real dispatcher and auth gate with a
- * stub RouteContext and stub handlers, on every surface it declares, with no
- * token, a wrong token, the root token, a scoped token, the SSE cookie and the
- * pinned extension Origin. Denials assert the exact status and body each auth
- * kind returned at 96764e8; admitted credentials assert the handler ran.
- *
- * Real-handler coverage for the same routes lives in
- * server-route-auth-blackbox.test.ts (every route, both surfaces, through
- * buildFetchHandler), plus the route-specific suites (extension-token,
- * pair-agent-e2e, server-pty-lease-routes, pty-inject-scan, dual-listener).
- */
-
-import { describe, test, expect } from 'bun:test';
-import * as crypto from 'crypto';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { ROUTES } from '../src/routes';
-import {
-  dispatchRoute, findRoute, UNMATCHED_ROUTE,
-  type AuthKind, type RouteContext, type RouteEntry, type Surface,
-} from '../src/routes/table';
-import { buildFetchHandler, __testInternals__ } from '../src/server';
-import { __resetRegistry } from '../src/token-registry';
-import { BrowserManager } from '../src/browser-manager';
-import { resolveConfig } from '../src/config';
-import { usePrivateStateRoot } from '../../test/helpers/private-state-root';
-
-usePrivateStateRoot();
-
-type Cred = 'none' | 'wrong' | 'root' | 'scoped' | 'sse-cookie' | 'extension-origin';
-const CREDS: Cred[] = ['none', 'wrong', 'root', 'scoped', 'sse-cookie', 'extension-origin'];
-
-const ROOT = 'stub-root-token-0123456789';
-const SCOPED = 'stub-scoped-token-0123456789';
-const COOKIE = 'stub-sse-cookie';
-
-function credHeaders(cred: Cred): Record<string, string> {
-  switch (cred) {
-    case 'none': return {};
-    case 'wrong': return { Authorization: 'Bearer stub-wrong-token-0123456789' };
-    case 'root': return { Authorization: `Bearer ${ROOT}` };
-    case 'scoped': return { Authorization: `Bearer ${SCOPED}` };
-    case 'sse-cookie': return { Cookie: `gstack_sse=${COOKIE}` };
-    case 'extension-origin': return { Origin: 'pinned-extension', Host: '127.0.0.1:34567' };
-  }
-}
-
-const ROOT_INFO = { clientId: 'root', scopes: ['admin'] } as any;
-const SCOPED_INFO = { clientId: 'stub-agent', scopes: ['read'] } as any;
-
-function stubContext(): RouteContext {
-  const bearer = (req: Request) => req.headers.get('authorization');
-  const unused = () => { throw new Error('stub handlers never reach the context'); };
-  return {
-    browserManager: {} as any,
-    startTime: 0,
-    browsePort: 34567,
-    validateAuth: (req) => bearer(req) === `Bearer ${ROOT}`,
-    isRootRequest: (req) => bearer(req) === `Bearer ${ROOT}`,
-    getTokenInfo: (req) => bearer(req) === `Bearer ${ROOT}` ? ROOT_INFO : bearer(req) === `Bearer ${SCOPED}` ? SCOPED_INFO : null,
-    hasSseCookie: (req) => req.headers.get('cookie') === `gstack_sse=${COOKIE}`,
-    isPinnedExtensionRequest: (req) => req.headers.get('origin') === 'pinned-extension',
-    isRootTokenValue: (token) => token === ROOT,
-    bootstrapRootToken: ROOT,
-    resetIdleTimer: unused,
-    terminal: { readPort: unused, grantToken: unused, restartSession: unused },
-    tunnel: { state: unused, close: unused, resolveAuthtoken: unused, start: unused },
-    commands: { handle: unused, handleInternal: unused },
-  };
-}
-
-const REACHED = 'stub-handler-reached';
-function stubbed(routes: readonly RouteEntry[]): RouteEntry[] {
-  return routes.map(r => ({
-    ...r,
-    handler: (_req, { tokenInfo }) => new Response(JSON.stringify({ reached: REACHED, tokenInfo }), { status: 299 }),
-  }));
-}
-
-/** Denials exactly as the if-chain server returned them for each gate-level check at 96764e8. */
-const EXPECTED_DENIAL: Record<Exclude<AuthKind, 'none' | 'handler'>, { status: number; body: string }> = {
-  'root-bearer': { status: 401, body: '{"error":"Unauthorized"}' },
-  'scoped': { status: 401, body: '{"error":"Unauthorized"}' },
-  'root-or-sse-cookie': { status: 401, body: '{"error":"Unauthorized"}' },
-  'root-token': { status: 403, body: '{"error":"Root token required"}' },
-  'extension-origin': { status: 403, body: '{"error":"Forbidden"}' },
-};
-
-const ADMITTED: Record<AuthKind, Cred[]> = {
-  'none': CREDS,
-  'handler': CREDS,
-  'root-bearer': ['root'],
-  'root-token': ['root'],
-  'scoped': ['root', 'scoped'],
-  'root-or-sse-cookie': ['root', 'sse-cookie'],
-  'extension-origin': ['extension-origin'],
-};
-
-/** Every route the daemon serves, with the auth kind and surfaces a security review signed off on. */
-const EXPECTED_ROUTES: Array<[method: string, path: string, auth: AuthKind, surfaces: Surface[]]> = [
-  ['GET', '/connect', 'none', ['local', 'tunnel']],
-  ['POST', '/connect', 'none', ['local', 'tunnel']],
-  ['*', '/cookie-picker*', 'handler', ['local']],
-  ['*', '/welcome', 'none', ['local']],
-  ['POST', '/extension-token', 'extension-origin', ['local']],
-  ['*', '/health', 'none', ['local']],
-  ['POST', '/pty-session', 'root-bearer', ['local']],
-  ['POST', '/pty-session/reattach', 'root-bearer', ['local']],
-  ['POST', '/pty-restart', 'root-bearer', ['local']],
-  ['POST', '/pty-dispose', 'handler', ['local']],
-  ['POST', '/internal/lease-refresh', 'root-bearer', ['local']],
-  ['POST', '/pty-inject-scan', 'root-bearer', ['local']],
-  ['POST', '/token', 'handler', ['local']],
-  ['DELETE', '/token/*', 'root-token', ['local']],
-  ['GET', '/agents', 'root-token', ['local']],
-  ['POST', '/pair', 'root-token', ['local']],
-  ['POST', '/tunnel/start', 'root-token', ['local']],
-  ['POST', '/sse-session', 'root-bearer', ['local']],
-  ['*', '/refs', 'root-bearer', ['local']],
-  ['*', '/activity/stream', 'root-or-sse-cookie', ['local']],
-  ['*', '/activity/history', 'root-bearer', ['local']],
-  ['POST', '/batch', 'scoped', ['local']],
-  ['GET', '/file', 'scoped', ['local']],
-  ['POST', '/command', 'scoped', ['local', 'tunnel']],
-  ['POST', '/inspector/pick', 'root-bearer', ['local']],
-  ['GET', '/inspector', 'root-bearer', ['local']],
-  ['POST', '/inspector/apply', 'root-bearer', ['local']],
-  ['POST', '/inspector/reset', 'root-bearer', ['local']],
-  ['GET', '/inspector/history', 'root-bearer', ['local']],
-  ['GET', '/memory', 'root-bearer', ['local']],
-  ['GET', '/inspector/events', 'root-bearer', ['local']],
-];
-
-const routeKey = (r: RouteEntry) => `${r.method} ${r.path}${r.prefix ? '*' : ''}`;
-const requestPath = (r: RouteEntry) => r.prefix ? `${r.path}${r.path.endsWith('/') ? 'probe' : '/probe'}` : r.path;
-const requestMethod = (r: RouteEntry) => r.method === '*' ? 'GET' : r.method;
-
-describe('route table declarations', () => {
-  test('the table is exactly the reviewed route inventory, auth kinds and surfaces', () => {
-    const describe = (method: string, p: string, auth: AuthKind, surfaces: readonly Surface[]) =>
-      `${method} ${p} auth=${auth} surfaces=${surfaces.join(',')}`;
-    const actual = ROUTES.map(r => describe(r.method, `${r.path}${r.prefix ? '*' : ''}`, r.auth, r.surfaces)).sort();
-    const expected = EXPECTED_ROUTES.map(([m, p, a, s]) => describe(m, p, a, s)).sort();
-    expect(actual).toEqual(expected);
-  });
-
-  test('every route declares an auth kind and at least one surface; only handler-auth routes carry handlerAuth', () => {
-    const kinds = new Set<AuthKind>(['none', 'root-bearer', 'root-token', 'scoped', 'extension-origin', 'root-or-sse-cookie', 'handler']);
-    for (const r of ROUTES) {
-      expect(kinds.has(r.auth), routeKey(r)).toBe(true);
-      expect(r.surfaces.length, routeKey(r)).toBeGreaterThan(0);
-      expect(typeof r.handler, routeKey(r)).toBe('function');
-      if (r.auth === 'handler') expect(r.handlerAuth?.length ?? 0, routeKey(r)).toBeGreaterThan(20);
-      else expect(r.handlerAuth, routeKey(r)).toBeUndefined();
-    }
-  });
-
-  test('no two entries claim the same method and path', () => {
-    const keys = ROUTES.map(routeKey);
-    expect(new Set(keys).size).toBe(keys.length);
-  });
-
-  test('the tunnel-surface paths in the table equal the TUNNEL_PATHS literal', () => {
-    const tableTunnelPaths = new Set(ROUTES.filter(r => r.surfaces.includes('tunnel')).map(r => r.path));
-    expect([...tableTunnelPaths].sort()).toEqual([...__testInternals__.tunnelPaths].sort());
-    expect(findRoute(ROUTES, 'GET', '/connect', 'tunnel')?.auth).toBe('none');
-  });
-});
-
-describe('route table auth matrix (stubbed handlers)', () => {
-  const ctx = stubContext();
-  const routes = stubbed(ROUTES);
-  for (const route of routes) {
-    for (const surface of route.surfaces) {
-      for (const cred of CREDS) {
-        test(`${surface} ${routeKey(route)} with ${cred}`, async () => {
-          const url = new URL(`http://127.0.0.1:34567${requestPath(route)}`);
-          const req = new Request(url, { method: requestMethod(route), headers: credHeaders(cred) });
-          const resp = await dispatchRoute(routes, req, url, surface, ctx);
-          const body = await resp.text();
-          if (ADMITTED[route.auth].includes(cred)) {
-            expect(resp.status).toBe(299);
-            const parsed = JSON.parse(body);
-            expect(parsed.reached).toBe(REACHED);
-            if (route.auth === 'scoped') expect(parsed.tokenInfo).toEqual(cred === 'root' ? ROOT_INFO : SCOPED_INFO);
-            return;
-          }
-          const denial = EXPECTED_DENIAL[route.auth as keyof typeof EXPECTED_DENIAL];
-          expect({ status: resp.status, body }).toEqual(denial);
-          expect(resp.headers.get('content-type')).toBe('application/json');
-        });
-      }
-    }
-  }
-
-  test('a local-only entry is not matched on the tunnel surface', () => {
-    for (const r of ROUTES.filter(r => !r.surfaces.includes('tunnel'))) {
-      expect(findRoute(ROUTES, requestMethod(r), requestPath(r), 'tunnel'), routeKey(r)).toBeNull();
-    }
-  });
-
-  for (const [method, pathname] of [['GET', '/no-such-route'], ['GET', '/command'], ['PUT', '/token'], ['GET', '/token/x']]) {
-    test(`unmatched ${method} ${pathname}: root-bearer check, then plain-text 404`, async () => {
-      expect(UNMATCHED_ROUTE.auth).toBe('root-bearer');
-      const url = new URL(`http://127.0.0.1:34567${pathname}`);
-      for (const cred of CREDS) {
-        const resp = await dispatchRoute(routes, new Request(url, { method, headers: credHeaders(cred) }), url, 'local', ctx);
-        const body = await resp.text();
-        if (cred === 'root') expect({ status: resp.status, body }).toEqual({ status: 404, body: 'Not found' });
-        else expect({ status: resp.status, body }).toEqual(EXPECTED_DENIAL['root-bearer']);
-      }
-    });
-  }
-});
-
-describe('tunnel surface rejects the root token on every tunnel route', () => {
-  const fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-route-table-'));
-  const config = resolveConfig({ BROWSE_STATE_FILE: path.join(fixtureDir, 'state/browse.json') });
-  for (const route of ROUTES.filter(r => r.surfaces.includes('tunnel'))) {
-    test(`${routeKey(route)}`, async () => {
-      __resetRegistry();
-      const authToken = 'route-table-' + crypto.randomBytes(16).toString('hex');
-      const handle = buildFetchHandler({
-        authToken, browsePort: 34567, config, browserManager: new BrowserManager(),
-        ownsTerminalAgent: false, startTime: Date.now(),
-      });
-      const resp = await handle.fetchTunnel(new Request(`http://127.0.0.1:34567${route.path}`, {
-        method: route.method, headers: { Authorization: `Bearer ${authToken}` },
-      }), null);
-      expect(resp.status).toBe(403);
-      expect((await resp.json() as { error: string }).error).toBe('Root token rejected on tunnel surface');
-    });
-  }
-});