@godscene/web 1.7.11

package/dist/es/cli-options.mjs

@@ -0,0 +1,97 @@
+import { CLIError } from "@godscene/shared/cli";
+import { defaultPuppeteerWindowViewportSize, resolveViewportSize } from "./common/viewport.mjs";
+const viewportWidthFlag = '--viewport-width';
+const viewportHeightFlag = '--viewport-height';
+function isLikelyCdpEndpoint(value) {
+    return !!value && /^(wss?):\/\//.test(value);
+}
+function parsePositiveIntegerOption(flag, rawValue) {
+    const value = Number(rawValue);
+    if (!Number.isInteger(value) || value <= 0) throw new CLIError(`Invalid value for "${flag}": expected a positive integer, got "${rawValue}".`);
+    return value;
+}
+function readRequiredOptionValue(args, index, flag) {
+    const currentArg = args[index];
+    const inlinePrefix = `${flag}=`;
+    if (currentArg.startsWith(inlinePrefix)) return {
+        value: currentArg.slice(inlinePrefix.length),
+        nextIndex: index
+    };
+    const nextArg = args[index + 1];
+    if (!nextArg || nextArg.startsWith('--')) throw new CLIError(`Option "${flag}" requires a value.`);
+    return {
+        value: nextArg,
+        nextIndex: index + 1
+    };
+}
+function readOptionalCdpEndpoint(args, index) {
+    const currentArg = args[index];
+    const inlinePrefix = '--cdp=';
+    if (currentArg.startsWith(inlinePrefix)) return {
+        value: currentArg.slice(inlinePrefix.length),
+        nextIndex: index
+    };
+    const nextArg = args[index + 1];
+    if (!isLikelyCdpEndpoint(nextArg)) return {
+        nextIndex: index
+    };
+    return {
+        value: nextArg,
+        nextIndex: index + 1
+    };
+}
+function parseWebCliOptions(rawArgs, env = process.env) {
+    const argv = [];
+    let isBridge = false;
+    let isCdp = false;
+    let viewportWidth;
+    let viewportHeight;
+    let cdpEndpoint;
+    for(let index = 0; index < rawArgs.length; index += 1){
+        const arg = rawArgs[index];
+        if ('--bridge' === arg) {
+            isBridge = true;
+            continue;
+        }
+        if ('--cdp' === arg || arg.startsWith('--cdp=')) {
+            isCdp = true;
+            const parsed = readOptionalCdpEndpoint(rawArgs, index);
+            cdpEndpoint = parsed.value ?? cdpEndpoint;
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (arg === viewportWidthFlag || arg.startsWith(`${viewportWidthFlag}=`)) {
+            const parsed = readRequiredOptionValue(rawArgs, index, viewportWidthFlag);
+            viewportWidth = parsePositiveIntegerOption(viewportWidthFlag, parsed.value);
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (arg === viewportHeightFlag || arg.startsWith(`${viewportHeightFlag}=`)) {
+            const parsed = readRequiredOptionValue(rawArgs, index, viewportHeightFlag);
+            viewportHeight = parsePositiveIntegerOption(viewportHeightFlag, parsed.value);
+            index = parsed.nextIndex;
+            continue;
+        }
+        argv.push(arg);
+    }
+    if (isBridge && isCdp) throw new CLIError('--bridge and --cdp are mutually exclusive. Please specify only one.');
+    const mode = isBridge ? 'bridge' : isCdp ? 'cdp' : 'puppeteer';
+    if ('puppeteer' !== mode) {
+        if (void 0 !== viewportWidth || void 0 !== viewportHeight) throw new CLIError('Viewport options are only supported in the default Puppeteer mode.');
+    }
+    if ('cdp' === mode) {
+        cdpEndpoint = cdpEndpoint ?? env.MIDSCENE_CDP_ENDPOINT;
+        if (!cdpEndpoint) throw new CLIError('CDP endpoint is required. Provide it as: --cdp <ws-endpoint> or set MIDSCENE_CDP_ENDPOINT environment variable.');
+    }
+    const hasViewportOverride = void 0 !== viewportWidth || void 0 !== viewportHeight;
+    return {
+        argv,
+        mode,
+        cdpEndpoint,
+        viewport: hasViewportOverride ? resolveViewportSize({
+            width: viewportWidth,
+            height: viewportHeight
+        }, defaultPuppeteerWindowViewportSize) : void 0
+    };
+}
+export { parseWebCliOptions };

package/dist/es/cli.mjs

@@ -0,0 +1,26 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createReportCliCommands } from "@godscene/core";
+import { reportCLIError, runToolsCLI } from "@godscene/shared/cli";
+import dotenv from "dotenv";
+import { parseWebCliOptions } from "./cli-options.mjs";
+import { WebMidsceneTools } from "./mcp-tools.mjs";
+import { WebCdpMidsceneTools } from "./mcp-tools-cdp.mjs";
+import { WebPuppeteerMidsceneTools } from "./mcp-tools-puppeteer.mjs";
+const envFile = join(process.cwd(), '.env');
+if (existsSync(envFile)) dotenv.config({
+    path: envFile
+});
+Promise.resolve().then(()=>{
+    const parsedOptions = parseWebCliOptions(process.argv.slice(2));
+    let tools;
+    tools = 'bridge' === parsedOptions.mode ? new WebMidsceneTools() : 'cdp' === parsedOptions.mode ? new WebCdpMidsceneTools(parsedOptions.cdpEndpoint) : new WebPuppeteerMidsceneTools(parsedOptions.viewport);
+    return runToolsCLI(tools, 'midscene-web', {
+        stripPrefix: 'web_',
+        argv: parsedOptions.argv,
+        version: "1.7.10",
+        extraCommands: createReportCliCommands()
+    });
+}).catch((e)=>{
+    process.exit(reportCLIError(e));
+});

package/dist/es/common/cache-helper.mjs

@@ -0,0 +1,26 @@
+import { AiJudgeOrderSensitive, callAIWithObjectResponse } from "@godscene/core/ai-model";
+const sanitizeXpaths = (xpaths)=>{
+    if (!Array.isArray(xpaths)) return [];
+    return xpaths.filter((xpath)=>'string' == typeof xpath && xpath.length > 0);
+};
+async function judgeOrderSensitive(options, debug) {
+    if (!options?.targetDescription || !options?.modelConfig) return false;
+    try {
+        const judgeResult = await AiJudgeOrderSensitive(options.targetDescription, callAIWithObjectResponse, options.modelConfig);
+        debug("judged isOrderSensitive=%s for description: %s", judgeResult.isOrderSensitive, options.targetDescription);
+        return judgeResult.isOrderSensitive;
+    } catch (error) {
+        debug('Failed to judge isOrderSensitive: %O', error);
+        return false;
+    }
+}
+function buildRectFromElementInfo(elementInfo) {
+    const matchedRect = {
+        left: elementInfo.rect.left,
+        top: elementInfo.rect.top,
+        width: elementInfo.rect.width,
+        height: elementInfo.rect.height
+    };
+    return matchedRect;
+}
+export { buildRectFromElementInfo, judgeOrderSensitive, sanitizeXpaths };

package/dist/es/common/viewport.mjs

@@ -0,0 +1,36 @@
+import { assert } from "@godscene/shared/utils";
+const defaultViewportWidth = 1440;
+const defaultViewportHeight = 800;
+const defaultViewportSize = {
+    width: defaultViewportWidth,
+    height: defaultViewportHeight
+};
+const defaultPuppeteerWindowViewportSize = {
+    width: defaultViewportWidth,
+    height: defaultViewportHeight
+};
+const defaultStaticPageViewportSize = {
+    width: defaultViewportWidth,
+    height: defaultViewportHeight
+};
+function parseViewportDimension(rawValue, name) {
+    const parsedValue = 'number' == typeof rawValue ? rawValue : Number(rawValue);
+    assert(Number.isInteger(parsedValue), `${name} must be a positive integer, but got ${rawValue}`);
+    assert(parsedValue > 0, `${name} must be greater than 0, but got ${rawValue}`);
+    return parsedValue;
+}
+function resolveViewportSize(viewport, fallback = defaultViewportSize) {
+    const width = viewport?.width === void 0 || null === viewport.width ? fallback.width : parseViewportDimension(viewport.width, 'viewportWidth');
+    const height = viewport?.height === void 0 || null === viewport.height ? fallback.height : parseViewportDimension(viewport.height, 'viewportHeight');
+    return {
+        width,
+        height
+    };
+}
+function resolveWebViewportSize(viewport, fallback = defaultViewportSize) {
+    return resolveViewportSize({
+        width: viewport?.viewportWidth,
+        height: viewport?.viewportHeight
+    }, fallback);
+}
+export { defaultPuppeteerWindowViewportSize, defaultStaticPageViewportSize, defaultViewportHeight, defaultViewportSize, defaultViewportWidth, resolveViewportSize, resolveWebViewportSize };

package/dist/es/index.mjs

@@ -0,0 +1,8 @@
+import { PlaywrightAgent, PlaywrightAiFixture } from "./playwright/index.mjs";
+import { Agent } from "@godscene/core/agent";
+import { PuppeteerAgent } from "./puppeteer/index.mjs";
+import { StaticPage, StaticPageAgent } from "./static/index.mjs";
+import { WebMidsceneTools } from "./mcp-tools.mjs";
+import { webPlaygroundPlatform } from "./platform.mjs";
+import { WebCdpMidsceneTools } from "./mcp-tools-cdp.mjs";
+export { Agent as PageAgent, PlaywrightAgent, PlaywrightAiFixture, PuppeteerAgent, StaticPage, StaticPageAgent, WebCdpMidsceneTools, WebMidsceneTools, webPlaygroundPlatform };

package/dist/es/mcp-server.mjs

@@ -0,0 +1,33 @@
+import { BaseMCPServer, createMCPServerLauncher } from "@godscene/shared/mcp";
+import { WebMidsceneTools } from "./mcp-tools.mjs";
+class WebMCPServer extends BaseMCPServer {
+    createToolsManager() {
+        return new WebMidsceneTools();
+    }
+    constructor(toolsManager){
+        super({
+            name: '@godscene/web-bridge-mcp',
+            version: "1.7.10",
+            description: 'Control the browser using natural language commands'
+        }, toolsManager);
+    }
+}
+function mcpServerForAgent(agent) {
+    return createMCPServerLauncher({
+        agent,
+        platformName: 'Web',
+        ToolsManagerClass: WebMidsceneTools,
+        MCPServerClass: WebMCPServer
+    });
+}
+async function mcpKitForAgent(agent) {
+    const toolsManager = new WebMidsceneTools();
+    const webAgent = agent;
+    toolsManager.setAgent(webAgent);
+    await toolsManager.initTools();
+    return {
+        description: 'Midscene Bridge MCP Server: Control the browser using natural language commands for navigation, clicking, input, hovering, screenshots waitFor, and achieving goals.',
+        tools: toolsManager.getToolDefinitions()
+    };
+}
+export { WebMCPServer, mcpKitForAgent, mcpServerForAgent };

package/dist/es/mcp-tools-cdp.mjs

@@ -0,0 +1,164 @@
+import { ScreenshotItem, z } from "@godscene/core";
+import { getDebug } from "@godscene/shared/logger";
+import { BaseMidsceneTools } from "@godscene/shared/mcp/base-tools";
+import puppeteer_core from "puppeteer-core";
+import { getProxyEndpoint } from "./cdp-proxy-manager.mjs";
+import { cleanupTargetIdFile, readSavedTargetId, saveTargetId } from "./cdp-target-store.mjs";
+import { defaultStaticPageViewportSize } from "./common/viewport.mjs";
+import { PuppeteerAgent } from "./puppeteer/index.mjs";
+import { StaticPage } from "./static/index.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const debug = getDebug('mcp:cdp');
+const CDP_TARGET_DISCOVERY_DELAY_MS = 500;
+function getTargetId(page) {
+    return page.target()._targetId;
+}
+class WebCdpMidsceneTools extends BaseMidsceneTools {
+    getCliReportSessionName() {
+        return 'midscene-web';
+    }
+    createTemporaryDevice() {
+        return new StaticPage({
+            screenshot: ScreenshotItem.create('', Date.now()),
+            shotSize: defaultStaticPageViewportSize,
+            shrunkShotToLogicalRatio: 1
+        });
+    }
+    async ensureAgent(navigateToUrl) {
+        if (this.agent && navigateToUrl) {
+            try {
+                await this.agent?.destroy?.();
+            } catch (error) {
+                console.debug('Failed to destroy agent during re-init:', error);
+            }
+            this.agent = void 0;
+        }
+        if (this.agent) return this.agent;
+        if (!this.activeBrowser) {
+            const endpoint = await getProxyEndpoint(this.cdpEndpoint);
+            this.activeBrowser = await puppeteer_core.connect({
+                browserWSEndpoint: endpoint,
+                defaultViewport: null
+            });
+        }
+        const browser = this.activeBrowser;
+        let pages = await browser.pages();
+        if (0 === pages.length) {
+            await new Promise((r)=>setTimeout(r, CDP_TARGET_DISCOVERY_DELAY_MS));
+            pages = await browser.pages();
+        }
+        const webPages = pages.filter((p)=>/^https?:\/\//.test(p.url()));
+        debug('Found %d page(s), %d web page(s): %o', pages.length, webPages.length, pages.map((p)=>p.url()));
+        let page;
+        if (navigateToUrl) if (webPages.length > 0) {
+            page = webPages[webPages.length - 1];
+            await page.bringToFront();
+            await page.goto(navigateToUrl, {
+                timeout: 30000,
+                waitUntil: 'domcontentloaded'
+            });
+        } else {
+            page = await browser.newPage();
+            await page.goto(navigateToUrl, {
+                timeout: 30000,
+                waitUntil: 'domcontentloaded'
+            });
+        }
+        else {
+            const savedTargetId = readSavedTargetId();
+            let matchedPage;
+            if (savedTargetId && pages.length > 0) {
+                matchedPage = pages.find((p)=>getTargetId(p) === savedTargetId);
+                matchedPage ? debug('Matched saved targetId %s', savedTargetId) : debug('Saved targetId %s not found among %d pages, falling back', savedTargetId, pages.length);
+            }
+            page = matchedPage ? matchedPage : webPages.length > 0 ? webPages[webPages.length - 1] : pages.length > 0 ? pages[pages.length - 1] : await browser.newPage();
+            await page.bringToFront();
+        }
+        const targetId = getTargetId(page);
+        if (targetId) saveTargetId(targetId);
+        else debug('No targetId on page.target(); cross-command tab reuse disabled until puppeteer integration is updated.');
+        const reportOptions = this.readCliReportAgentOptions();
+        this.agent = new PuppeteerAgent(page, {
+            ...reportOptions ?? {}
+        });
+        return this.agent;
+    }
+    async destroy() {
+        await super.destroy();
+        if (this.activeBrowser) {
+            this.activeBrowser.disconnect();
+            this.activeBrowser = null;
+        }
+    }
+    preparePlatformTools() {
+        return [
+            {
+                name: 'web_connect',
+                description: 'Connect to a web page via CDP. Opens a new tab with the given URL, or reuses the current page.',
+                schema: {
+                    url: z.string().url().optional().describe('URL to open in new tab (omit to use current page)')
+                },
+                handler: async (args)=>{
+                    const { url } = args;
+                    if (this.agent) {
+                        try {
+                            await this.agent.destroy?.();
+                        } catch (e) {
+                            console.debug('Failed to destroy agent during connect:', e);
+                        }
+                        this.agent = void 0;
+                    }
+                    const reportSession = this.createNewCliReportSession(url ?? 'current-page');
+                    this.commitCliReportSession(reportSession);
+                    this.agent = await this.ensureAgent(url);
+                    const screenshot = await this.agent.page?.screenshotBase64();
+                    const label = url ?? 'current page';
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Connected via CDP to: ${label}`
+                            },
+                            ...screenshot ? this.buildScreenshotContent(screenshot) : []
+                        ]
+                    };
+                }
+            },
+            {
+                name: 'web_disconnect',
+                description: 'Disconnect from current web page. The browser stays running (managed externally).',
+                schema: {},
+                handler: async ()=>{
+                    if (this.agent) {
+                        try {
+                            await this.agent.destroy?.();
+                        } catch (e) {
+                            console.debug('Failed to destroy agent during disconnect:', e);
+                        }
+                        this.agent = void 0;
+                    }
+                    if (this.activeBrowser) {
+                        this.activeBrowser.disconnect();
+                        this.activeBrowser = null;
+                    }
+                    cleanupTargetIdFile();
+                    return this.buildTextResult('Disconnected from web page (browser still running externally)');
+                }
+            }
+        ];
+    }
+    constructor(cdpEndpoint){
+        super(), _define_property(this, "cdpEndpoint", void 0), _define_property(this, "activeBrowser", null);
+        this.cdpEndpoint = cdpEndpoint;
+    }
+}
+export { WebCdpMidsceneTools };

package/dist/es/mcp-tools-puppeteer.mjs

@@ -0,0 +1,246 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ScreenshotItem, z } from "@godscene/core";
+import { BaseMidsceneTools } from "@godscene/shared/mcp/base-tools";
+import { resolveChromePath } from "@godscene/shared/mcp/chrome-path";
+import puppeteer_core from "puppeteer-core";
+import { defaultPuppeteerWindowViewportSize, defaultStaticPageViewportSize } from "./common/viewport.mjs";
+import { PuppeteerAgent } from "./puppeteer/index.mjs";
+import { StaticPage } from "./static/index.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const ENDPOINT_FILE = join(tmpdir(), 'midscene-puppeteer-endpoint');
+const USER_DATA_DIR = join(tmpdir(), 'midscene-puppeteer-profile');
+const PUPPETEER_ENDPOINT_FILE = ENDPOINT_FILE;
+function buildDetachedChromeArgs(options) {
+    const viewport = options.viewport ?? defaultPuppeteerWindowViewportSize;
+    return [
+        '--headless=new',
+        `--user-data-dir=${options.userDataDir}`,
+        '--remote-debugging-port=0',
+        '--no-first-run',
+        '--no-default-browser-check',
+        '--disable-extensions',
+        '--disable-default-apps',
+        '--disable-sync',
+        '--disable-background-networking',
+        '--password-store=basic',
+        '--use-mock-keychain',
+        `--window-size=${viewport.width},${viewport.height}`,
+        '--force-color-profile=srgb'
+    ];
+}
+const browserManager = {
+    activeBrowser: null,
+    async getOrLaunch (viewport) {
+        if (existsSync(ENDPOINT_FILE)) try {
+            const endpoint = (await readFile(ENDPOINT_FILE, 'utf-8')).trim();
+            const browser = await puppeteer_core.connect({
+                browserWSEndpoint: endpoint,
+                defaultViewport: null
+            });
+            return {
+                browser,
+                reused: true
+            };
+        } catch  {
+            try {
+                await unlink(ENDPOINT_FILE);
+            } catch  {}
+        }
+        const wsEndpoint = await this.launchDetachedChrome(viewport);
+        await writeFile(ENDPOINT_FILE, wsEndpoint);
+        const browser = await puppeteer_core.connect({
+            browserWSEndpoint: wsEndpoint,
+            defaultViewport: null
+        });
+        return {
+            browser,
+            reused: false
+        };
+    },
+    async closeBrowser () {
+        if (!existsSync(ENDPOINT_FILE)) return;
+        try {
+            const endpoint = (await readFile(ENDPOINT_FILE, 'utf-8')).trim();
+            const browser = await puppeteer_core.connect({
+                browserWSEndpoint: endpoint
+            });
+            await browser.close();
+        } catch  {}
+        try {
+            await unlink(ENDPOINT_FILE);
+        } catch  {}
+    },
+    disconnect () {
+        if (this.activeBrowser) {
+            this.activeBrowser.disconnect();
+            this.activeBrowser = null;
+        }
+    },
+    async launchDetachedChrome (viewport) {
+        const chromePath = resolveChromePath();
+        await mkdir(USER_DATA_DIR, {
+            recursive: true
+        });
+        const args = buildDetachedChromeArgs({
+            userDataDir: USER_DATA_DIR,
+            viewport
+        });
+        const proc = spawn(chromePath, args, {
+            detached: true,
+            stdio: [
+                'ignore',
+                'ignore',
+                'pipe'
+            ]
+        });
+        proc.unref();
+        return new Promise((resolve, reject)=>{
+            let output = '';
+            const onData = (data)=>{
+                output += data.toString();
+                const match = output.match(/DevTools listening on (ws:\/\/[^\s]+)/);
+                if (match) {
+                    proc.stderr.removeListener('data', onData);
+                    resolve(match[1]);
+                }
+            };
+            proc.stderr.on('data', onData);
+            proc.on('exit', (code)=>{
+                proc.stderr.removeListener('data', onData);
+                reject(new Error(`Chrome exited with code ${code} before DevTools was ready.\nChrome stderr: ${output}\nTip: try setting MIDSCENE_MCP_NO_SANDBOX=1 if running in a container.`));
+            });
+            setTimeout(()=>reject(new Error(`Chrome launch timeout.\nChrome stderr: ${output}\nTip: try setting MIDSCENE_MCP_NO_SANDBOX=1 if running in a container.`)), 15000);
+        });
+    }
+};
+class WebPuppeteerMidsceneTools extends BaseMidsceneTools {
+    getCliReportSessionName() {
+        return 'midscene-web';
+    }
+    createTemporaryDevice() {
+        return new StaticPage({
+            screenshot: ScreenshotItem.create('', Date.now()),
+            shotSize: this.viewport ?? defaultStaticPageViewportSize,
+            shrunkShotToLogicalRatio: 1
+        });
+    }
+    async ensureAgent(navigateToUrl) {
+        if (this.agent && navigateToUrl) {
+            try {
+                await this.agent?.destroy?.();
+            } catch  {}
+            this.agent = void 0;
+        }
+        if (this.agent) return this.agent;
+        const { browser, reused } = await browserManager.getOrLaunch(this.viewport);
+        browserManager.activeBrowser = browser;
+        const pages = await browser.pages();
+        let page;
+        if (navigateToUrl) {
+            page = await browser.newPage();
+            if (this.viewport) await page.setViewport(this.viewport);
+            await page.goto(navigateToUrl, {
+                timeout: 30000,
+                waitUntil: 'domcontentloaded'
+            });
+        } else {
+            const webPages = pages.filter((p)=>/^https?:\/\//.test(p.url()));
+            page = webPages.length > 0 ? webPages[webPages.length - 1] : pages[pages.length - 1] || await browser.newPage();
+            if (reused) await page.bringToFront();
+            if (this.viewport) await page.setViewport(this.viewport);
+        }
+        const reportOptions = this.readCliReportAgentOptions();
+        this.agent = new PuppeteerAgent(page, {
+            ...reportOptions ?? {}
+        });
+        return this.agent;
+    }
+    async destroy() {
+        await super.destroy();
+        browserManager.disconnect();
+    }
+    preparePlatformTools() {
+        return [
+            {
+                name: 'web_connect',
+                description: 'Connect to a web page. Opens a new tab with the given URL, or reuses the current page.',
+                schema: {
+                    url: z.string().url().optional().describe('URL to open in new tab (omit to use current page)')
+                },
+                handler: async (args)=>{
+                    const { url } = args;
+                    if (this.agent) {
+                        try {
+                            await this.agent.destroy?.();
+                        } catch  {}
+                        this.agent = void 0;
+                    }
+                    const reportSession = this.createNewCliReportSession(url ?? 'current-page');
+                    this.commitCliReportSession(reportSession);
+                    this.agent = await this.ensureAgent(url);
+                    const screenshot = await this.agent.page?.screenshotBase64();
+                    const label = url ?? 'current page';
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Connected to: ${label}`
+                            },
+                            ...screenshot ? this.buildScreenshotContent(screenshot) : []
+                        ]
+                    };
+                }
+            },
+            {
+                name: 'web_disconnect',
+                description: 'Disconnect from current web page. The browser stays running for future calls.',
+                schema: {},
+                handler: async ()=>{
+                    if (this.agent) {
+                        try {
+                            await this.agent.destroy?.();
+                        } catch  {}
+                        this.agent = void 0;
+                    }
+                    browserManager.disconnect();
+                    return this.buildTextResult('Disconnected from web page (browser still running)');
+                }
+            },
+            {
+                name: 'web_close',
+                description: 'Close the browser completely and release all resources.',
+                schema: {},
+                handler: async ()=>{
+                    if (this.agent) {
+                        try {
+                            await this.agent.destroy?.();
+                        } catch  {}
+                        this.agent = void 0;
+                    }
+                    await browserManager.closeBrowser();
+                    return this.buildTextResult('Browser closed');
+                }
+            }
+        ];
+    }
+    constructor(viewport){
+        super(), _define_property(this, "viewport", void 0);
+        this.viewport = viewport ? {
+            ...viewport
+        } : void 0;
+    }
+}
+export { PUPPETEER_ENDPOINT_FILE, WebPuppeteerMidsceneTools, buildDetachedChromeArgs };