@geometra/mcp 1.19.11 → 1.19.13

package/dist/__tests__/session-model.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { buildA11yTree, buildCompactUiIndex, buildPageModel, expandPageSection, buildUiDelta, hasUiDelta, summarizeUiDelta, } from '../session.js';
+import { buildA11yTree, buildCompactUiIndex, buildFormSchemas, buildPageModel, expandPageSection, buildUiDelta, hasUiDelta, summarizeUiDelta, } from '../session.js';
 function node(role, name, bounds, options) {
     return {
         role,
@@ -115,17 +115,117 @@ describe('buildPageModel', () => {
             summary: {
                 headingCount: 1,
                 fieldCount: 2,
+                requiredFieldCount: 2,
+                invalidFieldCount: 1,
                 actionCount: 1,
             },
+            page: {
+                fields: { offset: 0, returned: 2, total: 2, hasMore: false },
+                actions: { offset: 0, returned: 1, total: 1, hasMore: false },
+            },
         });
         expect(detail?.fields.map(field => field.name)).toEqual(['Full name', 'Email']);
         expect(detail?.fields.map(field => field.value)).toEqual(['Taylor Applicant', 'taylor@example.com']);
         expect(detail?.fields[0]?.state).toEqual({ required: true });
         expect(detail?.fields[1]?.state).toEqual({ invalid: true, required: true });
         expect(detail?.fields[1]?.validation).toEqual({ error: 'Please enter a valid email address.' });
+        expect(detail?.fields[1]?.visibility).toMatchObject({ intersectsViewport: true, fullyVisible: true });
+        expect(detail?.actions[0]?.scrollHint).toMatchObject({ status: 'visible' });
         expect(detail?.actions.map(action => action.id)).toEqual(['n:0.0.3']);
         expect(detail?.fields[0]).not.toHaveProperty('bounds');
     });
+    it('paginates long sections and carries context on repeated answers', () => {
+        const tree = node('group', undefined, { x: 0, y: 0, width: 900, height: 700 }, {
+            children: [
+                node('form', 'Application', { x: 20, y: -120, width: 760, height: 1800 }, {
+                    path: [0],
+                    children: [
+                        node('heading', 'Application', { x: 40, y: 40, width: 240, height: 28 }, { path: [0, 0] }),
+                        node('textbox', 'Full name', { x: 48, y: 120, width: 320, height: 36 }, {
+                            path: [0, 1],
+                            state: { required: true },
+                        }),
+                        node('textbox', 'Email', { x: 48, y: 176, width: 320, height: 36 }, {
+                            path: [0, 2],
+                            state: { required: true, invalid: true },
+                            validation: { error: 'Enter a valid email.' },
+                        }),
+                        node('textbox', 'Phone', { x: 48, y: 232, width: 320, height: 36 }, {
+                            path: [0, 3],
+                            state: { required: true },
+                        }),
+                        node('group', undefined, { x: 40, y: 980, width: 520, height: 96 }, {
+                            path: [0, 4],
+                            children: [
+                                node('text', 'Are you legally authorized to work here?', { x: 48, y: 980, width: 340, height: 24 }, {
+                                    path: [0, 4, 0],
+                                }),
+                                node('button', 'Yes', { x: 48, y: 1020, width: 88, height: 40 }, {
+                                    path: [0, 4, 1],
+                                    focusable: true,
+                                }),
+                                node('button', 'No', { x: 148, y: 1020, width: 88, height: 40 }, {
+                                    path: [0, 4, 2],
+                                    focusable: true,
+                                }),
+                            ],
+                        }),
+                        node('group', undefined, { x: 40, y: 1120, width: 520, height: 96 }, {
+                            path: [0, 5],
+                            children: [
+                                node('text', 'Will you require sponsorship?', { x: 48, y: 1120, width: 260, height: 24 }, {
+                                    path: [0, 5, 0],
+                                }),
+                                node('button', 'Yes', { x: 48, y: 1160, width: 88, height: 40 }, {
+                                    path: [0, 5, 1],
+                                    focusable: true,
+                                }),
+                                node('button', 'No', { x: 148, y: 1160, width: 88, height: 40 }, {
+                                    path: [0, 5, 2],
+                                    focusable: true,
+                                }),
+                            ],
+                        }),
+                        node('button', 'Submit application', { x: 48, y: 1540, width: 180, height: 40 }, {
+                            path: [0, 6],
+                            focusable: true,
+                        }),
+                    ],
+                }),
+            ],
+        });
+        const detail = expandPageSection(tree, 'fm:0', {
+            maxFields: 2,
+            fieldOffset: 1,
+            onlyRequiredFields: true,
+        });
+        expect(detail).toMatchObject({
+            summary: {
+                fieldCount: 3,
+                requiredFieldCount: 3,
+                invalidFieldCount: 1,
+                actionCount: 5,
+            },
+            page: {
+                fields: { offset: 1, returned: 2, total: 3, hasMore: false },
+                actions: { offset: 0, returned: 5, total: 5, hasMore: false },
+            },
+        });
+        expect(detail?.fields.map(field => field.name)).toEqual(['Email', 'Phone']);
+        expect(detail?.fields[0]?.scrollHint).toMatchObject({ status: 'visible' });
+        const authorizedYes = detail?.actions.find(action => action.name === 'Yes' && action.context?.prompt === 'Are you legally authorized to work here?');
+        const sponsorshipYes = detail?.actions.find(action => action.name === 'Yes' && action.context?.prompt === 'Will you require sponsorship?');
+        expect(authorizedYes).toMatchObject({
+            name: 'Yes',
+            context: { prompt: 'Are you legally authorized to work here?', section: 'Application' },
+            visibility: { fullyVisible: false, offscreenBelow: true },
+        });
+        expect(sponsorshipYes).toMatchObject({
+            name: 'Yes',
+            context: { prompt: 'Will you require sponsorship?', section: 'Application' },
+            visibility: { fullyVisible: false, offscreenBelow: true },
+        });
+    });
     it('drops noisy container names and falls back to unnamed summaries', () => {
         const tree = node('group', undefined, { x: 0, y: 0, width: 800, height: 600 }, {
             children: [
@@ -137,6 +237,135 @@ describe('buildPageModel', () => {
         expect(model.forms[0]?.name).toBeUndefined();
     });
 });
+describe('buildFormSchemas', () => {
+    it('builds a compact fill-oriented schema and collapses repeated answer groups', () => {
+        const longEssay = 'Semantic browser automation should be reliable, compact, and predictable across large forms.';
+        const tree = node('group', undefined, { x: 0, y: 0, width: 1024, height: 768 }, {
+            children: [
+                node('form', 'Application', { x: 32, y: 32, width: 760, height: 1500 }, {
+                    path: [0],
+                    children: [
+                        node('textbox', 'Full name', { x: 48, y: 120, width: 320, height: 36 }, {
+                            path: [0, 0],
+                            state: { required: true },
+                        }),
+                        node('combobox', 'Preferred location', { x: 48, y: 180, width: 320, height: 36 }, {
+                            path: [0, 1],
+                            state: { required: true },
+                            value: 'Berlin, Germany',
+                        }),
+                        node('group', undefined, { x: 40, y: 260, width: 520, height: 96 }, {
+                            path: [0, 2],
+                            children: [
+                                node('text', 'Are you legally authorized to work in Germany?', { x: 48, y: 260, width: 360, height: 24 }, {
+                                    path: [0, 2, 0],
+                                }),
+                                node('button', 'Yes', { x: 48, y: 300, width: 88, height: 40 }, {
+                                    path: [0, 2, 1],
+                                    focusable: true,
+                                    state: { required: true },
+                                }),
+                                node('button', 'No', { x: 148, y: 300, width: 88, height: 40 }, {
+                                    path: [0, 2, 2],
+                                    focusable: true,
+                                }),
+                            ],
+                        }),
+                        node('checkbox', 'Share my profile for future roles', { x: 48, y: 400, width: 24, height: 24 }, {
+                            path: [0, 3],
+                            focusable: true,
+                            state: { checked: true },
+                        }),
+                        node('textbox', 'Why Geometra?', { x: 48, y: 480, width: 520, height: 180 }, {
+                            path: [0, 4],
+                            state: { required: true, invalid: true },
+                            validation: { error: 'Please enter at least 40 characters.' },
+                            value: longEssay,
+                        }),
+                    ],
+                }),
+            ],
+        });
+        const schemas = buildFormSchemas(tree);
+        expect(schemas).toHaveLength(1);
+        expect(schemas[0]).toMatchObject({
+            formId: 'fm:0',
+            name: 'Application',
+            fieldCount: 5,
+            requiredCount: 4,
+            invalidCount: 1,
+        });
+        expect(schemas[0]?.fields).toEqual([
+            expect.objectContaining({
+                kind: 'text',
+                label: 'Full name',
+                required: true,
+            }),
+            expect.objectContaining({
+                kind: 'choice',
+                label: 'Preferred location',
+                required: true,
+                value: 'Berlin, Germany',
+            }),
+            expect.objectContaining({
+                kind: 'choice',
+                label: 'Are you legally authorized to work in Germany?',
+                required: true,
+                optionCount: 2,
+                options: ['Yes', 'No'],
+            }),
+            expect.objectContaining({
+                kind: 'toggle',
+                label: 'Share my profile for future roles',
+                checked: true,
+                controlType: 'checkbox',
+            }),
+            expect.objectContaining({
+                kind: 'text',
+                label: 'Why Geometra?',
+                required: true,
+                invalid: true,
+                valueLength: longEssay.length,
+            }),
+        ]);
+    });
+    it('prefers question prompts over nearby explanatory copy for grouped choices', () => {
+        const tree = node('group', undefined, { x: 0, y: 0, width: 900, height: 700 }, {
+            children: [
+                node('form', 'Application', { x: 20, y: 20, width: 760, height: 480 }, {
+                    path: [0],
+                    children: [
+                        node('group', undefined, { x: 32, y: 80, width: 520, height: 120 }, {
+                            path: [0, 0],
+                            children: [
+                                node('text', 'Will you now or in the future require sponsorship?', { x: 40, y: 80, width: 420, height: 24 }, {
+                                    path: [0, 0, 0],
+                                }),
+                                node('text', 'This intentionally repeats Yes / No labels to test contextual disambiguation.', { x: 40, y: 112, width: 520, height: 24 }, {
+                                    path: [0, 0, 1],
+                                }),
+                                node('button', 'Yes', { x: 40, y: 152, width: 88, height: 40 }, {
+                                    path: [0, 0, 2],
+                                    focusable: true,
+                                }),
+                                node('button', 'No', { x: 140, y: 152, width: 88, height: 40 }, {
+                                    path: [0, 0, 3],
+                                    focusable: true,
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            ],
+        });
+        const schema = buildFormSchemas(tree)[0];
+        expect(schema?.fields[0]).toMatchObject({
+            kind: 'choice',
+            label: 'Will you now or in the future require sponsorship?',
+            options: ['Yes', 'No'],
+        });
+    });
+});
 describe('buildUiDelta', () => {
     it('captures opened dialogs, state changes, and list count changes', () => {
         const before = node('group', undefined, { x: 0, y: 0, width: 1024, height: 768 }, {

package/dist/proxy-spawn.js

@@ -1,5 +1,5 @@
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+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';
@@ -13,9 +13,34 @@ export function resolveProxyScriptPath() {
 }
 export function resolveProxyScriptPathWith(customRequire, moduleDir = MODULE_DIR) {
     const errors = [];
+    const workspaceDist = path.resolve(moduleDir, '../../packages/proxy/dist/index.js');
+    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');
+        if (existsSync(packagedDist))
+            return packagedDist;
+        const builtLocalDist = buildLocalProxyDistIfPossible(packageDir, errors);
+        if (builtLocalDist)
+            return builtLocalDist;
+        errors.push(`Resolved @geometra/proxy package at ${packageDir}, but dist/index.js was missing`);
+    }
+    else {
+        errors.push('Could not find @geometra/proxy/package.json via Node module search paths');
+    }
     try {
         const pkgJson = customRequire.resolve('@geometra/proxy/package.json');
-        return path.join(path.dirname(pkgJson), 'dist/index.js');
+        const exportPackageDir = path.dirname(pkgJson);
+        const packagedDist = path.join(exportPackageDir, 'dist/index.js');
+        if (existsSync(packagedDist))
+            return packagedDist;
+        const builtLocalDist = buildLocalProxyDistIfPossible(exportPackageDir, errors);
+        if (builtLocalDist)
+            return builtLocalDist;
+        errors.push(`Resolved @geometra/proxy/package.json at ${pkgJson}, but dist/index.js was missing`);
     }
     catch (err) {
         errors.push(err instanceof Error ? err.message : String(err));
@@ -31,13 +56,64 @@ export function resolveProxyScriptPathWith(customRequire, moduleDir = MODULE_DIR
         return packagedSiblingDist;
     }
     errors.push(`Packaged sibling fallback not found at ${packagedSiblingDist}`);
-    const workspaceDist = path.resolve(moduleDir, '../../packages/proxy/dist/index.js');
     if (existsSync(workspaceDist)) {
         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(' | ')}`);
 }
+function resolveProxyPackageDir(customRequire) {
+    const searchRoots = customRequire.resolve.paths('@geometra/proxy') ?? [];
+    for (const searchRoot of searchRoots) {
+        const packageDir = path.join(searchRoot, '@geometra', 'proxy');
+        if (existsSync(path.join(packageDir, 'package.json')))
+            return packageDir;
+    }
+    return undefined;
+}
+function shouldPreferWorkspaceDist(packageDir, bundledDependencyDir) {
+    try {
+        return realpathSync(packageDir) === realpathSync(bundledDependencyDir);
+    }
+    catch {
+        return false;
+    }
+}
+function buildLocalProxyDistIfPossible(packageDir, errors) {
+    const distEntry = path.join(packageDir, 'dist/index.js');
+    const sourceEntry = path.join(packageDir, 'src/index.ts');
+    const tsconfigPath = path.join(packageDir, 'tsconfig.build.json');
+    if (!existsSync(sourceEntry) || !existsSync(tsconfigPath)) {
+        return undefined;
+    }
+    try {
+        const realPackageDir = realpathSync(packageDir);
+        const realTsconfigPath = path.join(realPackageDir, 'tsconfig.build.json');
+        const realDistDir = path.join(realPackageDir, 'dist');
+        const tscBin = require.resolve('typescript/bin/tsc');
+        rmSync(realDistDir, { recursive: true, force: true });
+        const result = spawnSync(process.execPath, [tscBin, '-p', realTsconfigPath], {
+            cwd: realPackageDir,
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        if (result.status !== 0) {
+            const detail = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+            errors.push(`Failed to build local @geometra/proxy at ${realPackageDir}: ${detail || `exit ${result.status ?? 'unknown'}`}`);
+            return undefined;
+        }
+        if (existsSync(distEntry))
+            return distEntry;
+        const realDistEntry = path.join(realPackageDir, 'dist/index.js');
+        if (existsSync(realDistEntry))
+            return realDistEntry;
+        errors.push(`Built local @geometra/proxy at ${realPackageDir}, but dist/index.js is still missing`);
+    }
+    catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+    }
+    return undefined;
+}
 export function parseProxyReadySignalLine(line) {
     const trimmed = line.trim();
     if (!trimmed)

package/dist/server.d.ts

@@ -6,6 +6,7 @@ interface NodeFilter {
     role?: string;
     name?: string;
     text?: string;
+    contextText?: string;
     value?: string;
     checked?: NodeStateFilterValue;
     disabled?: boolean;