@geometra/mcp 1.19.17 → 1.19.18

package/dist/__tests__/proxy-session-recovery.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/proxy-session-recovery.test.js

@@ -0,0 +1,118 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { WebSocketServer } from 'ws';
+const mockState = vi.hoisted(() => ({
+    startEmbeddedGeometraProxy: vi.fn(),
+    spawnGeometraProxy: vi.fn(),
+}));
+vi.mock('../proxy-spawn.js', () => ({
+    startEmbeddedGeometraProxy: mockState.startEmbeddedGeometraProxy,
+    spawnGeometraProxy: mockState.spawnGeometraProxy,
+}));
+const { connectThroughProxy, disconnect } = await import('../session.js');
+function frame(pageUrl) {
+    return {
+        type: 'frame',
+        layout: { x: 0, y: 0, width: 1280, height: 720, children: [] },
+        tree: {
+            kind: 'box',
+            props: {},
+            semantic: {
+                tag: 'body',
+                role: 'group',
+                pageUrl,
+            },
+            children: [],
+        },
+    };
+}
+async function createProxyPeer(options) {
+    const wss = new WebSocketServer({ port: 0 });
+    wss.on('connection', ws => {
+        ws.send(JSON.stringify(frame(options?.pageUrl ?? 'https://jobs.example.com/original')));
+        ws.on('message', raw => {
+            const msg = JSON.parse(String(raw));
+            if (msg.type === 'navigate') {
+                options?.onNavigate?.(ws, msg);
+            }
+        });
+    });
+    const port = await new Promise((resolve, reject) => {
+        wss.once('listening', () => {
+            const address = wss.address();
+            if (typeof address === 'object' && address)
+                resolve(address.port);
+            else
+                reject(new Error('Failed to resolve ephemeral WebSocket port'));
+        });
+        wss.once('error', reject);
+    });
+    return {
+        wss,
+        wsUrl: `ws://127.0.0.1:${port}`,
+    };
+}
+afterEach(async () => {
+    disconnect({ closeProxy: true });
+    vi.clearAllMocks();
+});
+async function closePeer(wss) {
+    for (const client of wss.clients) {
+        client.close();
+    }
+    await new Promise((resolve, reject) => wss.close(err => (err ? reject(err) : resolve())));
+}
+describe('connectThroughProxy recovery', () => {
+    it('restarts from a fresh proxy when a reused browser session was already closed', async () => {
+        const stalePeer = await createProxyPeer({
+            pageUrl: 'https://jobs.example.com/original',
+            onNavigate(ws, msg) {
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    requestId: msg.requestId,
+                    message: 'page.goto: Target page, context or browser has been closed',
+                }));
+            },
+        });
+        const freshPeer = await createProxyPeer({
+            pageUrl: 'https://jobs.example.com/recovered',
+        });
+        const staleRuntime = {
+            wsUrl: stalePeer.wsUrl,
+            closed: false,
+            close: vi.fn(async () => {
+                staleRuntime.closed = true;
+            }),
+        };
+        const freshRuntime = {
+            wsUrl: freshPeer.wsUrl,
+            closed: false,
+            close: vi.fn(async () => {
+                freshRuntime.closed = true;
+            }),
+        };
+        mockState.startEmbeddedGeometraProxy
+            .mockResolvedValueOnce({ runtime: staleRuntime, wsUrl: stalePeer.wsUrl })
+            .mockResolvedValueOnce({ runtime: freshRuntime, wsUrl: freshPeer.wsUrl });
+        mockState.spawnGeometraProxy.mockRejectedValue(new Error('spawn fallback should not be used'));
+        try {
+            const firstSession = await connectThroughProxy({
+                pageUrl: 'https://jobs.example.com/original',
+                headless: true,
+            });
+            expect(firstSession.proxyRuntime).toBe(staleRuntime);
+            const recoveredSession = await connectThroughProxy({
+                pageUrl: 'https://jobs.example.com/recovered',
+                headless: true,
+            });
+            expect(recoveredSession.proxyRuntime).toBe(freshRuntime);
+            expect(mockState.startEmbeddedGeometraProxy).toHaveBeenCalledTimes(2);
+            expect(staleRuntime.close).toHaveBeenCalledTimes(1);
+            expect(mockState.spawnGeometraProxy).not.toHaveBeenCalled();
+        }
+        finally {
+            disconnect({ closeProxy: true });
+            await closePeer(stalePeer.wss);
+            await closePeer(freshPeer.wss);
+        }
+    });
+});

package/dist/session.js

@@ -128,6 +128,112 @@ function shutdownPreviousSession(opts) {
         void prev.proxyRuntime.close().catch(() => { });
     }
 }
+function formatUnknownError(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+async function attachToReusableProxy(options) {
+    if (!reusableProxy) {
+        throw new Error('Failed to attach to reusable proxy session');
+    }
+    const session = ((reusableProxy.child && activeSession?.proxyChild === reusableProxy.child) ||
+        (reusableProxy.runtime && activeSession?.proxyRuntime === reusableProxy.runtime))
+        ? activeSession
+        : await connect(reusableProxy.wsUrl, {
+            skipInitialResize: true,
+            closePreviousProxy: false,
+            awaitInitialFrame: options.awaitInitialFrame,
+        });
+    if (!session) {
+        throw new Error('Failed to attach to reusable proxy session');
+    }
+    session.proxyChild = reusableProxy.child;
+    session.proxyRuntime = reusableProxy.runtime;
+    session.proxyReusable = true;
+    const desiredWidth = options.width ?? reusableProxy.width;
+    const desiredHeight = options.height ?? reusableProxy.height;
+    if (desiredWidth !== reusableProxy.width || desiredHeight !== reusableProxy.height) {
+        await sendAndWaitForUpdate(session, {
+            type: 'resize',
+            width: desiredWidth,
+            height: desiredHeight,
+        }, 5_000);
+        reusableProxy.width = desiredWidth;
+        reusableProxy.height = desiredHeight;
+    }
+    const currentUrl = session.cachedA11y?.meta?.pageUrl ?? reusableProxy.pageUrl;
+    if (currentUrl !== options.pageUrl) {
+        await sendNavigate(session, options.pageUrl, 15_000);
+        if ((session.proxyChild && reusableProxy?.child === session.proxyChild) ||
+            (session.proxyRuntime && reusableProxy?.runtime === session.proxyRuntime)) {
+            reusableProxy.pageUrl = options.pageUrl;
+        }
+    }
+    return session;
+}
+async function startFreshProxySession(options) {
+    closeReusableProxy();
+    try {
+        const { runtime, wsUrl } = await startEmbeddedGeometraProxy({
+            pageUrl: options.pageUrl,
+            port: options.port ?? 0,
+            headless: options.headless,
+            width: options.width,
+            height: options.height,
+            slowMo: options.slowMo,
+        });
+        const session = await connect(wsUrl, {
+            skipInitialResize: true,
+            closePreviousProxy: false,
+            awaitInitialFrame: options.awaitInitialFrame,
+        });
+        session.proxyRuntime = runtime;
+        session.proxyReusable = true;
+        setReusableProxy({ runtime }, wsUrl, {
+            headless: options.headless,
+            slowMo: options.slowMo,
+            width: options.width,
+            height: options.height,
+            pageUrl: options.pageUrl,
+        });
+        return session;
+    }
+    catch (e) {
+        const { child, wsUrl } = await spawnGeometraProxy({
+            pageUrl: options.pageUrl,
+            port: options.port ?? 0,
+            headless: options.headless,
+            width: options.width,
+            height: options.height,
+            slowMo: options.slowMo,
+        });
+        try {
+            const session = await connect(wsUrl, {
+                skipInitialResize: true,
+                closePreviousProxy: false,
+                awaitInitialFrame: options.awaitInitialFrame,
+            });
+            session.proxyChild = child;
+            session.proxyReusable = true;
+            setReusableProxy({ child }, wsUrl, {
+                headless: options.headless,
+                slowMo: options.slowMo,
+                width: options.width,
+                height: options.height,
+                pageUrl: options.pageUrl,
+            });
+            return session;
+        }
+        catch (fallbackError) {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                /* ignore */
+            }
+            throw fallbackError instanceof Error ? fallbackError : e;
+        }
+    }
+}
 /**
  * Connect to a running Geometra server. Waits for the first frame so that
  * layout/tree state is available immediately after connection.
@@ -232,107 +338,26 @@ export async function connectThroughProxy(options) {
     clearReusableProxyIfExited();
     const desiredHeadless = options.headless === true;
     const desiredSlowMo = options.slowMo ?? 0;
+    let reuseFailure;
     if (reusableProxy &&
         reusableProxy.headless === desiredHeadless &&
         reusableProxy.slowMo === desiredSlowMo) {
-        const session = ((reusableProxy.child && activeSession?.proxyChild === reusableProxy.child) ||
-            (reusableProxy.runtime && activeSession?.proxyRuntime === reusableProxy.runtime))
-            ? activeSession
-            : await connect(reusableProxy.wsUrl, {
-                skipInitialResize: true,
-                closePreviousProxy: false,
-                awaitInitialFrame: options.awaitInitialFrame,
-            });
-        if (!session) {
-            throw new Error('Failed to attach to reusable proxy session');
-        }
-        session.proxyChild = reusableProxy.child;
-        session.proxyRuntime = reusableProxy.runtime;
-        session.proxyReusable = true;
-        const desiredWidth = options.width ?? reusableProxy.width;
-        const desiredHeight = options.height ?? reusableProxy.height;
-        if (desiredWidth !== reusableProxy.width || desiredHeight !== reusableProxy.height) {
-            await sendAndWaitForUpdate(session, {
-                type: 'resize',
-                width: desiredWidth,
-                height: desiredHeight,
-            }, 5_000);
-            reusableProxy.width = desiredWidth;
-            reusableProxy.height = desiredHeight;
+        try {
+            return await attachToReusableProxy(options);
         }
-        if (options.pageUrl) {
-            const currentUrl = session.cachedA11y?.meta?.pageUrl ?? reusableProxy.pageUrl;
-            if (currentUrl !== options.pageUrl) {
-                await sendNavigate(session, options.pageUrl, 15_000);
-                if ((session.proxyChild && reusableProxy?.child === session.proxyChild) ||
-                    (session.proxyRuntime && reusableProxy?.runtime === session.proxyRuntime)) {
-                    reusableProxy.pageUrl = options.pageUrl;
-                }
-            }
+        catch (err) {
+            reuseFailure = err;
+            closeReusableProxy();
         }
-        return session;
     }
-    closeReusableProxy();
     try {
-        const { runtime, wsUrl } = await startEmbeddedGeometraProxy({
-            pageUrl: options.pageUrl,
-            port: options.port ?? 0,
-            headless: options.headless,
-            width: options.width,
-            height: options.height,
-            slowMo: options.slowMo,
-        });
-        const session = await connect(wsUrl, {
-            skipInitialResize: true,
-            closePreviousProxy: false,
-            awaitInitialFrame: options.awaitInitialFrame,
-        });
-        session.proxyRuntime = runtime;
-        session.proxyReusable = true;
-        setReusableProxy({ runtime }, wsUrl, {
-            headless: options.headless,
-            slowMo: options.slowMo,
-            width: options.width,
-            height: options.height,
-            pageUrl: options.pageUrl,
-        });
-        return session;
+        return await startFreshProxySession(options);
     }
     catch (e) {
-        const { child, wsUrl } = await spawnGeometraProxy({
-            pageUrl: options.pageUrl,
-            port: options.port ?? 0,
-            headless: options.headless,
-            width: options.width,
-            height: options.height,
-            slowMo: options.slowMo,
-        });
-        try {
-            const session = await connect(wsUrl, {
-                skipInitialResize: true,
-                closePreviousProxy: false,
-                awaitInitialFrame: options.awaitInitialFrame,
-            });
-            session.proxyChild = child;
-            session.proxyReusable = true;
-            setReusableProxy({ child }, wsUrl, {
-                headless: options.headless,
-                slowMo: options.slowMo,
-                width: options.width,
-                height: options.height,
-                pageUrl: options.pageUrl,
-            });
-            return session;
-        }
-        catch (fallbackError) {
-            try {
-                child.kill('SIGTERM');
-            }
-            catch {
-                /* ignore */
-            }
-            throw fallbackError instanceof Error ? fallbackError : e;
+        if (reuseFailure) {
+            throw new Error(`Failed to recover reusable browser session after it became stale: ${formatUnknownError(reuseFailure)}\nFresh proxy start also failed: ${formatUnknownError(e)}`);
         }
+        throw e;
     }
 }
 export function getSession() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.19.17",
+  "version": "1.19.18",
   "description": "MCP server for Geometra — interact with running Geometra apps via the geometry protocol, no browser needed",
   "license": "MIT",
   "type": "module",
@@ -30,7 +30,7 @@
     "ui-testing"
   ],
   "dependencies": {
-    "@geometra/proxy": "^1.19.17",
+    "@geometra/proxy": "^1.19.18",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "ws": "^8.18.0",
     "zod": "^3.23.0"