@geometra/mcp 1.49.0 → 1.53.0

package/dist/session.js

@@ -22,6 +22,7 @@ const FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS = 500;
 const FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS = 225;
 const FILL_BATCH_FILE_FIELD_TIMEOUT_MS = 5000;
 const FILL_BATCH_MAX_TIMEOUT_MS = 60_000;
+const SESSION_RECONNECT_TIMEOUT_MS = 5_000;
 let nextRequestSequence = 0;
 function invalidateSessionCaches(session) {
     session.cachedA11y = null;
@@ -682,6 +683,8 @@ export function connect(url, opts) {
             heartbeatInterval.unref();
         }
         ws.on('pong', () => {
+            if (session.ws !== ws)
+                return;
             lastMessageAt = Date.now();
             pendingPongBy = null;
         });
@@ -693,6 +696,8 @@ export function connect(url, opts) {
             }
         }, 10_000);
         ws.on('open', () => {
+            if (session.ws !== ws)
+                return;
             if (session.connectTrace) {
                 session.connectTrace.wsOpenMs = performance.now() - startedAt;
             }
@@ -715,6 +720,8 @@ export function connect(url, opts) {
             }
         });
         ws.on('message', (data) => {
+            if (session.ws !== ws)
+                return;
             lastMessageAt = Date.now();
             try {
                 const msg = JSON.parse(String(data));
@@ -755,6 +762,8 @@ export function connect(url, opts) {
             }
         });
         ws.on('close', () => {
+            if (session.ws !== ws)
+                return;
             if (heartbeatInterval) {
                 clearInterval(heartbeatInterval);
                 heartbeatInterval = null;
@@ -846,6 +855,19 @@ export function getSession(id) {
         return activeSessions.get(defaultSessionId) ?? null;
     return null;
 }
+export function pruneDisconnectedSessions() {
+    const removedIds = [];
+    for (const [id, session] of activeSessions.entries()) {
+        if (session.ws.readyState === WebSocket.OPEN)
+            continue;
+        removedIds.push(id);
+        activeSessions.delete(id);
+        if (defaultSessionId === id) {
+            promoteDefaultSession();
+        }
+    }
+    return removedIds;
+}
 export function resolveSession(id) {
     if (id) {
         const found = activeSessions.get(id);
@@ -903,6 +925,9 @@ function estimateFillBatchTimeout(fields) {
                 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;
+                if (field.typingDelayMs !== undefined) {
+                    total += field.typingDelayMs * field.value.length;
+                }
                 break;
             case 'choice':
                 total += field.choiceType === 'group' ? FILL_BATCH_TOGGLE_FIELD_TIMEOUT_MS : FILL_BATCH_CHOICE_FIELD_TIMEOUT_MS;
@@ -956,16 +981,128 @@ export function waitForUiCondition(session, predicate, timeoutMs) {
         check();
     });
 }
-function sendResizeAndWaitForUpdate(session, width, height, timeoutMs = 5_000) {
-    return new Promise((resolve, reject) => {
-        if (session.ws.readyState !== WebSocket.OPEN) {
-            reject(new Error('Not connected'));
+function reconnectUrlForSession(session) {
+    if (session.proxyRuntime && typeof session.proxyRuntime.wsUrl === 'string') {
+        return session.proxyRuntime.wsUrl;
+    }
+    const pooled = reusableProxyEntryForSession(session);
+    if (pooled) {
+        return pooled.wsUrl;
+    }
+    if (typeof session.url === 'string' && /^wss?:\/\//i.test(session.url)) {
+        return session.url;
+    }
+    return null;
+}
+async function openWebSocket(url, timeoutMs = SESSION_RECONNECT_TIMEOUT_MS) {
+    return await new Promise((resolve, reject) => {
+        const ws = new WebSocket(url);
+        const timeout = setTimeout(() => {
+            cleanup();
+            try {
+                ws.close();
+            }
+            catch {
+                /* ignore */
+            }
+            reject(new Error(`Reconnect to ${url} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const onOpen = () => {
+            cleanup();
+            resolve(ws);
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(new Error(`WebSocket reconnect failed for ${url}: ${err.message}`));
+        };
+        function cleanup() {
+            clearTimeout(timeout);
+            ws.off('open', onOpen);
+            ws.off('error', onError);
+        }
+        ws.on('open', onOpen);
+        ws.on('error', onError);
+    });
+}
+function bindReconnectedSocket(session, ws) {
+    ws.on('message', data => {
+        if (session.ws !== ws)
             return;
+        try {
+            const msg = JSON.parse(String(data));
+            if (msg.type === 'frame') {
+                session.layout = msg.layout;
+                session.tree = msg.tree;
+                session.updateRevision++;
+                invalidateSessionCaches(session);
+            }
+            else if (msg.type === 'patch' && session.layout) {
+                applyPatches(session.layout, msg.patches);
+                session.updateRevision++;
+                invalidateSessionCaches(session);
+            }
+        }
+        catch {
+            /* ignore malformed messages */
         }
-        const startRevision = session.updateRevision;
-        session.ws.send(JSON.stringify({ type: 'resize', width, height }));
-        waitForNextUpdate(session, timeoutMs, undefined, startRevision).then(resolve).catch(reject);
     });
+    ws.on('close', () => {
+        if (session.ws !== ws)
+            return;
+        if (activeSessions.get(session.id) === session) {
+            activeSessions.delete(session.id);
+            if (defaultSessionId === session.id)
+                promoteDefaultSession();
+        }
+    });
+}
+async function ensureSessionConnected(session) {
+    if (session.ws.readyState === WebSocket.OPEN)
+        return;
+    if (session.reconnectInFlight) {
+        const recovered = await session.reconnectInFlight;
+        if (!recovered) {
+            throw new Error('Not connected');
+        }
+        return;
+    }
+    const targetUrl = reconnectUrlForSession(session);
+    if (!targetUrl) {
+        throw new Error('Not connected');
+    }
+    const reconnectPromise = (async () => {
+        const nextWs = await openWebSocket(targetUrl);
+        try {
+            session.ws.close();
+        }
+        catch {
+            /* ignore */
+        }
+        session.ws = nextWs;
+        bindReconnectedSocket(session, nextWs);
+        activeSessions.set(session.id, session);
+        if (!session.isolated) {
+            defaultSessionId = session.id;
+        }
+        return true;
+    })();
+    session.reconnectInFlight = reconnectPromise;
+    let recovered = false;
+    try {
+        recovered = await reconnectPromise;
+    }
+    finally {
+        session.reconnectInFlight = undefined;
+    }
+    if (!recovered) {
+        throw new Error('Not connected');
+    }
+}
+async function sendResizeAndWaitForUpdate(session, width, height, timeoutMs = 5_000) {
+    await ensureSessionConnected(session);
+    const startRevision = session.updateRevision;
+    session.ws.send(JSON.stringify({ type: 'resize', width, height }));
+    return await waitForNextUpdate(session, timeoutMs, undefined, startRevision);
 }
 /**
  * Send a click event at (x, y) and wait for the next frame/patch response.
@@ -982,11 +1119,8 @@ export function sendClick(session, x, y, timeoutMs) {
  * Send a sequence of key events to type text into the focused element.
  */
 export function sendType(session, text, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        if (session.ws.readyState !== WebSocket.OPEN) {
-            reject(new Error('Not connected'));
-            return;
-        }
+    return (async () => {
+        await ensureSessionConnected(session);
         // Send each character as keydown + keyup
         for (const char of text) {
             const keyEvent = {
@@ -1003,8 +1137,8 @@ export function sendType(session, text, timeoutMs) {
             session.ws.send(JSON.stringify({ ...keyEvent, eventType: 'onKeyUp' }));
         }
         // Wait briefly for server to process and send update
-        waitForNextUpdate(session, timeoutMs).then(resolve).catch(reject);
-    });
+        return await waitForNextUpdate(session, timeoutMs);
+    })();
 }
 /**
  * Send a special key (Enter, Tab, Escape, etc.)
@@ -1054,6 +1188,10 @@ export function sendFieldText(session, fieldLabel, value, opts, timeoutMs) {
         payload.exact = opts.exact;
     if (opts?.fieldId)
         payload.fieldId = opts.fieldId;
+    if (opts?.typingDelayMs !== undefined)
+        payload.typingDelayMs = opts.typingDelayMs;
+    if (opts?.imeFriendly !== undefined)
+        payload.imeFriendly = opts.imeFriendly;
     return sendAndWaitForUpdate(session, payload, timeoutMs);
 }
 /** Choose a value for a labeled choice field (select, custom combobox, or radio-style group). */
@@ -2955,17 +3093,12 @@ function applyPatches(layout, patches) {
             node.height = patch.height;
     }
 }
-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'));
-            return;
-        }
-        const requestId = `req-${++nextRequestSequence}`;
-        const startRevision = session.updateRevision;
-        session.ws.send(JSON.stringify({ ...message, requestId }));
-        waitForNextUpdate(session, timeoutMs, requestId, startRevision, opts).then(resolve).catch(reject);
-    });
+async function sendAndWaitForUpdate(session, message, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, opts) {
+    await ensureSessionConnected(session);
+    const requestId = `req-${++nextRequestSequence}`;
+    const startRevision = session.updateRevision;
+    session.ws.send(JSON.stringify({ ...message, requestId }));
+    return await waitForNextUpdate(session, timeoutMs, requestId, startRevision, opts);
 }
 function waitForNextUpdate(session, timeoutMs = ACTION_UPDATE_TIMEOUT_MS, requestId, startRevision = session.updateRevision, opts) {
     return new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.49.0",
+  "version": "1.53.0",
   "description": "MCP server for Geometra — interact with running Geometra apps via the geometry protocol, no browser needed",
   "license": "MIT",
   "type": "module",