@geometra/mcp 1.19.15 → 1.19.17

package/dist/session.js

@@ -1,6 +1,7 @@
 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;
 const LISTBOX_UPDATE_TIMEOUT_MS = 4500;
 const FILL_BATCH_BASE_TIMEOUT_MS = 2500;
@@ -12,7 +13,86 @@ const FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS = 225;
 const FILL_BATCH_FILE_FIELD_TIMEOUT_MS = 5000;
 const FILL_BATCH_MAX_TIMEOUT_MS = 60_000;
 let nextRequestSequence = 0;
-function shutdownPreviousSession() {
+function invalidateSessionCaches(session) {
+    session.cachedA11y = null;
+    session.cachedA11yRevision = -1;
+    session.cachedFormSchemas?.clear();
+}
+function clearReusableProxyIfExited() {
+    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(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 = {
+        runtime: proxy.runtime,
+        wsUrl,
+        headless: opts.headless === true,
+        slowMo: opts.slowMo ?? 0,
+        width: opts.width ?? 1280,
+        height: opts.height ?? 720,
+        pageUrl: opts.pageUrl,
+    };
+}
+function closeReusableProxy() {
+    clearReusableProxyIfExited();
+    const proxy = reusableProxy;
+    reusableProxy = null;
+    if (!proxy)
+        return;
+    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;
+    if (!pageUrl)
+        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) {
     const prev = activeSession;
     if (!prev)
         return;
@@ -24,12 +104,28 @@ function shutdownPreviousSession() {
         /* ignore */
     }
     if (prev.proxyChild) {
+        const shouldKeepProxy = prev.proxyReusable && opts?.closeProxy === false;
+        rememberReusableProxyPageUrl(prev);
+        if (shouldKeepProxy)
+            return;
+        if (reusableProxy?.child === prev.proxyChild)
+            reusableProxy = null;
         try {
             prev.proxyChild.kill('SIGTERM');
         }
         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(() => { });
     }
 }
 /**
@@ -38,9 +134,22 @@ function shutdownPreviousSession() {
  */
 export function connect(url, opts) {
     return new Promise((resolve, reject) => {
-        shutdownPreviousSession();
+        clearReusableProxyIfExited();
+        if (reusableProxy && reusableProxy.wsUrl !== url) {
+            closeReusableProxy();
+        }
+        shutdownPreviousSession({ closeProxy: opts?.closePreviousProxy ?? true });
         const ws = new WebSocket(url);
-        const session = { ws, layout: null, tree: null, url, updateRevision: 0 };
+        const session = {
+            ws,
+            layout: null,
+            tree: null,
+            url,
+            updateRevision: 0,
+            cachedA11y: null,
+            cachedA11yRevision: -1,
+            cachedFormSchemas: new Map(),
+        };
         let resolved = false;
         const timeout = setTimeout(() => {
             if (!resolved) {
@@ -50,11 +159,17 @@ export function connect(url, opts) {
             }
         }, 10_000);
         ws.on('open', () => {
-            if (opts?.skipInitialResize)
-                return;
-            const width = opts?.width ?? 1024;
-            const height = opts?.height ?? 768;
-            ws.send(JSON.stringify({ type: 'resize', width, height }));
+            if (!opts?.skipInitialResize) {
+                const width = opts?.width ?? 1024;
+                const height = opts?.height ?? 768;
+                ws.send(JSON.stringify({ type: 'resize', width, height }));
+            }
+            if (opts?.awaitInitialFrame === false && !resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                activeSession = session;
+                resolve(session);
+            }
         });
         ws.on('message', (data) => {
             try {
@@ -63,6 +178,7 @@ export function connect(url, opts) {
                     session.layout = msg.layout;
                     session.tree = msg.tree;
                     session.updateRevision++;
+                    invalidateSessionCaches(session);
                     if (!resolved) {
                         resolved = true;
                         clearTimeout(timeout);
@@ -73,6 +189,7 @@ export function connect(url, opts) {
                 else if (msg.type === 'patch' && session.layout) {
                     applyPatches(session.layout, msg.patches);
                     session.updateRevision++;
+                    invalidateSessionCaches(session);
                 }
             }
             catch { /* ignore malformed messages */ }
@@ -87,7 +204,7 @@ export function connect(url, opts) {
         ws.on('close', () => {
             if (activeSession === session) {
                 activeSession = null;
-                if (session.proxyChild) {
+                if (session.proxyChild && !session.proxyReusable) {
                     try {
                         session.proxyChild.kill('SIGTERM');
                     }
@@ -95,6 +212,9 @@ export function connect(url, opts) {
                         /* ignore */
                     }
                 }
+                if (session.proxyRuntime && !session.proxyReusable) {
+                    void session.proxyRuntime.close().catch(() => { });
+                }
             }
             if (!resolved) {
                 resolved = true;
@@ -109,47 +229,135 @@ export function connect(url, opts) {
  * process to the session so disconnect / reconnect can clean it up.
  */
 export async function connectThroughProxy(options) {
-    const { child, wsUrl } = await spawnGeometraProxy({
-        pageUrl: options.pageUrl,
-        port: options.port ?? 0,
-        headless: options.headless,
-        width: options.width,
-        height: options.height,
-        slowMo: options.slowMo,
-    });
+    clearReusableProxyIfExited();
+    const desiredHeadless = options.headless === true;
+    const desiredSlowMo = options.slowMo ?? 0;
+    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;
+        }
+        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;
+                }
+            }
+        }
+        return session;
+    }
+    closeReusableProxy();
     try {
-        const session = await connect(wsUrl, { skipInitialResize: true });
-        session.proxyChild = child;
+        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 {
-            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() {
     return activeSession;
 }
-export function disconnect() {
-    shutdownPreviousSession();
+export function disconnect(opts) {
+    shutdownPreviousSession({ closeProxy: opts?.closeProxy ?? false });
+    if (opts?.closeProxy)
+        closeReusableProxy();
 }
 function estimateFillBatchTimeout(fields) {
     let total = FILL_BATCH_BASE_TIMEOUT_MS;
     let totalTextLength = 0;
     for (const field of fields) {
         switch (field.kind) {
+            case 'auto':
+                total += typeof field.value === 'boolean' ? FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS : FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS;
+                break;
             case 'text':
                 totalTextLength += field.value.length;
                 total += FILL_BATCH_TEXT_FIELD_TIMEOUT_MS;
                 total += Math.ceil(Math.max(1, field.value.length) / FILL_BATCH_TEXT_LENGTH_SLICE) * FILL_BATCH_TEXT_LENGTH_TIMEOUT_MS;
                 break;
             case 'choice':
-                total += FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS;
+                total += field.choiceType === 'group' ? FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS : FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS;
                 break;
             case 'toggle':
                 total += FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS;
@@ -285,6 +493,8 @@ export function sendFieldText(session, fieldLabel, value, opts, timeoutMs) {
     };
     if (opts?.exact !== undefined)
         payload.exact = opts.exact;
+    if (opts?.fieldId)
+        payload.fieldId = opts.fieldId;
     return sendAndWaitForUpdate(session, payload, timeoutMs);
 }
 /** Choose a value for a labeled choice field (select, custom combobox, or radio-style group). */
@@ -298,6 +508,10 @@ export function sendFieldChoice(session, fieldLabel, value, opts, timeoutMs = LI
         payload.exact = opts.exact;
     if (opts?.query)
         payload.query = opts.query;
+    if (opts?.choiceType)
+        payload.choiceType = opts.choiceType;
+    if (opts?.fieldId)
+        payload.fieldId = opts.fieldId;
     return sendAndWaitForUpdate(session, payload, timeoutMs);
 }
 /** Fill several semantic form fields in one proxy-side batch. */
@@ -349,6 +563,13 @@ export function sendWheel(session, deltaY, opts, timeoutMs) {
         ...(opts?.y !== undefined ? { y: opts.y } : {}),
     }, timeoutMs);
 }
+/** Navigate the proxy page to a new URL while keeping the browser process alive. */
+export function sendNavigate(session, url, timeoutMs = 15_000) {
+    return sendAndWaitForUpdate(session, {
+        type: 'navigate',
+        url,
+    }, timeoutMs, { requireUpdateOnAck: true });
+}
 /**
  * Build a flat accessibility tree from the raw UI tree + layout.
  * This is a standalone reimplementation that works with raw JSON —
@@ -974,10 +1195,16 @@ function simpleSchemaField(root, node) {
     const label = fieldLabel(node) ?? sanitizeInlineName(node.name, 80) ?? context?.prompt;
     if (!label)
         return null;
+    const choiceType = node.role === 'combobox'
+        ? node.meta?.controlTag === 'select'
+            ? 'select'
+            : 'listbox'
+        : undefined;
     return {
         id: formFieldIdForPath(node.path),
         kind: node.role === 'combobox' ? 'choice' : 'text',
         label,
+        ...(choiceType ? { choiceType } : {}),
         ...(node.state?.required ? { required: true } : {}),
         ...(node.state?.invalid ? { invalid: true } : {}),
         ...compactSchemaValue(node.value, 72),
@@ -1002,6 +1229,7 @@ function groupedSchemaField(root, grouped) {
         id: formFieldIdForPath(grouped.container.path),
         kind: radioLike ? 'choice' : 'multi_choice',
         label: grouped.prompt,
+        ...(radioLike ? { choiceType: 'group' } : {}),
         ...(grouped.controls.some(control => control.state?.required) ? { required: true } : {}),
         ...(grouped.controls.some(control => control.state?.invalid) ? { invalid: true } : {}),
         ...(radioLike
@@ -1068,7 +1296,7 @@ function buildFormSchemaForNode(root, formNode, options) {
             consumed.add(candidateKey);
         }
     }
-    const compactFields = trimSchemaFieldContexts(fields);
+    const compactFields = presentFormSchemaFields(fields, options);
     const filteredFields = compactFields.filter(field => {
         if (options?.onlyRequiredFields && !field.required)
             return false;
@@ -1089,14 +1317,35 @@ function buildFormSchemaForNode(root, formNode, options) {
     };
 }
 function trimSchemaFieldContexts(fields) {
+    return presentFormSchemaFields(fields, { includeOptions: true, includeContext: 'auto' });
+}
+function presentFormSchemaFields(fields, options) {
+    const includeOptions = options?.includeOptions ?? false;
+    const includeContext = options?.includeContext ?? 'auto';
     const labelCounts = new Map();
     for (const field of fields) {
         const key = normalizeUiText(field.label);
         labelCounts.set(key, (labelCounts.get(key) ?? 0) + 1);
     }
     return fields.map(field => {
+        const booleanChoice = field.kind === 'choice' &&
+            field.choiceType === 'group' &&
+            field.optionCount === 2 &&
+            field.options?.length === 2 &&
+            field.options.every(option => ['yes', 'no'].includes(normalizeUiText(option).toLowerCase()));
+        const next = { ...field };
+        if (booleanChoice)
+            next.booleanChoice = true;
+        if (!includeOptions)
+            delete next.options;
+        if (includeContext === 'none') {
+            delete next.context;
+            return next;
+        }
         if (!field.context)
-            return field;
+            return next;
+        if (includeContext === 'always')
+            return next;
         const trimmed = {};
         if (field.context.prompt && normalizeUiText(field.context.prompt) !== normalizeUiText(field.label)) {
             trimmed.prompt = field.context.prompt;
@@ -1105,10 +1354,11 @@ function trimSchemaFieldContexts(fields) {
             trimmed.section = field.context.section;
         }
         if (Object.keys(trimmed).length === 0) {
-            const { context: _context, ...rest } = field;
-            return rest;
+            delete next.context;
+            return next;
         }
-        return { ...field, context: trimmed };
+        next.context = trimmed;
+        return next;
     });
 }
 function toLandmarkModel(node) {
@@ -1690,6 +1940,8 @@ function walkNode(element, layout, path) {
         meta.scrollX = semantic.scrollX;
     if (typeof semantic?.scrollY === 'number' && Number.isFinite(semantic.scrollY))
         meta.scrollY = semantic.scrollY;
+    if (typeof semantic?.tag === 'string' && semantic.tag.trim().length > 0)
+        meta.controlTag = semantic.tag;
     const children = [];
     const elementChildren = element.children;
     const layoutChildren = layout.children;
@@ -1789,7 +2041,7 @@ function applyPatches(layout, patches) {
             node.height = patch.height;
     }
 }
-function sendAndWaitForUpdate(session, message, timeoutMs = ACTION_UPDATE_TIMEOUT_MS) {
+function sendAndWaitForUpdate(session, message, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, opts) {
     return new Promise((resolve, reject) => {
         if (session.ws.readyState !== WebSocket.OPEN) {
             reject(new Error('Not connected'));
@@ -1798,11 +2050,14 @@ function sendAndWaitForUpdate(session, message, timeoutMs = ACTION_UPDATE_TIMEOU
         const requestId = `req-${++nextRequestSequence}`;
         const startRevision = session.updateRevision;
         session.ws.send(JSON.stringify({ ...message, requestId }));
-        waitForNextUpdate(session, timeoutMs, requestId, startRevision).then(resolve).catch(reject);
+        waitForNextUpdate(session, timeoutMs, requestId, startRevision, opts).then(resolve).catch(reject);
     });
 }
-function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, requestId, startRevision = session.updateRevision) {
+function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, requestId, startRevision = session.updateRevision, opts) {
     return new Promise((resolve, reject) => {
+        let ackSeen = false;
+        let ackResult;
+        const ackPayload = () => (ackSeen && ackResult !== undefined ? { result: ackResult } : {});
         const onMessage = (data) => {
             try {
                 const msg = JSON.parse(String(data));
@@ -1813,13 +2068,26 @@ function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, reques
                         reject(new Error(typeof msg.message === 'string' ? msg.message : 'Geometra server error'));
                         return;
                     }
-                    if (msg.type === 'ack' && messageRequestId === requestId) {
+                    if ((msg.type === 'frame' || (msg.type === 'patch' && session.layout)) && ackSeen && session.updateRevision > startRevision) {
                         cleanup();
                         resolve({
-                            status: session.updateRevision > startRevision ? 'updated' : 'acknowledged',
+                            status: 'updated',
                             timeoutMs,
-                            ...(msg.result !== undefined ? { result: msg.result } : {}),
+                            ...ackPayload(),
                         });
+                        return;
+                    }
+                    if (msg.type === 'ack' && messageRequestId === requestId) {
+                        ackSeen = true;
+                        ackResult = msg.result;
+                        if (!opts?.requireUpdateOnAck || session.updateRevision > startRevision) {
+                            cleanup();
+                            resolve({
+                                status: session.updateRevision > startRevision ? 'updated' : 'acknowledged',
+                                timeoutMs,
+                                ...ackPayload(),
+                            });
+                        }
                     }
                     return;
                 }
@@ -1851,7 +2119,11 @@ function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, reques
         const timeout = setTimeout(() => {
             cleanup();
             if (requestId && session.updateRevision > startRevision) {
-                resolve({ status: 'updated', timeoutMs });
+                resolve({ status: 'updated', timeoutMs, ...ackPayload() });
+                return;
+            }
+            if (requestId && ackSeen) {
+                resolve({ status: 'acknowledged', timeoutMs, ...ackPayload() });
                 return;
             }
             resolve({ status: 'timed_out', timeoutMs });

package/package.json

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