@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/gstack-browse/test/batch.test.ts

@@ -1,267 +0,0 @@
-/**
- * Integration tests for POST /batch endpoint
- *
- * Tests parallel multi-tab execution, error isolation, SSE streaming,
- * newtab/closetab handling, and batch validation.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { startTestServer } from './test-server';
-import { BrowserManager } from '../src/browser-manager';
-
-let testServer: ReturnType<typeof startTestServer>;
-let bm: BrowserManager;
-let baseUrl: string;
-let serverPort: number;
-
-// Helper to send batch requests to the browse server
-async function batch(commands: any[], opts: { timeout?: number; stream?: boolean } = {}): Promise<any> {
-  const res = await fetch(`http://127.0.0.1:${serverPort}/batch`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ commands, ...opts }),
-  });
-  if (opts.stream) {
-    return res; // return raw response for SSE testing
-  }
-  return res.json();
-}
-
-beforeAll(async () => {
-  testServer = startTestServer(0);
-  baseUrl = testServer.url;
-
-  bm = new BrowserManager();
-  await bm.launch();
-  serverPort = bm.serverPort;
-
-  // Start the browse server
-  const { startServer } = await import('../src/server');
-  // The server is already started by launch — we need the port
-  // Actually, BrowserManager.launch() starts the browser, not the server.
-  // The test needs to start a server. Let's use the existing server infrastructure.
-});
-
-afterAll(async () => {
-  try { testServer.server.stop(true); } catch {}  // force-close keep-alives — a lingering Chromium connection otherwise blocks stop() forever
-  // Close only this file's own browser — never process.exit(): bun test runs
-  // all files in one process, so a delayed exit kills the whole suite
-  // (see test/no-suicide-exit.test.ts). close() can hang when the browser
-  // already died, and its internal 5s timeout ties bun's 5s hook timeout —
-  // so race it at 3s and abandon; the child is reaped at process exit.
-  try { await Promise.race([bm?.close(), new Promise((resolve) => setTimeout(resolve, 3000))]); } catch {}
-});
-
-// We need a running browse server for HTTP tests.
-// The commands.test.ts tests call handlers directly, but batch tests need the HTTP endpoint.
-// Let's test the batch logic by importing the handlers directly instead.
-
-import { handleReadCommand as _handleReadCommand } from '../src/read-commands';
-import { handleWriteCommand as _handleWriteCommand } from '../src/write-commands';
-import { handleMetaCommand } from '../src/meta-commands';
-import { handleSnapshot } from '../src/snapshot';
-import { READ_COMMANDS, WRITE_COMMANDS } from '../src/commands';
-
-// Per-FILE Chromium profile: this file launches an in-process persistent
-// context (BrowserManager.launch()), and sharing a profile dir with the
-// long-lived browse daemon a sibling file may have spawned kills one side's
-// Chromium (ProcessSingleton on user-data-dir). Scoped via hooks, never
-// module scope (see test/gstack-home-module-scope.test.ts's rationale).
-const ORIGINAL_CHROMIUM_PROFILE = process.env.CHROMIUM_PROFILE;
-let CHROMIUM_PROFILE_DIR: string | undefined;
-beforeAll(() => {
-  CHROMIUM_PROFILE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-test-profile-'));
-  process.env.CHROMIUM_PROFILE = CHROMIUM_PROFILE_DIR;
-});
-afterAll(() => {
-  if (ORIGINAL_CHROMIUM_PROFILE === undefined) delete process.env.CHROMIUM_PROFILE;
-  else process.env.CHROMIUM_PROFILE = ORIGINAL_CHROMIUM_PROFILE;
-  if (CHROMIUM_PROFILE_DIR) { try { fs.rmSync(CHROMIUM_PROFILE_DIR, { recursive: true, force: true }); } catch {} }
-});
-
-
-const handleReadCommand = (cmd: string, args: string[], b: BrowserManager) =>
-  _handleReadCommand(cmd, args, b.getActiveSession());
-const handleWriteCommand = (cmd: string, args: string[], b: BrowserManager) =>
-  _handleWriteCommand(cmd, args, b.getActiveSession(), b);
-
-describe('Batch execution', () => {
-  test('multi-tab parallel: goto + text on different tabs', async () => {
-    // Create two tabs
-    const tab1 = await bm.newTab(baseUrl + '/basic.html');
-    const tab2 = await bm.newTab(baseUrl + '/forms.html');
-
-    // Execute text command on both tabs in parallel using TabSession
-    const session1 = bm.getSession(tab1);
-    const session2 = bm.getSession(tab2);
-
-    const [result1, result2] = await Promise.allSettled([
-      _handleReadCommand('text', [], session1),
-      _handleReadCommand('text', [], session2),
-    ]);
-
-    expect(result1.status).toBe('fulfilled');
-    expect(result2.status).toBe('fulfilled');
-
-    if (result1.status === 'fulfilled') {
-      expect(result1.value).toContain('Hello');
-    }
-    if (result2.status === 'fulfilled') {
-      // forms.html has form elements
-      expect(result2.value.length).toBeGreaterThan(0);
-    }
-
-    // Cleanup
-    await bm.closeTab(tab2);
-    await bm.closeTab(tab1);
-  });
-
-  test('same-tab sequential: commands execute in order', async () => {
-    const tabId = await bm.newTab();
-    const session = bm.getSession(tabId);
-
-    // Navigate then read — must be sequential
-    await _handleWriteCommand('goto', [baseUrl + '/basic.html'], session, bm);
-    const text = await _handleReadCommand('text', [], session);
-
-    expect(text).toContain('Hello');
-
-    await bm.closeTab(tabId);
-  });
-
-  test('per-command error isolation: one tab fails, others succeed', async () => {
-    const tab1 = await bm.newTab(baseUrl + '/basic.html');
-    const tab2 = await bm.newTab(baseUrl + '/basic.html');
-
-    const session1 = bm.getSession(tab1);
-    const session2 = bm.getSession(tab2);
-
-    // Use Promise.allSettled — one succeeds (text read), one fails (invalid ref)
-    const results = await Promise.allSettled([
-      _handleReadCommand('text', [], session1),
-      session2.resolveRef('@e999'), // nonexistent ref — fails immediately
-    ]);
-
-    expect(results[0].status).toBe('fulfilled');
-    expect(results[1].status).toBe('rejected');
-
-    await bm.closeTab(tab2);
-    await bm.closeTab(tab1);
-  });
-
-  test('page-scoped refs: snapshot refs are per-session', async () => {
-    const tab1 = await bm.newTab(baseUrl + '/basic.html');
-    const tab2 = await bm.newTab(baseUrl + '/forms.html');
-
-    const session1 = bm.getSession(tab1);
-    const session2 = bm.getSession(tab2);
-
-    // Snapshot on tab1 creates refs in session1
-    await handleSnapshot(['-i'], session1);
-    const refCount1 = session1.getRefCount();
-
-    // Snapshot on tab2 creates refs in session2
-    await handleSnapshot(['-i'], session2);
-    const refCount2 = session2.getRefCount();
-
-    // Refs should be independent
-    expect(refCount1).toBeGreaterThanOrEqual(0);
-    expect(refCount2).toBeGreaterThanOrEqual(0);
-
-    // Session1's refs should not have changed after session2's snapshot
-    expect(session1.getRefCount()).toBe(refCount1);
-
-    await bm.closeTab(tab2);
-    await bm.closeTab(tab1);
-  });
-
-  test('per-tab lastSnapshot: snapshot -D works per-tab', async () => {
-    const tab1 = await bm.newTab(baseUrl + '/basic.html');
-    const session1 = bm.getSession(tab1);
-
-    // First snapshot sets the baseline
-    const snap1 = await handleSnapshot([], session1);
-    expect(session1.getLastSnapshot()).not.toBeNull();
-
-    // Second snapshot with -D should diff against the first
-    const snap2 = await handleSnapshot(['-D'], session1);
-    // Since page didn't change, diff should indicate identical
-    // (either "no changes" or empty diff with just headers)
-    expect(snap2.length).toBeGreaterThan(0);
-
-    await bm.closeTab(tab1);
-  });
-
-  test('getSession throws for nonexistent tab', () => {
-    expect(() => bm.getSession(99999)).toThrow('Tab 99999 not found');
-  });
-
-  test('getActiveSession returns the current active tab session', async () => {
-    const tabId = await bm.newTab(baseUrl + '/basic.html');
-    const session = bm.getActiveSession();
-    expect(session.getPage().url()).toContain('basic.html');
-    await bm.closeTab(tabId);
-  });
-
-  test('batch-safe command subset validation', () => {
-    const BATCH_SAFE = new Set([
-      'text', 'html', 'links', 'snapshot', 'accessibility', 'cookies', 'url',
-      'goto', 'click', 'fill', 'select', 'hover', 'scroll', 'wait',
-      'screenshot', 'pdf',
-      'newtab', 'closetab',
-    ]);
-
-    // All batch-safe commands should be in the main command sets (except newtab/closetab which are meta)
-    for (const cmd of BATCH_SAFE) {
-      if (cmd === 'newtab' || cmd === 'closetab' || cmd === 'snapshot' || cmd === 'screenshot' || cmd === 'pdf' || cmd === 'url') {
-        continue; // These are META_COMMANDS, handled separately
-      }
-      const isKnown = READ_COMMANDS.has(cmd) || WRITE_COMMANDS.has(cmd);
-      expect(isKnown).toBe(true);
-    }
-  });
-
-  test('closeTab via page.close preserves at-least-one-page invariant', async () => {
-    // Create a tab, close it via page.close() (simulating batch closetab)
-    const tabId = await bm.newTab(baseUrl + '/basic.html');
-    const session = bm.getSession(tabId);
-
-    // Close via page.close() directly (how batch does it)
-    await session.getPage().close();
-
-    // The page.on('close') handler should have cleaned up
-    // And the browser should still have at least one tab
-    expect(bm.getTabCount()).toBeGreaterThanOrEqual(1);
-  });
-
-  test('parallel goto on multiple tabs', async () => {
-    const tab1 = await bm.newTab();
-    const tab2 = await bm.newTab();
-    const tab3 = await bm.newTab();
-
-    const session1 = bm.getSession(tab1);
-    const session2 = bm.getSession(tab2);
-    const session3 = bm.getSession(tab3);
-
-    // Navigate all three tabs in parallel
-    const results = await Promise.allSettled([
-      _handleWriteCommand('goto', [baseUrl + '/basic.html'], session1, bm),
-      _handleWriteCommand('goto', [baseUrl + '/forms.html'], session2, bm),
-      _handleWriteCommand('goto', [baseUrl + '/basic.html'], session3, bm),
-    ]);
-
-    expect(results.every(r => r.status === 'fulfilled')).toBe(true);
-
-    // Verify each tab landed on the right page
-    expect(session1.getPage().url()).toContain('basic.html');
-    expect(session2.getPage().url()).toContain('forms.html');
-    expect(session3.getPage().url()).toContain('basic.html');
-
-    await bm.closeTab(tab3);
-    await bm.closeTab(tab2);
-    await bm.closeTab(tab1);
-  });
-});

package/.agent/skills/gstack-browse/test/bridge-chromium-e2e.test.ts

@@ -1,205 +0,0 @@
-/**
- * codex F3 critical test: real Chromium navigates through the SOCKS5 bridge.
- *
- * The other bridge tests prove TCP relay works at the byte level. This test
- * proves the FEATURE works: a Chromium browser launched with
- * proxy.server = 'socks5://127.0.0.1:<bridgePort>' actually traverses the
- * bridge → authenticated upstream → destination chain. Without this test,
- * we could ship a working transport layer and a broken integration with
- * Chromium and not know it.
- */
-
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import { chromium, type Browser } from 'playwright';
-import * as net from 'net';
-import * as http from 'http';
-import { startSocksBridge, type BridgeHandle } from '../src/socks-bridge';
-
-interface MockUpstream {
-  port: number;
-  close: () => Promise<void>;
-  totalConnects: () => number;
-}
-
-/**
- * Minimal SOCKS5 upstream with username/password auth. Tracks how many
- * CONNECT requests succeeded — non-zero proves the browser's request
- * actually traversed the chain.
- */
-async function startAuthUpstream(user: string, pass: string): Promise<MockUpstream> {
-  let connects = 0;
-  const server = net.createServer((sock) => {
-    sock.once('data', (greeting) => {
-      if (greeting[0] !== 0x05) { sock.destroy(); return; }
-      const methods = greeting.subarray(2, 2 + greeting[1]);
-      if (!methods.includes(0x02)) { sock.write(Buffer.from([0x05, 0xFF])); sock.destroy(); return; }
-      sock.write(Buffer.from([0x05, 0x02]));
-      sock.once('data', (auth) => {
-        const ulen = auth[1];
-        const uname = auth.subarray(2, 2 + ulen).toString();
-        const plen = auth[2 + ulen];
-        const passwd = auth.subarray(3 + ulen, 3 + ulen + plen).toString();
-        if (uname !== user || passwd !== pass) {
-          sock.write(Buffer.from([0x01, 0x01])); sock.destroy(); return;
-        }
-        sock.write(Buffer.from([0x01, 0x00]));
-        sock.once('data', (req) => {
-          const atyp = req[3];
-          let host: string; let port: number;
-          if (atyp === 0x01) {
-            host = `${req[4]}.${req[5]}.${req[6]}.${req[7]}`;
-            port = req.readUInt16BE(8);
-          } else if (atyp === 0x03) {
-            const len = req[4];
-            host = req.subarray(5, 5 + len).toString();
-            port = req.readUInt16BE(5 + len);
-          } else {
-            sock.write(Buffer.from([0x05, 0x08, 0x00, 0x01, 0, 0, 0, 0, 0, 0]));
-            sock.destroy(); return;
-          }
-          const dest = net.createConnection({ host, port }, () => {
-            connects++;
-            sock.write(Buffer.from([0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0]));
-            sock.pipe(dest);
-            dest.pipe(sock);
-            sock.on('error', () => dest.destroy());
-            dest.on('error', () => sock.destroy());
-            sock.on('close', () => dest.destroy());
-            dest.on('close', () => sock.destroy());
-          });
-          dest.on('error', () => {
-            try { sock.write(Buffer.from([0x05, 0x04, 0x00, 0x01, 0, 0, 0, 0, 0, 0])); } catch {}
-            sock.destroy();
-          });
-        });
-      });
-    });
-    sock.on('error', () => sock.destroy());
-  });
-  await new Promise<void>((resolve, reject) => {
-    server.once('error', reject);
-    server.once('listening', () => resolve());
-    server.listen(0, '127.0.0.1');
-  });
-  const addr = server.address();
-  if (!addr || typeof addr === 'string') throw new Error('mock upstream: bad address');
-  return {
-    port: addr.port,
-    totalConnects: () => connects,
-    close: () => new Promise((r) => server.close(() => r())),
-  };
-}
-
-/** Tiny HTTP server to serve as the navigation target. */
-async function startHttpFixture(body: string): Promise<{ port: number; close: () => Promise<void>; hits: () => number }> {
-  let hits = 0;
-  const server = http.createServer((_req, res) => {
-    hits++;
-    res.writeHead(200, { 'Content-Type': 'text/html' });
-    res.end(body);
-  });
-  await new Promise<void>((resolve, reject) => {
-    server.once('error', reject);
-    server.listen(0, '127.0.0.1', () => resolve());
-  });
-  const addr = server.address();
-  if (!addr || typeof addr === 'string') throw new Error('http fixture: bad address');
-  return {
-    port: addr.port,
-    hits: () => hits,
-    close: () => new Promise((r) => server.close(() => r())),
-  };
-}
-
-describe('bridge-chromium-e2e (codex F3)', () => {
-  let upstream: MockUpstream;
-  let bridge: BridgeHandle;
-  let httpFixture: { port: number; close: () => Promise<void>; hits: () => number };
-  let browser: Browser;
-
-  beforeAll(async () => {
-    upstream = await startAuthUpstream('alice', 'wonderland');
-    bridge = await startSocksBridge({
-      upstream: { host: '127.0.0.1', port: upstream.port, userId: 'alice', password: 'wonderland' },
-    });
-    httpFixture = await startHttpFixture('<html><body><h1 id="ok">via-bridge</h1></body></html>');
-    browser = await chromium.launch({
-      headless: true,
-      proxy: { server: `socks5://127.0.0.1:${bridge.port}` },
-    });
-  });
-
-  afterAll(async () => {
-    await browser.close();
-    await httpFixture.close();
-    await bridge.close();
-    await upstream.close();
-  });
-
-  test('Chromium navigates through bridge → auth upstream → HTTP fixture', async () => {
-    const page = await browser.newPage();
-    try {
-      const before = upstream.totalConnects();
-      const fixtureHitsBefore = httpFixture.hits();
-
-      // Use 127.0.0.1 explicitly so we hit our local HTTP server (not via DNS).
-      const target = `http://127.0.0.1:${httpFixture.port}/`;
-      const response = await page.goto(target);
-      expect(response?.ok()).toBe(true);
-
-      const text = await page.locator('#ok').textContent();
-      expect(text).toBe('via-bridge');
-
-      // Proof of traversal: the upstream's connect counter incremented AND
-      // the HTTP fixture got a hit.
-      expect(upstream.totalConnects()).toBeGreaterThan(before);
-      expect(httpFixture.hits()).toBeGreaterThan(fixtureHitsBefore);
-    } finally {
-      await page.close();
-    }
-  });
-
-  test('subsequent navigation also traverses the bridge', async () => {
-    const page = await browser.newPage();
-    try {
-      const before = upstream.totalConnects();
-      const target = `http://127.0.0.1:${httpFixture.port}/page2`;
-      await page.goto(target);
-      expect(upstream.totalConnects()).toBeGreaterThan(before);
-    } finally {
-      await page.close();
-    }
-  });
-});
-
-describe('bridge-port-restart (codex F1, reframed)', () => {
-  test('two sequential bridge instances pick different ephemeral ports', async () => {
-    // codex F1: the original bridge-port-isolation test assumed two browse
-    // daemons coexist, which contradicts our single-daemon refuse-on-mismatch
-    // model (D2). The valid restart test is: spin up bridge A, close it,
-    // spin up bridge B, assert B picks a fresh ephemeral port (and that a
-    // hardcoded port like 1090 never appears in either).
-    const upstream = await startAuthUpstream('u', 'p');
-    try {
-      const a = await startSocksBridge({
-        upstream: { host: '127.0.0.1', port: upstream.port, userId: 'u', password: 'p' },
-      });
-      expect(a.port).not.toBe(1090);
-      const portA = a.port;
-      await a.close();
-
-      const b = await startSocksBridge({
-        upstream: { host: '127.0.0.1', port: upstream.port, userId: 'u', password: 'p' },
-      });
-      expect(b.port).not.toBe(1090);
-      // The same port can be reused safely because the listener is closed.
-      // But more importantly, both ports are valid ephemeral ports and the
-      // bridge chose them via listen(0), not a hardcoded constant.
-      expect(b.port).toBeGreaterThan(0);
-      expect(typeof portA).toBe('number');
-      await b.close();
-    } finally {
-      await upstream.close();
-    }
-  });
-});