@godscene/web 1.7.11

package/dist/es/mcp-tools.mjs

@@ -0,0 +1,81 @@
+import { ScreenshotItem, z } from "@godscene/core";
+import { BaseMidsceneTools } from "@godscene/shared/mcp/base-tools";
+import { AgentOverChromeBridge } from "./bridge-mode/index.mjs";
+import { defaultStaticPageViewportSize } from "./common/viewport.mjs";
+import { StaticPage } from "./static/index.mjs";
+class WebMidsceneTools extends BaseMidsceneTools {
+    getCliReportSessionName() {
+        return 'midscene-web';
+    }
+    createTemporaryDevice() {
+        return new StaticPage({
+            screenshot: ScreenshotItem.create('', Date.now()),
+            shotSize: defaultStaticPageViewportSize,
+            shrunkShotToLogicalRatio: 1
+        });
+    }
+    async ensureAgent(openNewTabWithUrl) {
+        if (this.agent && openNewTabWithUrl) {
+            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;
+        this.agent = await this.initBridgeModeAgent(openNewTabWithUrl);
+        return this.agent;
+    }
+    async initBridgeModeAgent(url) {
+        const reportOptions = this.readCliReportAgentOptions();
+        const agent = new AgentOverChromeBridge({
+            closeConflictServer: true,
+            ...reportOptions ?? {}
+        });
+        if (url) await agent.connectNewTabWithUrl(url);
+        else await agent.connectCurrentTab();
+        return agent;
+    }
+    preparePlatformTools() {
+        return [
+            {
+                name: 'web_connect',
+                description: 'Connect to web page. If URL provided, opens new tab; otherwise connects to current tab.',
+                schema: {
+                    url: z.string().url().optional().describe('URL to open in new tab (omit to connect current tab)')
+                },
+                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-tab');
+                    this.commitCliReportSession(reportSession);
+                    this.agent = await this.initBridgeModeAgent(url);
+                    const screenshot = await this.agent.page?.screenshotBase64();
+                    const label = url ?? 'current tab';
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Connected to: ${label}`
+                            },
+                            ...screenshot ? this.buildScreenshotContent(screenshot) : []
+                        ]
+                    };
+                }
+            },
+            {
+                name: 'web_disconnect',
+                description: 'Disconnect from current web page and release browser resources',
+                schema: {},
+                handler: this.createDisconnectHandler('web page')
+            }
+        ];
+    }
+}
+export { WebMidsceneTools };

package/dist/es/platform.mjs

@@ -0,0 +1,37 @@
+import { ScreenshotItem } from "@godscene/core";
+import { createMjpegPreviewDescriptor, definePlaygroundPlatform } from "@godscene/playground";
+import { StaticPage, StaticPageAgent } from "./static/index.mjs";
+function createDefaultWebAgent() {
+    const page = new StaticPage({
+        shotSize: {
+            width: 800,
+            height: 600
+        },
+        screenshot: ScreenshotItem.create('', Date.now()),
+        shrunkShotToLogicalRatio: 1
+    });
+    return new StaticPageAgent(page);
+}
+const webPlaygroundPlatform = definePlaygroundPlatform({
+    id: 'web',
+    title: 'Midscene Web Playground',
+    description: "Web playground platform descriptor",
+    async prepare (options) {
+        const agent = options?.agent;
+        const agentFactory = options?.agentFactory || (options?.agent || options?.agentFactory ? void 0 : ()=>createDefaultWebAgent());
+        return {
+            platformId: 'web',
+            title: options?.title || 'Midscene Web Playground',
+            agent: agent || (agentFactory ? void 0 : createDefaultWebAgent()),
+            agentFactory,
+            launchOptions: options?.launchOptions,
+            preview: options?.preview || createMjpegPreviewDescriptor({
+                title: 'Web page preview'
+            }),
+            metadata: {
+                interfaceType: agent?.interface?.interfaceType || 'web'
+            }
+        };
+    }
+});
+export { webPlaygroundPlatform };

package/dist/es/playwright/ai-fixture.mjs

@@ -0,0 +1,364 @@
+import { PlaywrightAgent } from "./index.mjs";
+import { processCacheConfig } from "@godscene/core/utils";
+import { DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT, DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT } from "@godscene/shared/constants";
+import { getDebug } from "@godscene/shared/logger";
+import { replaceIllegalPathCharsAndSpace, uuid } from "@godscene/shared/utils";
+import { test } from "@playwright/test";
+const debugPage = getDebug('web:playwright:ai-fixture');
+const groupAndCaseForTest = (testInfo)=>{
+    let taskFile;
+    let taskTitle;
+    const titlePath = [
+        ...testInfo.titlePath
+    ];
+    if (titlePath.length > 1) {
+        taskFile = titlePath.shift() || 'unnamed';
+        taskTitle = titlePath.join('__');
+    } else if (1 === titlePath.length) {
+        taskTitle = titlePath[0];
+        taskFile = `${taskTitle}`;
+    } else {
+        taskTitle = 'unnamed';
+        taskFile = 'unnamed';
+    }
+    const taskTitleWithRetry = `${taskTitle}${testInfo.retry ? `(retry #${testInfo.retry})` : ''}`;
+    return {
+        file: taskFile,
+        id: replaceIllegalPathCharsAndSpace(`${taskFile}(${taskTitle})`),
+        title: replaceIllegalPathCharsAndSpace(taskTitleWithRetry)
+    };
+};
+const midsceneAgentKeyId = '_midsceneAgentId';
+const midsceneDumpAnnotationId = 'MIDSCENE_DUMP_ANNOTATION';
+const PlaywrightAiFixture = (options)=>{
+    const { forceSameTabNavigation = true, waitForNetworkIdleTimeout = DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT, waitForNavigationTimeout = DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT, cache, ...sharedAgentOptions } = options ?? {};
+    const processTestCacheConfig = (testInfo)=>{
+        const { id } = groupAndCaseForTest(testInfo);
+        return processCacheConfig(cache, id);
+    };
+    const pageAgentMap = {};
+    const testAgentRecords = new Map();
+    const getAgentRecordsForTest = (testInfo)=>{
+        let records = testAgentRecords.get(testInfo.testId);
+        if (!records) {
+            records = new Map();
+            testAgentRecords.set(testInfo.testId, records);
+        }
+        return records;
+    };
+    const setReportAnnotation = (testInfo, reportPaths)=>{
+        testInfo.annotations = testInfo.annotations.filter((item)=>item.type !== midsceneDumpAnnotationId);
+        for (const reportPath of reportPaths)testInfo.annotations.push({
+            type: midsceneDumpAnnotationId,
+            description: reportPath
+        });
+    };
+    const finalizeAgentRecord = async (record)=>{
+        if (!record.finalizePromise) record.finalizePromise = (async ()=>{
+            await record.agent.destroy();
+            const reportPath = record.agent.reportFile || void 0;
+            record.finalReportPath = reportPath;
+            return reportPath;
+        })();
+        return await record.finalizePromise;
+    };
+    const createOrReuseAgentForPage = (page, testInfo, opts)=>{
+        let idForPage = page[midsceneAgentKeyId];
+        if (!idForPage) {
+            idForPage = uuid();
+            page[midsceneAgentKeyId] = idForPage;
+            const { file, title } = groupAndCaseForTest(testInfo);
+            const cacheConfig = processTestCacheConfig(testInfo);
+            const reportTag = `playwright-${title.replace(/[\\/]/g, '-')}-${idForPage}`;
+            const agent = new PlaywrightAgent(page, {
+                testId: reportTag,
+                reportFileName: reportTag,
+                forceSameTabNavigation,
+                cache: cacheConfig,
+                groupName: title,
+                groupDescription: file,
+                generateReport: true,
+                ...sharedAgentOptions,
+                ...opts
+            });
+            pageAgentMap[idForPage] = agent;
+            const records = getAgentRecordsForTest(testInfo);
+            const record = {
+                agent
+            };
+            records.set(idForPage, record);
+            page.on('close', async ()=>{
+                debugPage('page closed');
+                try {
+                    await finalizeAgentRecord(record);
+                } finally{
+                    delete pageAgentMap[idForPage];
+                }
+            });
+        }
+        return pageAgentMap[idForPage];
+    };
+    async function generateAiFunction(options) {
+        const { page, testInfo, use, aiActionType } = options;
+        const agent = createOrReuseAgentForPage(page, testInfo, {
+            waitForNavigationTimeout,
+            waitForNetworkIdleTimeout
+        });
+        await use(async (taskPrompt, ...args)=>new Promise((resolve, reject)=>{
+                test.step(`ai-${aiActionType} - ${JSON.stringify(taskPrompt)}`, async ()=>{
+                    try {
+                        const result = await agent[aiActionType].bind(agent)(taskPrompt, ...args);
+                        resolve(result);
+                    } catch (error) {
+                        reject(error);
+                    }
+                });
+            }));
+    }
+    return {
+        _midsceneFinalizeReports: [
+            async ({}, use, testInfo)=>{
+                await use();
+                const records = testAgentRecords.get(testInfo.testId);
+                if (!records || 0 === records.size) return;
+                const reportPaths = (await Promise.all(Array.from(records.values()).map((record)=>finalizeAgentRecord(record)))).filter((reportPath)=>Boolean(reportPath));
+                if (reportPaths.length > 0) setReportAnnotation(testInfo, reportPaths);
+                testAgentRecords.delete(testInfo.testId);
+            },
+            {
+                auto: true
+            }
+        ],
+        agentForPage: async ({ page }, use, testInfo)=>{
+            await use(async (propsPage, opts)=>{
+                const cacheConfig = processTestCacheConfig(testInfo);
+                let finalCacheConfig = cacheConfig;
+                if (opts?.cache !== void 0) {
+                    const userCache = opts.cache;
+                    if (false === userCache) finalCacheConfig = false;
+                    else if (true === userCache) {
+                        const { id } = groupAndCaseForTest(testInfo);
+                        finalCacheConfig = {
+                            id
+                        };
+                    } else if ('object' == typeof userCache) if (userCache.id) finalCacheConfig = userCache;
+                    else {
+                        const { id } = groupAndCaseForTest(testInfo);
+                        finalCacheConfig = {
+                            ...userCache,
+                            id
+                        };
+                    }
+                }
+                const agent = createOrReuseAgentForPage(propsPage || page, testInfo, {
+                    waitForNavigationTimeout,
+                    waitForNetworkIdleTimeout,
+                    cache: finalCacheConfig,
+                    ...opts
+                });
+                return agent;
+            });
+        },
+        ai: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'ai'
+            });
+        },
+        aiAct: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiAct'
+            });
+        },
+        aiAction: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiAction'
+            });
+        },
+        aiTap: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiTap'
+            });
+        },
+        aiRightClick: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiRightClick'
+            });
+        },
+        aiDoubleClick: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiDoubleClick'
+            });
+        },
+        aiHover: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiHover'
+            });
+        },
+        aiInput: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiInput'
+            });
+        },
+        aiKeyboardPress: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiKeyboardPress'
+            });
+        },
+        aiScroll: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiScroll'
+            });
+        },
+        aiQuery: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiQuery'
+            });
+        },
+        aiAssert: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiAssert'
+            });
+        },
+        aiWaitFor: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiWaitFor'
+            });
+        },
+        aiLocate: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiLocate'
+            });
+        },
+        aiNumber: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiNumber'
+            });
+        },
+        aiString: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiString'
+            });
+        },
+        aiBoolean: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiBoolean'
+            });
+        },
+        aiAsk: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'aiAsk'
+            });
+        },
+        runYaml: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'runYaml'
+            });
+        },
+        setAIActionContext: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'setAIActionContext'
+            });
+        },
+        evaluateJavaScript: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'evaluateJavaScript'
+            });
+        },
+        recordToReport: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'recordToReport'
+            });
+        },
+        logScreenshot: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'logScreenshot'
+            });
+        },
+        freezePageContext: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'freezePageContext'
+            });
+        },
+        unfreezePageContext: async ({ page }, use, testInfo)=>{
+            await generateAiFunction({
+                page,
+                testInfo,
+                use,
+                aiActionType: 'unfreezePageContext'
+            });
+        }
+    };
+};
+export { PlaywrightAiFixture, midsceneDumpAnnotationId };

package/dist/es/playwright/index.mjs

@@ -0,0 +1,36 @@
+import { Agent } from "@godscene/core/agent";
+import { WebPage } from "./page.mjs";
+import { PlaywrightAiFixture } from "./ai-fixture.mjs";
+import { overrideAIConfig } from "@godscene/shared/env";
+import { getDebug } from "@godscene/shared/logger";
+import semver from "semver";
+import { BROWSER_NAVIGATION_ERROR_PATTERN, forceChromeSelectRendering as base_page_mjs_forceChromeSelectRendering, forceClosePopup } from "../puppeteer/base-page.mjs";
+import { getWebpackRequire } from "../utils.mjs";
+const debug = getDebug('playwright:agent');
+function getPlaywrightVersion() {
+    try {
+        const playwrightPkg = getWebpackRequire()('playwright/package.json');
+        return playwrightPkg.version || null;
+    } catch (error) {
+        console.error('[midscene:error] Failed to get Playwright version', error);
+        return null;
+    }
+}
+class PlaywrightAgent extends Agent {
+    isRetryableContextError(error) {
+        return error instanceof Error && BROWSER_NAVIGATION_ERROR_PATTERN.test(error.message);
+    }
+    constructor(page, opts){
+        if (!page) throw new Error('[midscene] PlaywrightAgent requires a valid Playwright page instance. Please make sure to pass a valid page object.');
+        const webPage = new WebPage(page, opts);
+        super(webPage, opts);
+        const { forceSameTabNavigation = true, forceChromeSelectRendering } = opts ?? {};
+        if (forceSameTabNavigation) forceClosePopup(page, debug);
+        if (forceChromeSelectRendering) {
+            const playwrightVersion = getPlaywrightVersion();
+            if (playwrightVersion && !semver.gte(playwrightVersion, '1.52.0')) console.warn(`[midscene:error] forceChromeSelectRendering requires Playwright >= 1.52.0, but current version is ${playwrightVersion}. This feature may not work correctly.`);
+            base_page_mjs_forceChromeSelectRendering(page);
+        }
+    }
+}
+export { PlaywrightAgent, PlaywrightAiFixture, WebPage as PlaywrightWebPage, overrideAIConfig };

package/dist/es/playwright/page.mjs

@@ -0,0 +1,42 @@
+import { Page } from "../puppeteer/base-page.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;
+}
+class WebPage extends Page {
+    async registerFileChooserListener(handler) {
+        const page = this.underlyingPage;
+        let capturedError;
+        this.playwrightFileChooserHandler = async (chooser)=>{
+            try {
+                await handler({
+                    accept: async (files)=>{
+                        await chooser.setFiles(files);
+                    }
+                });
+            } catch (error) {
+                capturedError = error;
+            }
+        };
+        page.on('filechooser', this.playwrightFileChooserHandler);
+        return {
+            dispose: ()=>{
+                if (this.playwrightFileChooserHandler) {
+                    page.off('filechooser', this.playwrightFileChooserHandler);
+                    this.playwrightFileChooserHandler = void 0;
+                }
+            },
+            getError: ()=>capturedError
+        };
+    }
+    constructor(page, opts){
+        super(page, 'playwright', opts), _define_property(this, "playwrightFileChooserHandler", void 0);
+    }
+}
+export { WebPage };