@geometra/mcp 1.19.16 → 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/proxy-spawn.d.ts

@@ -1,7 +1,14 @@
 import { type ChildProcess } from 'node:child_process';
+export interface EmbeddedProxyRuntime {
+    wsUrl: string;
+    closed: boolean;
+    close: () => Promise<void>;
+}
 /** Resolve bundled @geometra/proxy CLI entry (dist/index.js). */
 export declare function resolveProxyScriptPath(): string;
 export declare function resolveProxyScriptPathWith(customRequire: NodeRequire, moduleDir?: string): string;
+export declare function resolveProxyRuntimePath(): string;
+export declare function resolveProxyRuntimePathWith(customRequire: NodeRequire, moduleDir?: string): string;
 export interface SpawnProxyParams {
     pageUrl: string;
     port: number;
@@ -10,6 +17,10 @@ export interface SpawnProxyParams {
     height?: number;
     slowMo?: number;
 }
+export declare function startEmbeddedGeometraProxy(opts: SpawnProxyParams): Promise<{
+    runtime: EmbeddedProxyRuntime;
+    wsUrl: string;
+}>;
 export declare function parseProxyReadySignalLine(line: string): string | undefined;
 export declare function formatProxyStartupFailure(message: string, opts: SpawnProxyParams): string;
 /**

package/dist/proxy-spawn.js

@@ -2,7 +2,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, realpathSync, rmSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 const require = createRequire(import.meta.url);
 const READY_SIGNAL_TYPE = 'geometra-proxy-ready';
 const READY_TIMEOUT_MS = 45_000;
@@ -12,21 +12,30 @@ export function resolveProxyScriptPath() {
     return resolveProxyScriptPathWith(require);
 }
 export function resolveProxyScriptPathWith(customRequire, moduleDir = MODULE_DIR) {
+    return resolveProxyDistPathWith(customRequire, moduleDir, 'index.js');
+}
+export function resolveProxyRuntimePath() {
+    return resolveProxyRuntimePathWith(require);
+}
+export function resolveProxyRuntimePathWith(customRequire, moduleDir = MODULE_DIR) {
+    return resolveProxyDistPathWith(customRequire, moduleDir, 'runtime.js');
+}
+function resolveProxyDistPathWith(customRequire, moduleDir, entryFile) {
     const errors = [];
-    const workspaceDist = path.resolve(moduleDir, '../../packages/proxy/dist/index.js');
+    const workspaceDist = path.resolve(moduleDir, `../../packages/proxy/dist/${entryFile}`);
     const bundledDependencyDir = path.resolve(moduleDir, '../node_modules/@geometra/proxy');
     const packageDir = resolveProxyPackageDir(customRequire);
     if (packageDir) {
         if (shouldPreferWorkspaceDist(packageDir, bundledDependencyDir) && existsSync(workspaceDist)) {
             return workspaceDist;
         }
-        const packagedDist = path.join(packageDir, 'dist/index.js');
+        const packagedDist = path.join(packageDir, 'dist', entryFile);
         if (existsSync(packagedDist))
             return packagedDist;
-        const builtLocalDist = buildLocalProxyDistIfPossible(packageDir, errors);
+        const builtLocalDist = buildLocalProxyDistIfPossible(packageDir, entryFile, errors);
         if (builtLocalDist)
             return builtLocalDist;
-        errors.push(`Resolved @geometra/proxy package at ${packageDir}, but dist/index.js was missing`);
+        errors.push(`Resolved @geometra/proxy package at ${packageDir}, but dist/${entryFile} was missing`);
     }
     else {
         errors.push('Could not find @geometra/proxy/package.json via Node module search paths');
@@ -34,24 +43,26 @@ export function resolveProxyScriptPathWith(customRequire, moduleDir = MODULE_DIR
     try {
         const pkgJson = customRequire.resolve('@geometra/proxy/package.json');
         const exportPackageDir = path.dirname(pkgJson);
-        const packagedDist = path.join(exportPackageDir, 'dist/index.js');
+        const packagedDist = path.join(exportPackageDir, 'dist', entryFile);
         if (existsSync(packagedDist))
             return packagedDist;
-        const builtLocalDist = buildLocalProxyDistIfPossible(exportPackageDir, errors);
+        const builtLocalDist = buildLocalProxyDistIfPossible(exportPackageDir, entryFile, errors);
         if (builtLocalDist)
             return builtLocalDist;
-        errors.push(`Resolved @geometra/proxy/package.json at ${pkgJson}, but dist/index.js was missing`);
+        errors.push(`Resolved @geometra/proxy/package.json at ${pkgJson}, but dist/${entryFile} was missing`);
     }
     catch (err) {
         errors.push(err instanceof Error ? err.message : String(err));
     }
-    try {
-        return customRequire.resolve('@geometra/proxy');
-    }
-    catch (err) {
-        errors.push(err instanceof Error ? err.message : String(err));
+    if (entryFile === 'index.js') {
+        try {
+            return customRequire.resolve('@geometra/proxy');
+        }
+        catch (err) {
+            errors.push(err instanceof Error ? err.message : String(err));
+        }
     }
-    const packagedSiblingDist = path.resolve(moduleDir, '../../proxy/dist/index.js');
+    const packagedSiblingDist = path.resolve(moduleDir, `../../proxy/dist/${entryFile}`);
     if (existsSync(packagedSiblingDist)) {
         return packagedSiblingDist;
     }
@@ -60,7 +71,7 @@ export function resolveProxyScriptPathWith(customRequire, moduleDir = MODULE_DIR
         return workspaceDist;
     }
     errors.push(`Workspace fallback not found at ${workspaceDist}`);
-    throw new Error(`Could not resolve @geometra/proxy. Install it with the MCP package: npm install @geometra/proxy. Resolution errors: ${errors.join(' | ')}`);
+    throw new Error(`Could not resolve @geometra/proxy dist/${entryFile}. Install it with the MCP package: npm install @geometra/proxy. Resolution errors: ${errors.join(' | ')}`);
 }
 function resolveProxyPackageDir(customRequire) {
     const searchRoots = customRequire.resolve.paths('@geometra/proxy') ?? [];
@@ -79,8 +90,8 @@ function shouldPreferWorkspaceDist(packageDir, bundledDependencyDir) {
         return false;
     }
 }
-function buildLocalProxyDistIfPossible(packageDir, errors) {
-    const distEntry = path.join(packageDir, 'dist/index.js');
+function buildLocalProxyDistIfPossible(packageDir, entryFile, errors) {
+    const distEntry = path.join(packageDir, 'dist', entryFile);
     const sourceEntry = path.join(packageDir, 'src/index.ts');
     const tsconfigPath = path.join(packageDir, 'tsconfig.build.json');
     if (!existsSync(sourceEntry) || !existsSync(tsconfigPath)) {
@@ -104,16 +115,32 @@ function buildLocalProxyDistIfPossible(packageDir, errors) {
         }
         if (existsSync(distEntry))
             return distEntry;
-        const realDistEntry = path.join(realPackageDir, 'dist/index.js');
+        const realDistEntry = path.join(realPackageDir, 'dist', entryFile);
         if (existsSync(realDistEntry))
             return realDistEntry;
-        errors.push(`Built local @geometra/proxy at ${realPackageDir}, but dist/index.js is still missing`);
+        errors.push(`Built local @geometra/proxy at ${realPackageDir}, but dist/${entryFile} is still missing`);
     }
     catch (err) {
         errors.push(err instanceof Error ? err.message : String(err));
     }
     return undefined;
 }
+export async function startEmbeddedGeometraProxy(opts) {
+    const runtimePath = resolveProxyRuntimePath();
+    const runtimeModule = await import(pathToFileURL(runtimePath).href);
+    if (typeof runtimeModule.launchProxyRuntime !== 'function') {
+        throw new Error(`Resolved ${runtimePath}, but it did not export launchProxyRuntime()`);
+    }
+    const runtime = await runtimeModule.launchProxyRuntime({
+        url: opts.pageUrl,
+        port: opts.port,
+        width: opts.width,
+        height: opts.height,
+        headed: opts.headless !== true,
+        slowMo: opts.slowMo,
+    });
+    return { runtime, wsUrl: runtime.wsUrl };
+}
 export function parseProxyReadySignalLine(line) {
     const trimmed = line.trim();
     if (!trimmed)

package/dist/server.js

@@ -175,7 +175,7 @@ const batchActionSchema = z.discriminatedUnion('type', [
     }),
 ]);
 export function createServer() {
-    const server = new McpServer({ name: 'geometra', version: '1.19.14' }, { capabilities: { tools: {} } });
+    const server = new McpServer({ name: 'geometra', version: '1.19.17' }, { capabilities: { tools: {} } });
     // ── connect ──────────────────────────────────────────────────
     server.tool('geometra_connect', `Connect to a Geometra WebSocket peer, or start \`geometra-proxy\` automatically for a normal web page.
 

package/dist/session.d.ts

@@ -1,5 +1,6 @@
 import type { ChildProcess } from 'node:child_process';
 import WebSocket from 'ws';
+import { type EmbeddedProxyRuntime } from './proxy-spawn.js';
 /**
  * Parsed accessibility node from the UI tree + computed layout.
  * Mirrors the shape of @geometra/core's AccessibilityNode without importing it
@@ -325,6 +326,7 @@ export interface Session {
     updateRevision: number;
     /** Present when this session owns a child geometra-proxy process (pageUrl connect). */
     proxyChild?: ChildProcess;
+    proxyRuntime?: EmbeddedProxyRuntime;
     proxyReusable?: boolean;
     cachedA11y?: A11yNode | null;
     cachedA11yRevision?: number;

package/dist/session.js

@@ -1,5 +1,5 @@
 import WebSocket from 'ws';
-import { spawnGeometraProxy } from './proxy-spawn.js';
+import { spawnGeometraProxy, startEmbeddedGeometraProxy } from './proxy-spawn.js';
 let activeSession = null;
 let reusableProxy = null;
 const ACTION_UPDATE_TIMEOUT_MS = 2000;
@@ -19,14 +19,42 @@ function invalidateSessionCaches(session) {
     session.cachedFormSchemas?.clear();
 }
 function clearReusableProxyIfExited() {
-    if (!reusableProxy?.child.killed && reusableProxy?.child.exitCode === null && reusableProxy?.child.signalCode === null) {
+    if (!reusableProxy)
+        return;
+    if (reusableProxy.child) {
+        if (!reusableProxy.child.killed && reusableProxy.child.exitCode === null && reusableProxy.child.signalCode === null) {
+            return;
+        }
+        reusableProxy = null;
         return;
     }
+    if (!reusableProxy.runtime.closed)
+        return;
     reusableProxy = null;
 }
-function setReusableProxy(child, wsUrl, opts) {
+function setReusableProxy(proxy, wsUrl, opts) {
+    if ('child' in proxy) {
+        const child = proxy.child;
+        reusableProxy = {
+            child,
+            wsUrl,
+            headless: opts.headless === true,
+            slowMo: opts.slowMo ?? 0,
+            width: opts.width ?? 1280,
+            height: opts.height ?? 720,
+            pageUrl: opts.pageUrl,
+        };
+        const clear = () => {
+            if (reusableProxy?.child === child)
+                reusableProxy = null;
+        };
+        child.once('exit', clear);
+        child.once('close', clear);
+        child.once('error', clear);
+        return;
+    }
     reusableProxy = {
-        child,
+        runtime: proxy.runtime,
         wsUrl,
         headless: opts.headless === true,
         slowMo: opts.slowMo ?? 0,
@@ -34,13 +62,6 @@ function setReusableProxy(child, wsUrl, opts) {
         height: opts.height ?? 720,
         pageUrl: opts.pageUrl,
     };
-    const clear = () => {
-        if (reusableProxy?.child === child)
-            reusableProxy = null;
-    };
-    child.once('exit', clear);
-    child.once('close', clear);
-    child.once('error', clear);
 }
 function closeReusableProxy() {
     clearReusableProxyIfExited();
@@ -48,12 +69,16 @@ function closeReusableProxy() {
     reusableProxy = null;
     if (!proxy)
         return;
-    try {
-        proxy.child.kill('SIGTERM');
-    }
-    catch {
-        /* ignore */
+    if (proxy.child) {
+        try {
+            proxy.child.kill('SIGTERM');
+        }
+        catch {
+            /* ignore */
+        }
+        return;
     }
+    void proxy.runtime.close().catch(() => { });
 }
 function rememberReusableProxyPageUrl(session) {
     const pageUrl = session.cachedA11y?.meta?.pageUrl;
@@ -61,6 +86,10 @@ function rememberReusableProxyPageUrl(session) {
         return;
     if (session.proxyChild && reusableProxy?.child === session.proxyChild) {
         reusableProxy.pageUrl = pageUrl;
+        return;
+    }
+    if (session.proxyRuntime && reusableProxy?.runtime === session.proxyRuntime) {
+        reusableProxy.pageUrl = pageUrl;
     }
 }
 function shutdownPreviousSession(opts) {
@@ -87,6 +116,122 @@ function shutdownPreviousSession(opts) {
         catch {
             /* ignore */
         }
+        return;
+    }
+    if (prev.proxyRuntime) {
+        const shouldKeepProxy = prev.proxyReusable && opts?.closeProxy === false;
+        rememberReusableProxyPageUrl(prev);
+        if (shouldKeepProxy)
+            return;
+        if (reusableProxy?.runtime === prev.proxyRuntime)
+            reusableProxy = null;
+        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;
+        }
     }
 }
 /**
@@ -173,6 +318,9 @@ export function connect(url, opts) {
                         /* ignore */
                     }
                 }
+                if (session.proxyRuntime && !session.proxyReusable) {
+                    void session.proxyRuntime.close().catch(() => { });
+                }
             }
             if (!resolved) {
                 resolved = true;
@@ -190,75 +338,24 @@ 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 = activeSession?.proxyChild === reusableProxy.child
-            ? 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.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 (reusableProxy?.child === session.proxyChild) {
-                    reusableProxy.pageUrl = options.pageUrl;
-                }
-            }
+        catch (err) {
+            reuseFailure = err;
+            closeReusableProxy();
         }
-        return session;
     }
-    closeReusableProxy();
-    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;
+        return await startFreshProxySession(options);
     }
     catch (e) {
-        try {
-            child.kill('SIGTERM');
-        }
-        catch {
-            /* ignore */
+        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;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.19.16",
+  "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.16",
+    "@geometra/proxy": "^1.19.18",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "ws": "^8.18.0",
     "zod": "^3.23.0"