leapfrog-mcp 0.6.5 → 0.6.8

package/dist/index.js

@@ -347,6 +347,105 @@ server.registerTool("session_create", {
         return err(e.message);
     }
 });
+// ─── session_create_batch ────────────────────────────────────────────────────
+server.registerTool("session_create_batch", {
+    title: "Create Multiple Browser Sessions",
+    description: "Create multiple isolated browser sessions concurrently — 5-10x faster than sequential session_create calls. " +
+        "Optionally navigate each to a URL. Returns all session IDs. " +
+        "A single reflow positions all windows into a unified grid after all sessions are created.",
+    inputSchema: z.object({
+        sessions: z.array(z.object({
+            url: z.string().optional().describe("URL to navigate after creation."),
+            headed: z.boolean().optional().describe("Run with visible UI."),
+            viewport: z.object({ width: z.number(), height: z.number() }).optional().describe("Custom viewport."),
+            profile: z.string().optional().describe("Profile shorthand name for persistent Chrome profile."),
+            pinned: z.boolean().optional().describe("Pin to prevent idle timeout."),
+            waitUntil: z.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("Wait strategy for navigation."),
+        })).min(1).max(15).describe("Array of sessions to create."),
+    }).strict(),
+}, async ({ sessions: sessionSpecs }) => {
+    try {
+        const results = [];
+        // Phase 1: Create all sessions concurrently
+        const createPromises = sessionSpecs.map(async (spec) => {
+            try {
+                const session = await sessions.createSession({
+                    headed: spec.headed,
+                    viewport: spec.viewport,
+                    profile: spec.profile,
+                });
+                if (spec.pinned)
+                    session.pinned = true;
+                // Inject init scripts
+                if (LEAP_HUD)
+                    await session.context.addInitScript(getHUDInitScript(session.name ?? session.id));
+                if (LEAP_AUTO_CONSENT)
+                    await session.context.addInitScript(getConsentDismissScript());
+                await session.context.addInitScript(getDetectionInitScript());
+                if (LEAP_TRACE)
+                    await session.context.tracing.start({ screenshots: true, snapshots: true });
+                // Claim tile slot (without triggering reflow yet — watcher handles it)
+                if (tilesCoord) {
+                    const detected = tileManager.getScreenSize();
+                    if (detected)
+                        await tilesCoord.updateScreenSize(detected.width, detected.height).catch(() => { });
+                    await tilesCoord.claimSlot(session.id).catch(() => { });
+                }
+                return { session, spec };
+            }
+            catch (e) {
+                return { error: e.message, spec };
+            }
+        });
+        const created = await Promise.all(createPromises);
+        // Phase 2: Navigate sessions that have URLs (concurrently)
+        const navPromises = created.map(async (result) => {
+            if ("error" in result && result.error) {
+                results.push({ id: "(failed)", url: result.spec.url, error: result.error });
+                return;
+            }
+            const { session, spec } = result;
+            if (spec.url) {
+                try {
+                    const parsed = new URL(spec.url);
+                    if (!["http:", "https:"].includes(parsed.protocol)) {
+                        results.push({ id: session.id, error: `Blocked URL scheme: ${parsed.protocol}` });
+                        return;
+                    }
+                    const ssrfBlock = await checkSSRF(parsed.hostname);
+                    if (ssrfBlock) {
+                        results.push({ id: session.id, error: ssrfBlock });
+                        return;
+                    }
+                    await session.page.goto(spec.url, {
+                        waitUntil: spec.waitUntil || "load",
+                        timeout: 30000,
+                    });
+                    results.push({ id: session.id, url: spec.url });
+                }
+                catch (e) {
+                    results.push({ id: session.id, url: spec.url, error: e.message });
+                }
+            }
+            else {
+                results.push({ id: session.id });
+            }
+        });
+        await Promise.all(navPromises);
+        // Phase 3: Single global reflow
+        await reflowWithContext().catch(() => { });
+        const stats = sessions.getStats();
+        const lines = results.map((r) => r.error
+            ? `${r.id} — ERROR: ${r.error}`
+            : `${r.id}${r.url ? ` → ${r.url}` : ""}`);
+        return ok(`Created ${results.filter((r) => !r.error).length}/${sessionSpecs.length} sessions\n` +
+            `Pool: ${stats.active}/${stats.maxSessions} active\n\n` +
+            lines.join("\n"));
+    }
+    catch (e) {
+        return err(e.message);
+    }
+});
 // ─── session_list ───────────────────────────────────────────────────────────
 server.registerTool("session_list", {
     title: "List Browser Sessions",

package/dist/session-manager.js

@@ -577,22 +577,9 @@ export class SessionManager {
                 logger.warn("tile.position_failed", { error: e.message });
             }
         }
-        // ── Debounced reflow after creation (Windows only) ─────────────
-        // On Windows, launch args position each window for a grid that includes
-        // only the sessions created so far. Earlier windows end up at stale positions.
-        // Reflow all after a 500ms debounce so rapid batch creates settle into one reflow.
-        // Skipped on macOS where CDP reflow can move windows to the wrong screen.
-        if (process.platform === "win32" && tileManager.isEnabled() && this.sessions.size > 1) {
-            clearTimeout(globalThis.__leapReflowTimer);
-            globalThis.__leapReflowTimer = setTimeout(async () => {
-                try {
-                    await tileManager.reflowAll(this.sessions);
-                }
-                catch (e) {
-                    logger.warn("tile.reflow_after_create_failed", { error: e.message });
-                }
-            }, 500);
-        }
+        // Reflow is handled by the TilesCoordinator file watcher in index.ts,
+        // which calls reflowWithContext() with global multi-terminal grid state.
+        // A local-only reflowAll here would override the global grid positions.
         // ── Auto-reflow on external close ──────────────────────────────
         // When the user manually closes a browser window (X button), clean up
         // the session and reflow remaining tiled windows. Without this, closing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leapfrog-mcp",
-  "version": "0.6.5",
+  "version": "0.6.8",
   "description": "Multi-session browser MCP for AI agents — 36 tools, stealth, persistent auth, code-first scripts, API sniffer, agent intelligence",
   "type": "module",
   "main": "dist/index.js",