leapfrog-mcp 0.6.7 → 0.6.9

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

@@ -8,7 +8,7 @@ import { generateFingerprint } from "./humanize-fingerprint.js";
 import { isHumanizeEnabled } from "./humanize-utils.js";
 import { CdpConnector } from "./cdp-connector.js";
 import { installSSRFRouteGuard } from "./ssrf.js";
-import { tileManager } from "./tile-manager.js";
+import { tileManager, TileManager } from "./tile-manager.js";
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
@@ -565,13 +565,27 @@ export class SessionManager {
         // Record the screen assignment so reflowAll keeps it on this screen.
         if (isHeaded && !cdpConnected && detectedScreen) {
             tileManager.assignSessionScreen(id, detectedScreen);
+            // Lock viewport for sessions with explicitly-set viewport so reflow
+            // doesn't override it. Unlocked sessions get dynamic viewport sync.
+            if (opts?.viewport) {
+                tileManager.lockViewport(id);
+            }
+            const initialBounds = {
+                x: detectedScreen.x,
+                y: detectedScreen.y,
+                width: Math.min(1280, detectedScreen.width),
+                height: Math.min(720, detectedScreen.height),
+            };
             try {
-                await tileManager.positionWindowWithBounds(page, id, {
-                    x: detectedScreen.x,
-                    y: detectedScreen.y,
-                    width: Math.min(1280, detectedScreen.width),
-                    height: Math.min(720, detectedScreen.height),
-                });
+                await tileManager.positionWindowWithBounds(page, id, initialBounds);
+                // Dynamic viewport sync on initial placement
+                if (!opts?.viewport) {
+                    const viewport = TileManager.calculateViewportFromBounds(initialBounds);
+                    try {
+                        await page.setViewportSize(viewport);
+                    }
+                    catch { }
+                }
             }
             catch (e) {
                 logger.warn("tile.position_failed", { error: e.message });

package/dist/tile-manager.d.ts

@@ -30,6 +30,10 @@ declare class TileManager {
     private windowIds;
     /** Per-session screen assignment — windows stay on the screen where they were created. */
     private sessionScreens;
+    /** Sessions with explicitly-set viewports — reflow won't override these. */
+    private viewportLocked;
+    /** Chrome UI height (tabs, address bar, bookmarks). Subtracted from tile height to get content area. */
+    static CHROME_HEIGHT: number;
     configure(opts: {
         layout: TileLayout;
         padding: number;
@@ -79,6 +83,15 @@ declare class TileManager {
         globalIndex: number;
     }): string[];
     positionWindow(page: Page, sessionId: string): Promise<void>;
+    /** Calculate the page viewport that fits inside a window of the given bounds. */
+    static calculateViewportFromBounds(bounds: TileBounds): {
+        width: number;
+        height: number;
+    };
+    /** Lock a session's viewport so reflow won't override an explicitly-set viewport. */
+    lockViewport(sessionId: string): void;
+    /** Check if a session's viewport is locked. */
+    isViewportLocked(sessionId: string): boolean;
     /** Record which screen a session was placed on so reflows keep it there. */
     assignSessionScreen(sessionId: string, screen: ScreenWorkArea): void;
     /** Get the screen assigned to a session, or the current global screen. */

package/dist/tile-manager.js

@@ -4,7 +4,7 @@
 // Opt-in via LEAP_TILE=true|grid|master env var.
 //
 // Key design:
-//   - Viewport (screenshot resolution) stays at 1280x720 regardless of tile size
+//   - Viewport auto-syncs to tile size during reflow (dynamic viewport)
 //   - Screen detection via page.evaluate() on first headed session, cached
 //   - Accounts for macOS menu bar, Dock, and work area offset
 //   - Launch-time positioning via --window-position/--window-size Chrome args
@@ -23,6 +23,10 @@ class TileManager {
     windowIds = new Map();
     /** Per-session screen assignment — windows stay on the screen where they were created. */
     sessionScreens = new Map();
+    /** Sessions with explicitly-set viewports — reflow won't override these. */
+    viewportLocked = new Set();
+    /** Chrome UI height (tabs, address bar, bookmarks). Subtracted from tile height to get content area. */
+    static CHROME_HEIGHT = process.platform === "darwin" ? 72 : 85;
     // ── Configuration ──────────────────────────────────────────────────
     configure(opts) {
         this.enabled = true;
@@ -317,6 +321,21 @@ if (found) { found; } else {
         // This is a low-level primitive; reflowAll calls it with correct bounds.
         logger.debug("tile.position_window", { sessionId });
     }
+    /** Calculate the page viewport that fits inside a window of the given bounds. */
+    static calculateViewportFromBounds(bounds) {
+        return {
+            width: Math.max(bounds.width, 400),
+            height: Math.max(bounds.height - TileManager.CHROME_HEIGHT, 200),
+        };
+    }
+    /** Lock a session's viewport so reflow won't override an explicitly-set viewport. */
+    lockViewport(sessionId) {
+        this.viewportLocked.add(sessionId);
+    }
+    /** Check if a session's viewport is locked. */
+    isViewportLocked(sessionId) {
+        return this.viewportLocked.has(sessionId);
+    }
     /** Record which screen a session was placed on so reflows keep it there. */
     assignSessionScreen(sessionId, screen) {
         this.sessionScreens.set(sessionId, screen);
@@ -386,6 +405,18 @@ if (found) { found; } else {
                 if (!page || page.isClosed())
                     return;
                 await this.positionWindowWithBounds(page, id, bounds);
+                // Dynamic viewport sync — resize page viewport to match tile content area.
+                // Skip sessions where user explicitly set a viewport (viewport-locked).
+                if (!this.viewportLocked.has(id)) {
+                    const viewport = TileManager.calculateViewportFromBounds(bounds);
+                    try {
+                        await page.setViewportSize(viewport);
+                        logger.debug("tile.viewport_synced", { id, ...viewport });
+                    }
+                    catch {
+                        // Viewport sync is non-fatal
+                    }
+                }
             });
         }));
         // Bring all windows to front after positioning
@@ -416,6 +447,7 @@ if (found) { found; } else {
     removeSession(sessionId) {
         this.windowIds.delete(sessionId);
         this.sessionScreens.delete(sessionId);
+        this.viewportLocked.delete(sessionId);
     }
 }
 export const tileManager = new TileManager();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leapfrog-mcp",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "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",