@geometra/mcp 1.19.7 → 1.19.8

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

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

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

@@ -0,0 +1,59 @@
+import { afterAll, describe, expect, it } from 'vitest';
+import { WebSocketServer } from 'ws';
+import { connect, disconnect, sendListboxPick } from '../session.js';
+describe('proxy-backed MCP actions', () => {
+    afterAll(() => {
+        disconnect();
+    });
+    it('waits for final listbox outcome instead of resolving on intermediate updates', async () => {
+        const wss = new WebSocketServer({ port: 0 });
+        wss.on('connection', ws => {
+            ws.on('message', raw => {
+                const msg = JSON.parse(String(raw));
+                if (msg.type === 'resize') {
+                    ws.send(JSON.stringify({
+                        type: 'frame',
+                        layout: { x: 0, y: 0, width: 1024, height: 768, children: [] },
+                        tree: { kind: 'box', props: {}, semantic: { tag: 'body', role: 'group' }, children: [] },
+                    }));
+                    return;
+                }
+                if (msg.type === 'listboxPick') {
+                    ws.send(JSON.stringify({
+                        type: 'frame',
+                        layout: { x: 0, y: 0, width: 1024, height: 768, children: [] },
+                        tree: { kind: 'box', props: {}, semantic: { tag: 'body', role: 'group' }, children: [] },
+                    }));
+                    setTimeout(() => {
+                        ws.send(JSON.stringify({
+                            type: 'error',
+                            requestId: msg.requestId,
+                            message: 'listboxPick: no visible option matching \"Japan\"',
+                        }));
+                    }, 20);
+                }
+            });
+        });
+        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);
+        });
+        try {
+            const session = await connect(`ws://127.0.0.1:${port}`);
+            await expect(sendListboxPick(session, 'Japan', {
+                fieldLabel: 'Country',
+                exact: true,
+            })).rejects.toThrow('listboxPick: no visible option matching "Japan"');
+        }
+        finally {
+            disconnect();
+            await new Promise((resolve, reject) => wss.close(err => (err ? reject(err) : resolve())));
+        }
+    });
+});

package/dist/server.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { formatConnectFailureMessage, isHttpUrl, normalizeConnectTarget } from './connect-utils.js';
 import { connect, connectThroughProxy, disconnect, getSession, sendClick, sendType, sendKey, sendFileUpload, sendListboxPick, sendSelectOption, sendSetChecked, sendWheel, buildA11yTree, buildCompactUiIndex, buildPageModel, expandPageSection, buildUiDelta, hasUiDelta, nodeIdForPath, summarizeCompactIndex, summarizePageModel, summarizeUiDelta, } from './session.js';
 export function createServer() {
-    const server = new McpServer({ name: 'geometra', version: '1.19.7' }, { capabilities: { tools: {} } });
+    const server = new McpServer({ name: 'geometra', version: '1.19.8' }, { capabilities: { tools: {} } });
     // ── connect ──────────────────────────────────────────────────
     server.tool('geometra_connect', `Connect to a Geometra WebSocket peer, or start \`geometra-proxy\` automatically for a normal web page.
 
@@ -69,7 +69,7 @@ Chromium opens **visible** by default unless \`headless: true\`. File upload / w
         }
     });
     // ── query ────────────────────────────────────────────────────
-    server.tool('geometra_query', `Find elements in the current Geometra UI by stable id, role, name, or text content. Returns matching elements with their exact pixel bounds {x, y, width, height}, visible in-viewport bounds, an on-screen center point, role, name, and tree path.
+    server.tool('geometra_query', `Find elements in the current Geometra UI by stable id, role, name, or text content. Returns matching elements with their exact pixel bounds {x, y, width, height}, visible in-viewport bounds, an on-screen center point, visibility / scroll-reveal hints, role, name, and tree path.
 
 This is the Geometra equivalent of Playwright's locator — but instant, structured, and with no browser. Use the returned bounds to click elements or assert on layout.`, {
         id: z.string().optional().describe('Stable node id from geometra_snapshot or geometra_expand_section'),
@@ -223,7 +223,7 @@ Strategies: **auto** (default) tries chooser click if x,y given, else hidden \`i
     });
     server.tool('geometra_pick_listbox_option', `Pick an option from a custom dropdown / listbox / searchable combobox (Headless UI, React Select, Radix, Ashby-style custom selects, etc.). Requires \`@geometra/proxy\`.
 
-Pass \`fieldLabel\` to open a labeled dropdown semantically instead of relying on coordinates. If the opened control is editable, MCP types \`query\` (or the option label by default) before selecting. Uses substring name match unless exact=true.`, {
+Pass \`fieldLabel\` to open a labeled dropdown semantically instead of relying on coordinates. If the opened control is editable, MCP types \`query\` (or the option label by default) before selecting. Uses substring name match unless exact=true, prefers the popup nearest the opened field, and handles a few short affirmative/negative aliases such as \`Yes\` /\`No\` for consent-style copy.`, {
         label: z.string().describe('Accessible name of the option (visible text or aria-label)'),
         exact: z.boolean().optional().describe('Exact name match'),
         openX: z.number().optional().describe('Click to open dropdown'),
@@ -450,12 +450,18 @@ function formatNode(node, viewport) {
     const visibleRight = Math.min(viewport.width, node.bounds.x + node.bounds.width);
     const visibleBottom = Math.min(viewport.height, node.bounds.y + node.bounds.height);
     const hasVisibleIntersection = visibleRight > visibleLeft && visibleBottom > visibleTop;
+    const fullyVisible = node.bounds.x >= 0 &&
+        node.bounds.y >= 0 &&
+        node.bounds.x + node.bounds.width <= viewport.width &&
+        node.bounds.y + node.bounds.height <= viewport.height;
     const centerX = hasVisibleIntersection
         ? Math.round((visibleLeft + visibleRight) / 2)
         : Math.round(Math.min(Math.max(node.bounds.x + node.bounds.width / 2, 0), viewport.width));
     const centerY = hasVisibleIntersection
         ? Math.round((visibleTop + visibleBottom) / 2)
         : Math.round(Math.min(Math.max(node.bounds.y + node.bounds.height / 2, 0), viewport.height));
+    const revealDeltaX = Math.round(node.bounds.x + node.bounds.width / 2 - viewport.width / 2);
+    const revealDeltaY = Math.round(node.bounds.y + node.bounds.height / 2 - viewport.height / 2);
     return {
         id: nodeIdForPath(node.path),
         role: node.role,
@@ -471,6 +477,19 @@ function formatNode(node, viewport) {
             x: centerX,
             y: centerY,
         },
+        visibility: {
+            intersectsViewport: hasVisibleIntersection,
+            fullyVisible,
+            offscreenAbove: node.bounds.y + node.bounds.height <= 0,
+            offscreenBelow: node.bounds.y >= viewport.height,
+            offscreenLeft: node.bounds.x + node.bounds.width <= 0,
+            offscreenRight: node.bounds.x >= viewport.width,
+        },
+        scrollHint: {
+            status: fullyVisible ? 'visible' : hasVisibleIntersection ? 'partial' : 'offscreen',
+            revealDeltaX,
+            revealDeltaY,
+        },
         focusable: node.focusable,
         ...(node.state && Object.keys(node.state).length > 0 ? { state: node.state } : {}),
         path: node.path,

package/dist/session.d.ts

@@ -223,6 +223,7 @@ export interface Session {
     layout: Record<string, unknown> | null;
     tree: Record<string, unknown> | null;
     url: string;
+    updateRevision: number;
     /** Present when this session owns a child geometra-proxy process (pageUrl connect). */
     proxyChild?: ChildProcess;
 }

package/dist/session.js

@@ -2,6 +2,8 @@ import WebSocket from 'ws';
 import { spawnGeometraProxy } from './proxy-spawn.js';
 let activeSession = null;
 const ACTION_UPDATE_TIMEOUT_MS = 2000;
+const LISTBOX_UPDATE_TIMEOUT_MS = 4500;
+let nextRequestSequence = 0;
 function shutdownPreviousSession() {
     const prev = activeSession;
     if (!prev)
@@ -30,7 +32,7 @@ export function connect(url) {
     return new Promise((resolve, reject) => {
         shutdownPreviousSession();
         const ws = new WebSocket(url);
-        const session = { ws, layout: null, tree: null, url };
+        const session = { ws, layout: null, tree: null, url, updateRevision: 0 };
         let resolved = false;
         const timeout = setTimeout(() => {
             if (!resolved) {
@@ -49,6 +51,7 @@ export function connect(url) {
                 if (msg.type === 'frame') {
                     session.layout = msg.layout;
                     session.tree = msg.tree;
+                    session.updateRevision++;
                     if (!resolved) {
                         resolved = true;
                         clearTimeout(timeout);
@@ -58,6 +61,7 @@ export function connect(url) {
                 }
                 else if (msg.type === 'patch' && session.layout) {
                     applyPatches(session.layout, msg.patches);
+                    session.updateRevision++;
                 }
             }
             catch { /* ignore malformed messages */ }
@@ -208,7 +212,7 @@ export function sendListboxPick(session, label, opts) {
         payload.fieldLabel = opts.fieldLabel;
     if (opts?.query)
         payload.query = opts.query;
-    return sendAndWaitForUpdate(session, payload);
+    return sendAndWaitForUpdate(session, payload, LISTBOX_UPDATE_TIMEOUT_MS);
 }
 /** Native `<select>` only: click the control center, then pick by value, label text, or zero-based index. */
 export function sendSelectOption(session, x, y, option) {
@@ -1258,40 +1262,55 @@ function applyPatches(layout, patches) {
             node.height = patch.height;
     }
 }
-function sendAndWaitForUpdate(session, message) {
+function sendAndWaitForUpdate(session, message, timeoutMs = ACTION_UPDATE_TIMEOUT_MS) {
     return new Promise((resolve, reject) => {
         if (session.ws.readyState !== WebSocket.OPEN) {
             reject(new Error('Not connected'));
             return;
         }
-        session.ws.send(JSON.stringify(message));
-        waitForNextUpdate(session).then(resolve).catch(reject);
+        const requestId = `req-${++nextRequestSequence}`;
+        const startRevision = session.updateRevision;
+        session.ws.send(JSON.stringify({ ...message, requestId }));
+        waitForNextUpdate(session, timeoutMs, requestId, startRevision).then(resolve).catch(reject);
     });
 }
-function waitForNextUpdate(session) {
+function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, requestId, startRevision = session.updateRevision) {
     return new Promise((resolve, reject) => {
         const onMessage = (data) => {
             try {
                 const msg = JSON.parse(String(data));
+                const messageRequestId = typeof msg.requestId === 'string' ? msg.requestId : undefined;
+                if (requestId) {
+                    if (msg.type === 'error' && messageRequestId === requestId) {
+                        cleanup();
+                        reject(new Error(typeof msg.message === 'string' ? msg.message : 'Geometra server error'));
+                        return;
+                    }
+                    if (msg.type === 'ack' && messageRequestId === requestId) {
+                        cleanup();
+                        resolve({
+                            status: session.updateRevision > startRevision ? 'updated' : 'acknowledged',
+                            timeoutMs,
+                        });
+                    }
+                    return;
+                }
                 if (msg.type === 'error') {
                     cleanup();
                     reject(new Error(typeof msg.message === 'string' ? msg.message : 'Geometra server error'));
                     return;
                 }
                 if (msg.type === 'frame') {
-                    session.layout = msg.layout;
-                    session.tree = msg.tree;
                     cleanup();
-                    resolve({ status: 'updated', timeoutMs: ACTION_UPDATE_TIMEOUT_MS });
+                    resolve({ status: 'updated', timeoutMs });
                 }
                 else if (msg.type === 'patch' && session.layout) {
-                    applyPatches(session.layout, msg.patches);
                     cleanup();
-                    resolve({ status: 'updated', timeoutMs: ACTION_UPDATE_TIMEOUT_MS });
+                    resolve({ status: 'updated', timeoutMs });
                 }
                 else if (msg.type === 'ack') {
                     cleanup();
-                    resolve({ status: 'acknowledged', timeoutMs: ACTION_UPDATE_TIMEOUT_MS });
+                    resolve({ status: 'acknowledged', timeoutMs });
                 }
             }
             catch { /* ignore */ }
@@ -1299,8 +1318,8 @@ function waitForNextUpdate(session) {
         // Expose timeout explicitly so action handlers can tell the user the result is ambiguous.
         const timeout = setTimeout(() => {
             cleanup();
-            resolve({ status: 'timed_out', timeoutMs: ACTION_UPDATE_TIMEOUT_MS });
-        }, ACTION_UPDATE_TIMEOUT_MS);
+            resolve({ status: 'timed_out', timeoutMs });
+        }, timeoutMs);
         function cleanup() {
             clearTimeout(timeout);
             session.ws.off('message', onMessage);

package/package.json

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