imprint-mcp 0.4.3 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imprint-mcp",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Teach an AI agent how to use any website. Once. Records a real browser session + narration; generates a deterministic MCP tool plus a DOM-replay playbook fallback.",
   "type": "module",
   "exports": {

package/src/imprint/mcp-server.ts

@@ -89,6 +89,24 @@ export function buildJsonSchema(parameters: WorkflowParameter[]): Tool['inputSch
 
 const log = createLog('mcp');
 
+export async function runSerializedBySite<T>(
+  queues: Map<string, Promise<void>>,
+  site: string,
+  task: () => Promise<T>,
+): Promise<T> {
+  const previous = queues.get(site) ?? Promise.resolve();
+  const run = previous.catch(() => undefined).then(task);
+  const tail = run.then(
+    () => undefined,
+    () => undefined,
+  );
+  queues.set(site, tail);
+  tail.finally(() => {
+    if (queues.get(site) === tail) queues.delete(site);
+  });
+  return await run;
+}
+
 /** Build the MCP Server with all discovered tools registered. */
 function buildServer(
   name: string,
@@ -127,6 +145,12 @@ function buildServer(
   // cdp-replay and re-pay the ~33s relaunch.
   const winnerCache = new Map<string, ConcreteBackend>();
 
+  // Browser-backed rungs share per-site state (CDP page/session, stealth token,
+  // winner memo, and backend cache). Parallel MCP calls can race that state and
+  // make Google Flights return fast empty result sets. Keep same-site execution
+  // sequential while allowing unrelated sites to proceed independently.
+  const siteExecutionQueues = new Map<string, Promise<void>>();
+
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: tools.map((t) => ({
       name: t.workflow.toolName,
@@ -162,74 +186,76 @@ function buildServer(
       string | number | boolean
     >;
 
-    // Audit-only pacing: when the audit harness sets IMPRINT_AUDIT_PACING_MS,
-    // sleep before each tool call so the auditor's per-parameter differential
-    // probing of bot-defended idempotent reads stays steady enough not to trip
-    // the per-IP anti-bot defense. Unset in production → no delay.
-    const pacingMs = Number(process.env.IMPRINT_AUDIT_PACING_MS);
-    if (Number.isFinite(pacingMs) && pacingMs > 0) {
-      await new Promise((r) => setTimeout(r, pacingMs));
-    }
-
     try {
-      const ladder = resolveLadder('auto', tool.preferredOrder);
-      const { result, usedBackend, attempts } = await runWithLadder(
-        ladder,
-        tool,
-        args,
-        assetRoot,
-        stealthCache,
-        { cdpPool, winnerCache, skipBootstrapSplice: Boolean(tool.preferredOrder?.length) },
-      );
-      // Reset the idle timer for this site's pooled Chrome.
-      if (result.ok && usedBackend === 'cdp-replay' && cdpPool.has(tool.site)) {
-        const prev = cdpIdleTimers.get(tool.site);
-        if (prev) clearTimeout(prev);
-        const timer = setTimeout(() => {
-          const cf = cdpPool.get(tool.site);
-          if (cf) {
-            log(`closing idle CDP session for ${tool.site}`);
-            cf.close().catch(() => {});
-            cdpPool.delete(tool.site);
-            cdpIdleTimers.delete(tool.site);
-            // Drop this site's winner memo too: a memoized cdp-replay would now
-            // point at a closed Chrome and re-pay the cold relaunch.
-            for (const key of winnerCache.keys()) {
-              if (key.startsWith(`${tool.site}:`)) winnerCache.delete(key);
-            }
-          }
-        }, CDP_IDLE_TIMEOUT_MS);
-        timer.unref();
-        cdpIdleTimers.set(tool.site, timer);
-      }
-      if (!result.ok) {
-        const text = formatToolError(result);
-        return {
-          isError: true,
-          content: [{ type: 'text', text: `${text}\n(backend: ${usedBackend})` }],
-        };
-      }
-      try {
-        const cache = persistRuntimeBackendsCache({
+      return await runSerializedBySite(siteExecutionQueues, tool.site, async () => {
+        // Audit-only pacing: when the audit harness sets IMPRINT_AUDIT_PACING_MS,
+        // sleep before each actual workflow execution so same-site queued calls
+        // stay spaced out instead of all waiting concurrently before the queue.
+        // Unset in production -> no delay.
+        const pacingMs = Number(process.env.IMPRINT_AUDIT_PACING_MS);
+        if (Number.isFinite(pacingMs) && pacingMs > 0) {
+          await new Promise((r) => setTimeout(r, pacingMs));
+        }
+
+        const ladder = resolveLadder('auto', tool.preferredOrder);
+        const { result, usedBackend, attempts } = await runWithLadder(
+          ladder,
           tool,
+          args,
           assetRoot,
-          usedBackend,
-          attempts,
-        });
-        if (cache) {
-          tool.preferredOrder = cache.preferredOrder;
+          stealthCache,
+          { cdpPool, winnerCache, skipBootstrapSplice: Boolean(tool.preferredOrder?.length) },
+        );
+        // Reset the idle timer for this site's pooled Chrome.
+        if (result.ok && usedBackend === 'cdp-replay' && cdpPool.has(tool.site)) {
+          const prev = cdpIdleTimers.get(tool.site);
+          if (prev) clearTimeout(prev);
+          const timer = setTimeout(() => {
+            const cf = cdpPool.get(tool.site);
+            if (cf) {
+              log(`closing idle CDP session for ${tool.site}`);
+              cf.close().catch(() => {});
+              cdpPool.delete(tool.site);
+              cdpIdleTimers.delete(tool.site);
+              // Drop this site's winner memo too: a memoized cdp-replay would now
+              // point at a closed Chrome and re-pay the cold relaunch.
+              for (const key of winnerCache.keys()) {
+                if (key.startsWith(`${tool.site}:`)) winnerCache.delete(key);
+              }
+            }
+          }, CDP_IDLE_TIMEOUT_MS);
+          timer.unref();
+          cdpIdleTimers.set(tool.site, timer);
+        }
+        if (!result.ok) {
+          const text = formatToolError(result);
+          return {
+            isError: true,
+            content: [{ type: 'text', text: `${text}\n(backend: ${usedBackend})` }],
+          };
+        }
+        try {
+          const cache = persistRuntimeBackendsCache({
+            tool,
+            assetRoot,
+            usedBackend,
+            attempts,
+          });
+          if (cache) {
+            tool.preferredOrder = cache.preferredOrder;
+            log(
+              `  learned backend order for ${tool.workflow.toolName}: ${cache.preferredOrder.join(' → ')}`,
+            );
+          }
+        } catch (err) {
           log(
-            `  learned backend order for ${tool.workflow.toolName}: ${cache.preferredOrder.join(' → ')}`,
+            `  warning: could not persist backend order for ${tool.workflow.toolName}: ${err instanceof Error ? err.message : String(err)}`,
           );
         }
-      } catch (err) {
-        log(
-          `  warning: could not persist backend order for ${tool.workflow.toolName}: ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
-      const text =
-        typeof result.data === 'string' ? result.data : JSON.stringify(result.data, null, 2);
-      return { content: [{ type: 'text', text: `${text}\n\n(backend: ${usedBackend})` }] };
+        const text =
+          typeof result.data === 'string' ? result.data : JSON.stringify(result.data, null, 2);
+        return { content: [{ type: 'text', text: `${text}\n\n(backend: ${usedBackend})` }] };
+      });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       return { isError: true, content: [{ type: 'text', text: `[INTERNAL] ${msg}` }] };