@geometra/mcp 1.19.16 → 1.19.17

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,16 @@ 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(() => { });
     }
 }
 /**
@@ -173,6 +212,9 @@ export function connect(url, opts) {
                         /* ignore */
                     }
                 }
+                if (session.proxyRuntime && !session.proxyReusable) {
+                    void session.proxyRuntime.close().catch(() => { });
+                }
             }
             if (!resolved) {
                 resolved = true;
@@ -193,7 +235,8 @@ export async function connectThroughProxy(options) {
     if (reusableProxy &&
         reusableProxy.headless === desiredHeadless &&
         reusableProxy.slowMo === desiredSlowMo) {
-        const session = activeSession?.proxyChild === reusableProxy.child
+        const session = ((reusableProxy.child && activeSession?.proxyChild === reusableProxy.child) ||
+            (reusableProxy.runtime && activeSession?.proxyRuntime === reusableProxy.runtime))
             ? activeSession
             : await connect(reusableProxy.wsUrl, {
                 skipInitialResize: true,
@@ -204,6 +247,7 @@ export async function connectThroughProxy(options) {
             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;
@@ -220,7 +264,8 @@ export async function connectThroughProxy(options) {
             const currentUrl = session.cachedA11y?.meta?.pageUrl ?? reusableProxy.pageUrl;
             if (currentUrl !== options.pageUrl) {
                 await sendNavigate(session, options.pageUrl, 15_000);
-                if (reusableProxy?.child === session.proxyChild) {
+                if ((session.proxyChild && reusableProxy?.child === session.proxyChild) ||
+                    (session.proxyRuntime && reusableProxy?.runtime === session.proxyRuntime)) {
                     reusableProxy.pageUrl = options.pageUrl;
                 }
             }
@@ -228,23 +273,23 @@ export async function connectThroughProxy(options) {
         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 { 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.proxyChild = child;
+        session.proxyRuntime = runtime;
         session.proxyReusable = true;
-        setReusableProxy(child, wsUrl, {
+        setReusableProxy({ runtime }, wsUrl, {
             headless: options.headless,
             slowMo: options.slowMo,
             width: options.width,
@@ -254,13 +299,40 @@ export async function connectThroughProxy(options) {
         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 {
-            child.kill('SIGTERM');
+            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 {
-            /* ignore */
+        catch (fallbackError) {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                /* ignore */
+            }
+            throw fallbackError instanceof Error ? fallbackError : e;
         }
-        throw e;
     }
 }
 export function getSession() {

package/package.json

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