@geometra/mcp 1.19.12 → 1.19.14

package/dist/session.js

@@ -3,6 +3,12 @@ import { spawnGeometraProxy } from './proxy-spawn.js';
 let activeSession = null;
 const ACTION_UPDATE_TIMEOUT_MS = 2000;
 const LISTBOX_UPDATE_TIMEOUT_MS = 4500;
+const FILL_BATCH_BASE_TIMEOUT_MS = 2500;
+const FILL_BATCH_TEXT_FIELD_TIMEOUT_MS = 250;
+const FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS = 450;
+const FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS = 200;
+const FILL_BATCH_FILE_FIELD_TIMEOUT_MS = 5000;
+const FILL_BATCH_MAX_TIMEOUT_MS = 30_000;
 let nextRequestSequence = 0;
 function shutdownPreviousSession() {
     const prev = activeSession;
@@ -28,7 +34,7 @@ function shutdownPreviousSession() {
  * Connect to a running Geometra server. Waits for the first frame so that
  * layout/tree state is available immediately after connection.
  */
-export function connect(url) {
+export function connect(url, opts) {
     return new Promise((resolve, reject) => {
         shutdownPreviousSession();
         const ws = new WebSocket(url);
@@ -42,8 +48,11 @@ export function connect(url) {
             }
         }, 10_000);
         ws.on('open', () => {
-            // Send initial resize so server computes layout
-            ws.send(JSON.stringify({ type: 'resize', width: 1024, height: 768 }));
+            if (opts?.skipInitialResize)
+                return;
+            const width = opts?.width ?? 1024;
+            const height = opts?.height ?? 768;
+            ws.send(JSON.stringify({ type: 'resize', width, height }));
         });
         ws.on('message', (data) => {
             try {
@@ -107,7 +116,7 @@ export async function connectThroughProxy(options) {
         slowMo: options.slowMo,
     });
     try {
-        const session = await connect(wsUrl);
+        const session = await connect(wsUrl, { skipInitialResize: true });
         session.proxyChild = child;
         return session;
     }
@@ -127,6 +136,26 @@ export function getSession() {
 export function disconnect() {
     shutdownPreviousSession();
 }
+function estimateFillBatchTimeout(fields) {
+    let total = FILL_BATCH_BASE_TIMEOUT_MS;
+    for (const field of fields) {
+        switch (field.kind) {
+            case 'text':
+                total += FILL_BATCH_TEXT_FIELD_TIMEOUT_MS;
+                break;
+            case 'choice':
+                total += FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS;
+                break;
+            case 'toggle':
+                total += FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS;
+                break;
+            case 'file':
+                total += FILL_BATCH_FILE_FIELD_TIMEOUT_MS;
+                break;
+        }
+    }
+    return Math.min(total, FILL_BATCH_MAX_TIMEOUT_MS);
+}
 export function waitForUiCondition(session, predicate, timeoutMs) {
     return new Promise((resolve) => {
         const check = () => {
@@ -263,6 +292,10 @@ export function sendFieldChoice(session, fieldLabel, value, opts, timeoutMs = LI
         payload.query = opts.query;
     return sendAndWaitForUpdate(session, payload, timeoutMs);
 }
+/** Fill several semantic form fields in one proxy-side batch. */
+export function sendFillFields(session, fields, timeoutMs = estimateFillBatchTimeout(fields)) {
+    return sendAndWaitForUpdate(session, { type: 'fillFields', fields }, timeoutMs);
+}
 /** ARIA `role=option` listbox (e.g. React Select). Optional click opens the list. */
 export function sendListboxPick(session, label, opts, timeoutMs = LISTBOX_UPDATE_TIMEOUT_MS) {
     const payload = { type: 'listboxPick', label };
@@ -387,6 +420,9 @@ function decodePath(encoded) {
 export function nodeIdForPath(path) {
     return `n:${encodePath(path)}`;
 }
+function formFieldIdForPath(path) {
+    return `ff:${encodePath(path)}`;
+}
 function sectionPrefix(kind) {
     if (kind === 'landmark')
         return 'lm';
@@ -800,7 +836,9 @@ function nearestPromptText(container, target) {
         const dy = Math.max(0, target.bounds.y - candidate.bounds.y);
         const dx = Math.abs(target.bounds.x - candidate.bounds.x);
         const headingBonus = candidate.role === 'heading' ? -32 : 0;
-        return { text, score: dy * 4 + dx + headingBonus };
+        const questionBonus = /\?\s*$/.test(text) ? -160 : 0;
+        const lengthPenalty = text.length > 90 ? 80 : text.length > 60 ? 40 : text.length > 45 ? 20 : 0;
+        return { text, score: dy * 4 + dx + headingBonus + questionBonus + lengthPenalty };
     })
         .filter((candidate) => !!candidate)
         .sort((a, b) => a.score - b.score)[0];
@@ -809,13 +847,19 @@ function nearestPromptText(container, target) {
 function nodeContext(root, node) {
     const ancestors = ancestorNodes(root, node.path);
     let prompt;
-    for (let index = ancestors.length - 1; index >= 0; index--) {
-        const ancestor = ancestors[index];
-        const grouped = countGroupedChoiceControls(ancestor) >= 2;
-        if (grouped || ancestor.role === 'group' || ancestor.role === 'form' || ancestor.role === 'dialog') {
-            prompt = nearestPromptText(ancestor, node);
-            if (prompt)
-                break;
+    const promptEligibleNode = node.role === 'radio' || node.role === 'button';
+    if (promptEligibleNode) {
+        for (let index = ancestors.length - 1; index >= 0; index--) {
+            const ancestor = ancestors[index];
+            const grouped = countGroupedChoiceControls(ancestor) >= 2;
+            const eligiblePromptContainer = (ancestor.role === 'group' && ancestor.path.length > 0) ||
+                ancestor.role === 'dialog' ||
+                (ancestor.role === 'form' && grouped);
+            if (eligiblePromptContainer) {
+                prompt = nearestPromptText(ancestor, node);
+                if (prompt)
+                    break;
+            }
         }
     }
     let section;
@@ -868,6 +912,197 @@ function toActionModel(root, node, includeBounds = true) {
         ...(includeBounds ? { bounds: cloneBounds(node.bounds) } : {}),
     };
 }
+function compactSchemaContext(context, label) {
+    if (!context)
+        return undefined;
+    const out = {};
+    if (context.prompt && normalizeUiText(context.prompt) !== normalizeUiText(label))
+        out.prompt = context.prompt;
+    if (context.section)
+        out.section = context.section;
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function compactSchemaValue(value, inlineLimit = 80) {
+    const normalized = sanitizeInlineName(value, Math.max(120, inlineLimit + 32));
+    if (!normalized)
+        return {};
+    return normalized.length <= inlineLimit
+        ? { value: normalized }
+        : { valueLength: normalized.length };
+}
+function schemaOptionLabel(node) {
+    return sanitizeFieldName(node.name, 80) ?? sanitizeInlineName(node.name, 80);
+}
+function isGroupedChoiceControl(node) {
+    return node.role === 'radio' || node.role === 'checkbox' || (node.role === 'button' && node.focusable);
+}
+function groupedChoiceForNode(root, formNode, seed) {
+    const context = nodeContext(root, seed);
+    const prompt = context?.prompt;
+    if (!prompt)
+        return null;
+    const matchesPrompt = (candidate) => {
+        if (!isGroupedChoiceControl(candidate))
+            return false;
+        return nodeContext(root, candidate)?.prompt === prompt;
+    };
+    const ancestors = ancestorNodes(root, seed.path);
+    for (let index = ancestors.length - 1; index >= 0; index--) {
+        const ancestor = ancestors[index];
+        if (ancestor.role === 'form')
+            continue;
+        const controls = sortByBounds(collectDescendants(ancestor, matchesPrompt));
+        if (controls.length >= 2) {
+            return { container: ancestor, prompt, controls };
+        }
+    }
+    if (seed.role !== 'radio' && seed.role !== 'button')
+        return null;
+    const controls = sortByBounds(collectDescendants(formNode, matchesPrompt));
+    return controls.length >= 2 ? { container: formNode, prompt, controls } : null;
+}
+function simpleSchemaField(root, node) {
+    const context = nodeContext(root, node);
+    const label = fieldLabel(node) ?? sanitizeInlineName(node.name, 80) ?? context?.prompt;
+    if (!label)
+        return null;
+    return {
+        id: formFieldIdForPath(node.path),
+        kind: node.role === 'combobox' ? 'choice' : 'text',
+        label,
+        ...(node.state?.required ? { required: true } : {}),
+        ...(node.state?.invalid ? { invalid: true } : {}),
+        ...compactSchemaValue(node.value, 72),
+        ...(compactSchemaContext(context, label) ? { context: compactSchemaContext(context, label) } : {}),
+    };
+}
+function groupedSchemaField(root, grouped) {
+    const optionEntries = grouped.controls
+        .map(control => ({
+        label: schemaOptionLabel(control),
+        selected: control.state?.checked === true || control.state?.selected === true,
+        role: control.role,
+    }))
+        .filter((entry) => !!entry.label);
+    if (optionEntries.length < 2)
+        return null;
+    const options = dedupeStrings(optionEntries.map(entry => entry.label), 16);
+    const selectedOptions = dedupeStrings(optionEntries.filter(entry => entry.selected).map(entry => entry.label), 16);
+    const radioLike = optionEntries.every(entry => entry.role === 'radio' || entry.role === 'button');
+    const context = nodeContext(root, grouped.controls[0]);
+    return {
+        id: formFieldIdForPath(grouped.container.path),
+        kind: radioLike ? 'choice' : 'multi_choice',
+        label: grouped.prompt,
+        ...(grouped.controls.some(control => control.state?.required) ? { required: true } : {}),
+        ...(grouped.controls.some(control => control.state?.invalid) ? { invalid: true } : {}),
+        ...(radioLike
+            ? {
+                ...(selectedOptions[0] ? { value: selectedOptions[0] } : {}),
+            }
+            : {
+                ...(selectedOptions.length > 0 ? { values: selectedOptions } : {}),
+            }),
+        optionCount: options.length,
+        options,
+        ...(compactSchemaContext(context, grouped.prompt) ? { context: compactSchemaContext(context, grouped.prompt) } : {}),
+    };
+}
+function toggleSchemaField(root, node) {
+    const label = schemaOptionLabel(node);
+    if (!label)
+        return null;
+    const context = nodeContext(root, node);
+    const controlType = node.role === 'radio' ? 'radio' : 'checkbox';
+    return {
+        id: formFieldIdForPath(node.path),
+        kind: 'toggle',
+        label,
+        controlType,
+        ...(node.state?.required ? { required: true } : {}),
+        ...(node.state?.invalid ? { invalid: true } : {}),
+        ...(node.state?.checked !== undefined ? { checked: node.state.checked === true } : {}),
+        ...(compactSchemaContext(context, label) ? { context: compactSchemaContext(context, label) } : {}),
+    };
+}
+function buildFormSchemaForNode(root, formNode, options) {
+    const candidates = sortByBounds(collectDescendants(formNode, candidate => candidate.role === 'textbox' ||
+        candidate.role === 'combobox' ||
+        candidate.role === 'checkbox' ||
+        candidate.role === 'radio' ||
+        (candidate.role === 'button' && candidate.focusable)));
+    const consumed = new Set();
+    const fields = [];
+    for (const candidate of candidates) {
+        const candidateKey = pathKey(candidate.path);
+        if (consumed.has(candidateKey))
+            continue;
+        if (candidate.role === 'textbox' || candidate.role === 'combobox') {
+            const field = simpleSchemaField(root, candidate);
+            if (field)
+                fields.push(field);
+            consumed.add(candidateKey);
+            continue;
+        }
+        const grouped = groupedChoiceForNode(root, formNode, candidate);
+        if (grouped && grouped.controls.some(control => pathKey(control.path) === candidateKey)) {
+            const field = groupedSchemaField(root, grouped);
+            for (const control of grouped.controls)
+                consumed.add(pathKey(control.path));
+            if (field)
+                fields.push(field);
+            continue;
+        }
+        if (candidate.role === 'checkbox' || candidate.role === 'radio') {
+            const field = toggleSchemaField(root, candidate);
+            if (field)
+                fields.push(field);
+            consumed.add(candidateKey);
+        }
+    }
+    const compactFields = trimSchemaFieldContexts(fields);
+    const filteredFields = compactFields.filter(field => {
+        if (options?.onlyRequiredFields && !field.required)
+            return false;
+        if (options?.onlyInvalidFields && !field.invalid)
+            return false;
+        return true;
+    });
+    const maxFields = options?.maxFields ?? filteredFields.length;
+    const pageFields = filteredFields.slice(0, maxFields);
+    const name = sectionDisplayName(formNode, 'form');
+    return {
+        formId: sectionIdForPath('form', formNode.path),
+        ...(name ? { name } : {}),
+        fieldCount: compactFields.length,
+        requiredCount: compactFields.filter(field => field.required).length,
+        invalidCount: compactFields.filter(field => field.invalid).length,
+        fields: pageFields,
+    };
+}
+function trimSchemaFieldContexts(fields) {
+    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 => {
+        if (!field.context)
+            return field;
+        const trimmed = {};
+        if (field.context.prompt && normalizeUiText(field.context.prompt) !== normalizeUiText(field.label)) {
+            trimmed.prompt = field.context.prompt;
+        }
+        if ((labelCounts.get(normalizeUiText(field.label)) ?? 0) > 1 && field.context.section) {
+            trimmed.section = field.context.section;
+        }
+        if (Object.keys(trimmed).length === 0) {
+            const { context: _context, ...rest } = field;
+            return rest;
+        }
+        return { ...field, context: trimmed };
+    });
+}
 function toLandmarkModel(node) {
     const name = sectionDisplayName(node, 'landmark');
     return {
@@ -991,6 +1226,15 @@ export function buildPageModel(root, options) {
         archetypes: inferPageArchetypes(baseModel),
     };
 }
+export function buildFormSchemas(root, options) {
+    const forms = sortByBounds([
+        ...(root.role === 'form' ? [root] : []),
+        ...collectDescendants(root, candidate => candidate.role === 'form'),
+    ]);
+    return forms
+        .filter(form => !options?.formId || sectionIdForPath('form', form.path) === options.formId)
+        .map(form => buildFormSchemaForNode(root, form, options));
+}
 function headingModels(node, maxHeadings, includeBounds) {
     const headings = sortByBounds(collectDescendants(node, candidate => candidate.role === 'heading' && !!sanitizeInlineName(candidate.name, 80)));
     return headings.slice(0, maxHeadings).map(heading => ({
@@ -1566,6 +1810,7 @@ function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, reques
                         resolve({
                             status: session.updateRevision > startRevision ? 'updated' : 'acknowledged',
                             timeoutMs,
+                            ...(msg.result !== undefined ? { result: msg.result } : {}),
                         });
                     }
                     return;
@@ -1585,7 +1830,11 @@ function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, reques
                 }
                 else if (msg.type === 'ack') {
                     cleanup();
-                    resolve({ status: 'acknowledged', timeoutMs });
+                    resolve({
+                        status: 'acknowledged',
+                        timeoutMs,
+                        ...(msg.result !== undefined ? { result: msg.result } : {}),
+                    });
                 }
             }
             catch { /* ignore */ }

package/package.json

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