@godscene/web 1.7.11

package/dist/es/puppeteer/index.mjs

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

package/dist/es/puppeteer/page.mjs

@@ -0,0 +1,7 @@
+import { Page } from "./base-page.mjs";
+class PuppeteerWebPage extends Page {
+    constructor(page, opts){
+        super(page, 'puppeteer', opts);
+    }
+}
+export { PuppeteerWebPage };

package/dist/es/static/index.mjs

@@ -0,0 +1,3 @@
+import { StaticPageAgent } from "./static-agent.mjs";
+import static_page from "./static-page.mjs";
+export { static_page as StaticPage, StaticPageAgent };

package/dist/es/static/static-agent.mjs

@@ -0,0 +1,10 @@
+import { Agent } from "@godscene/core/agent";
+class StaticPageAgent extends Agent {
+    constructor(page){
+        super(page, {
+            generateReport: false
+        });
+        this.dryMode = true;
+    }
+}
+export { StaticPageAgent };

package/dist/es/static/static-page.mjs

@@ -0,0 +1,123 @@
+import { defineActionDragAndDrop, defineActionHover, defineActionInput, defineActionKeyboardPress, defineActionRightClick, defineActionScroll, defineActionSwipe, defineActionTap } from "@godscene/core/device";
+import { ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED } from "@godscene/shared/common";
+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 ThrowNotImplemented = (methodName)=>{
+    throw new Error(`The method "${methodName}" is not implemented as designed since this is a static UI context. (${ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED})`);
+};
+class StaticPage {
+    actionSpace() {
+        return [
+            defineActionTap(async (param)=>{
+                ThrowNotImplemented('Tap');
+            }),
+            defineActionRightClick(async (param)=>{
+                ThrowNotImplemented('RightClick');
+            }),
+            defineActionHover(async (param)=>{
+                ThrowNotImplemented('Hover');
+            }),
+            defineActionInput(async (param)=>{
+                ThrowNotImplemented('Input');
+            }),
+            defineActionKeyboardPress(async (param)=>{
+                ThrowNotImplemented('KeyboardPress');
+            }),
+            defineActionScroll(async (param)=>{
+                ThrowNotImplemented('Scroll');
+            }),
+            defineActionDragAndDrop(async (param)=>{
+                ThrowNotImplemented('DragAndDrop');
+            }),
+            defineActionSwipe(async (param)=>{
+                ThrowNotImplemented('Swipe');
+            })
+        ];
+    }
+    async evaluateJavaScript(script) {
+        return ThrowNotImplemented('evaluateJavaScript');
+    }
+    async getElementsInfo() {
+        return ThrowNotImplemented('getElementsInfo');
+    }
+    async getElementsNodeTree() {
+        return ThrowNotImplemented('getElementsNodeTree');
+    }
+    async getXpathsByPoint(point) {
+        return ThrowNotImplemented('getXpathsByPoint');
+    }
+    async getElementFromPoint(args) {
+        return ThrowNotImplemented('getElementFromPoint');
+    }
+    async getElementInfoByXpath(xpath) {
+        return ThrowNotImplemented('getElementInfoByXpath');
+    }
+    async size() {
+        return {
+            ...this.uiContext.shotSize
+        };
+    }
+    async screenshotBase64() {
+        const screenshot = this.uiContext.screenshot;
+        if ('object' == typeof screenshot && 'base64' in screenshot) return screenshot.base64;
+        return screenshot;
+    }
+    async url() {
+        return Promise.resolve('https://static_page_without_url');
+    }
+    async scrollUntilTop(startingPoint) {
+        return ThrowNotImplemented('scrollUntilTop');
+    }
+    async scrollUntilBottom(startingPoint) {
+        return ThrowNotImplemented('scrollUntilBottom');
+    }
+    async scrollUntilLeft(startingPoint) {
+        return ThrowNotImplemented('scrollUntilLeft');
+    }
+    async scrollUntilRight(startingPoint) {
+        return ThrowNotImplemented('scrollUntilRight');
+    }
+    async scrollUp(distance, startingPoint) {
+        return ThrowNotImplemented('scrollUp');
+    }
+    async scrollDown(distance, startingPoint) {
+        return ThrowNotImplemented('scrollDown');
+    }
+    async scrollLeft(distance, startingPoint) {
+        return ThrowNotImplemented('scrollLeft');
+    }
+    async scrollRight(distance, startingPoint) {
+        return ThrowNotImplemented('scrollRight');
+    }
+    async clearInput() {
+        return ThrowNotImplemented('clearInput');
+    }
+    async destroy() {}
+    updateContext(newContext) {
+        this.uiContext = newContext;
+    }
+    constructor(uiContext){
+        _define_property(this, "interfaceType", 'static');
+        _define_property(this, "uiContext", void 0);
+        _define_property(this, "mouse", {
+            click: ThrowNotImplemented.bind(null, 'mouse.click'),
+            wheel: ThrowNotImplemented.bind(null, 'mouse.wheel'),
+            move: ThrowNotImplemented.bind(null, 'mouse.move'),
+            drag: ThrowNotImplemented.bind(null, 'mouse.drag')
+        });
+        _define_property(this, "keyboard", {
+            type: ThrowNotImplemented.bind(null, 'keyboard.type'),
+            press: ThrowNotImplemented.bind(null, 'keyboard.press')
+        });
+        this.uiContext = uiContext;
+    }
+}
+export { StaticPage as default };

package/dist/es/utils.mjs

@@ -0,0 +1,6 @@
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+function getWebpackRequire() {
+    return void 0 !== __rspack_createRequire_require ? __rspack_createRequire_require : require;
+}
+export { getWebpackRequire };

package/dist/es/web-element.mjs

@@ -0,0 +1,57 @@
+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 WebElementInfoImpl {
+    constructor({ content, rect, id, attributes, indexId, xpaths, isVisible }){
+        _define_property(this, "content", void 0);
+        _define_property(this, "rect", void 0);
+        _define_property(this, "center", void 0);
+        _define_property(this, "id", void 0);
+        _define_property(this, "indexId", void 0);
+        _define_property(this, "attributes", void 0);
+        _define_property(this, "xpaths", void 0);
+        _define_property(this, "isVisible", void 0);
+        this.content = content;
+        this.rect = rect;
+        this.center = [
+            Math.floor(rect.left + rect.width / 2),
+            Math.floor(rect.top + rect.height / 2)
+        ];
+        this.id = id;
+        this.attributes = attributes;
+        this.indexId = indexId;
+        this.xpaths = xpaths;
+        this.isVisible = isVisible;
+    }
+}
+const limitOpenNewTabScript = `
+if (!window.__MIDSCENE_NEW_TAB_INTERCEPTOR_INITIALIZED__) {
+  window.__MIDSCENE_NEW_TAB_INTERCEPTOR_INITIALIZED__ = true;
+
+  // Intercept the window.open method (only once)
+  window.open = function(url) {
+    console.log('Blocked window.open:', url);
+    window.location.href = url;
+    return null;
+  };
+
+  // Block all a tag clicks with target="_blank" (only once)
+  document.addEventListener('click', function(e) {
+    const target = e.target.closest('a');
+    if (target && target.target === '_blank') {
+      e.preventDefault();
+      console.log('Blocked new tab:', target.href);
+      window.location.href = target.href;
+      target.removeAttribute('target');
+    }
+  }, true);
+}
+`;
+export { WebElementInfoImpl, limitOpenNewTabScript };

package/dist/es/web-page.mjs

@@ -0,0 +1,272 @@
+import node_assert from "node:assert";
+import { z } from "@godscene/core";
+import { AbstractInterface, defineAction, defineActionClearInput, defineActionCursorMove, defineActionDoubleClick, defineActionDragAndDrop, defineActionHover, defineActionInput, defineActionKeyboardPress, defineActionLongPress, defineActionPinch, defineActionRightClick, defineActionScroll, defineActionSwipe, defineActionTap, normalizePinchParam } from "@godscene/core/device";
+import { sleep } from "@godscene/core/utils";
+import { getDebug } from "@godscene/shared/logger";
+import { transformHotkeyInput } from "@godscene/shared/us-keyboard-layout";
+const debug = getDebug('web:page');
+const navigateParamSchema = z.object({
+    url: z.string().describe('The URL to navigate to. Must start with https://, file://, or a similar protocol.')
+});
+function normalizeKeyInputs(value) {
+    const inputs = Array.isArray(value) ? value : [
+        value
+    ];
+    const result = [];
+    for (const input of inputs){
+        if ('string' != typeof input) {
+            result.push(input);
+            continue;
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            result.push(input);
+            continue;
+        }
+        let normalized = trimmed;
+        if (normalized.length > 1 && normalized.includes('+')) normalized = normalized.replace(/\s*\+\s*/g, ' ');
+        if (/\s/.test(normalized)) normalized = normalized.replace(/\s+/g, ' ');
+        const transformed = transformHotkeyInput(normalized);
+        if (1 === transformed.length && '' === transformed[0] && '' !== trimmed) {
+            result.push(input);
+            continue;
+        }
+        if (0 === transformed.length) {
+            result.push(input);
+            continue;
+        }
+        result.push(...transformed);
+    }
+    return result;
+}
+function getKeyCommands(value) {
+    const keys = normalizeKeyInputs(value);
+    return keys.reduce((acc, k)=>{
+        const includeMeta = keys.includes('Meta') || keys.includes('Control');
+        if (includeMeta && ('a' === k || 'A' === k)) return acc.concat([
+            {
+                key: k,
+                command: 'SelectAll'
+            }
+        ]);
+        if (includeMeta && ('c' === k || 'C' === k)) return acc.concat([
+            {
+                key: k,
+                command: 'Copy'
+            }
+        ]);
+        if (includeMeta && ('v' === k || 'V' === k)) return acc.concat([
+            {
+                key: k,
+                command: 'Paste'
+            }
+        ]);
+        return acc.concat([
+            {
+                key: k
+            }
+        ]);
+    }, []);
+}
+class AbstractWebPage extends AbstractInterface {
+    get mouse() {
+        return {
+            click: async (x, y, options)=>{},
+            wheel: async (deltaX, deltaY)=>{},
+            move: async (x, y)=>{},
+            drag: async (from, to)=>{}
+        };
+    }
+    get keyboard() {
+        return {
+            type: async (text)=>{},
+            press: async (action)=>{}
+        };
+    }
+    async clearInput(element) {}
+}
+const commonWebActionsForWebPage = (page, includeTouchEvents = false)=>[
+        defineActionTap(async (param)=>{
+            const element = param.locate;
+            node_assert(element, 'Element not found, cannot tap');
+            await page.mouse.click(element.center[0], element.center[1], {
+                button: 'left'
+            });
+        }),
+        defineActionRightClick(async (param)=>{
+            const element = param.locate;
+            node_assert(element, 'Element not found, cannot right click');
+            await page.mouse.click(element.center[0], element.center[1], {
+                button: 'right'
+            });
+        }),
+        defineActionDoubleClick(async (param)=>{
+            const element = param.locate;
+            node_assert(element, 'Element not found, cannot double click');
+            await page.mouse.click(element.center[0], element.center[1], {
+                button: 'left',
+                count: 2
+            });
+        }),
+        defineActionHover(async (param)=>{
+            const element = param.locate;
+            node_assert(element, 'Element not found, cannot hover');
+            await page.mouse.move(element.center[0], element.center[1]);
+        }),
+        defineActionInput(async (param)=>{
+            const element = param.locate;
+            if (element && 'typeOnly' !== param.mode) await page.clearInput(element);
+            else if (element && 'typeOnly' === param.mode) {
+                await page.mouse.click(element.center[0], element.center[1], {
+                    button: 'left'
+                });
+                await page.keyboard.press([
+                    {
+                        key: 'End'
+                    }
+                ]);
+            }
+            if ('clear' === param.mode) return;
+            if (!param || !param.value) return;
+            await page.keyboard.type(param.value);
+            await page.flushPendingVisualUpdate?.();
+        }),
+        defineActionKeyboardPress(async (param)=>{
+            const element = param.locate;
+            if (element) await page.mouse.click(element.center[0], element.center[1], {
+                button: 'left'
+            });
+            const keys = getKeyCommands(param.keyName);
+            await page.keyboard.press(keys);
+            await page.flushPendingVisualUpdate?.();
+        }),
+        defineActionCursorMove(async (param)=>{
+            const arrowKey = 'left' === param.direction ? 'ArrowLeft' : 'ArrowRight';
+            const times = param.times ?? 1;
+            for(let i = 0; i < times; i++){
+                await page.keyboard.press([
+                    {
+                        key: arrowKey
+                    }
+                ]);
+                await sleep(100);
+            }
+        }),
+        defineActionScroll(async (param)=>{
+            const element = param.locate;
+            const startingPoint = element ? {
+                left: element.center[0],
+                top: element.center[1]
+            } : void 0;
+            const scrollToEventName = param?.scrollType;
+            if ('scrollToTop' === scrollToEventName) await page.scrollUntilTop(startingPoint);
+            else if ('scrollToBottom' === scrollToEventName) await page.scrollUntilBottom(startingPoint);
+            else if ('scrollToRight' === scrollToEventName) await page.scrollUntilRight(startingPoint);
+            else if ('scrollToLeft' === scrollToEventName) await page.scrollUntilLeft(startingPoint);
+            else if ('singleAction' !== scrollToEventName && scrollToEventName) throw new Error(`Unknown scroll event type: ${scrollToEventName}, param: ${JSON.stringify(param)}`);
+            else {
+                if (param?.direction !== 'down' && param && param.direction) if ('up' === param.direction) await page.scrollUp(param.distance || void 0, startingPoint);
+                else if ('left' === param.direction) await page.scrollLeft(param.distance || void 0, startingPoint);
+                else if ('right' === param.direction) await page.scrollRight(param.distance || void 0, startingPoint);
+                else throw new Error(`Unknown scroll direction: ${param.direction}`);
+                else await page.scrollDown(param?.distance || void 0, startingPoint);
+                await sleep(500);
+            }
+        }),
+        defineActionDragAndDrop(async (param)=>{
+            const from = param.from;
+            const to = param.to;
+            node_assert(from, 'missing "from" param for drag and drop');
+            node_assert(to, 'missing "to" param for drag and drop');
+            await page.mouse.drag({
+                x: from.center[0],
+                y: from.center[1]
+            }, {
+                x: to.center[0],
+                y: to.center[1]
+            });
+        }),
+        defineActionLongPress(async (param)=>{
+            const element = param.locate;
+            node_assert(element, 'Element not found, cannot long press');
+            const duration = param?.duration;
+            await page.longPress(element.center[0], element.center[1], duration);
+        }),
+        defineActionPinch(async (param)=>{
+            const { centerX, centerY, startDistance, endDistance, duration } = normalizePinchParam(param, await page.size());
+            await page.pinch(centerX, centerY, startDistance, endDistance, duration);
+        }),
+        ...includeTouchEvents ? [
+            defineActionSwipe(async (param)=>{
+                const { width, height } = await page.size();
+                const { start, end } = param;
+                const startPoint = start ? {
+                    x: start.center[0],
+                    y: start.center[1]
+                } : {
+                    x: width / 2,
+                    y: height / 2
+                };
+                let endPoint;
+                if (end) endPoint = {
+                    x: end.center[0],
+                    y: end.center[1]
+                };
+                else if (param.distance) {
+                    const direction = param.direction;
+                    if (!direction) throw new Error('direction is required for swipe gesture');
+                    endPoint = {
+                        x: startPoint.x + ('right' === direction ? param.distance : 'left' === direction ? -param.distance : 0),
+                        y: startPoint.y + ('down' === direction ? param.distance : 'up' === direction ? -param.distance : 0)
+                    };
+                } else throw new Error('Either end or distance must be specified for swipe gesture');
+                endPoint.x = Math.max(0, Math.min(endPoint.x, width));
+                endPoint.y = Math.max(0, Math.min(endPoint.y, height));
+                const duration = param.duration;
+                debug(`swipe from ${startPoint.x}, ${startPoint.y} to ${endPoint.x}, ${endPoint.y} with duration ${duration}ms, repeat is set to ${param.repeat}`);
+                let repeat = 'number' == typeof param.repeat ? param.repeat : 1;
+                if (0 === repeat) repeat = 10;
+                for(let i = 0; i < repeat; i++)await page.swipe(startPoint, endPoint, duration);
+            })
+        ] : [],
+        defineActionClearInput(async (param)=>{
+            await page.clearInput(param.locate);
+        }),
+        defineAction({
+            name: 'Navigate',
+            description: 'Navigate the browser to a specified URL. Opens the URL in the current tab.',
+            paramSchema: navigateParamSchema,
+            sample: {
+                url: 'https://www.example.com'
+            },
+            call: async (param)=>{
+                if (!page.navigate) throw new Error('Navigate operation is not supported on this page type');
+                await page.navigate(param.url);
+            }
+        }),
+        defineAction({
+            name: 'Reload',
+            description: 'Reload the current page',
+            call: async ()=>{
+                if (!page.reload) throw new Error('Reload operation is not supported on this page type');
+                await page.reload();
+            }
+        }),
+        defineAction({
+            name: 'GoBack',
+            description: 'Navigate back in browser history',
+            call: async ()=>{
+                if (!page.goBack) throw new Error('GoBack operation is not supported on this page type');
+                await page.goBack();
+            }
+        }),
+        defineAction({
+            name: 'GoForward',
+            description: 'Navigate forward in browser history',
+            call: async ()=>{
+                if (!page.goForward) throw new Error('GoForward operation is not supported on this page type');
+                await page.goForward();
+            }
+        })
+    ];
+export { AbstractWebPage, commonWebActionsForWebPage, getKeyCommands };

package/dist/lib/bin.js

@@ -0,0 +1,20 @@
+"use strict";
+var __webpack_exports__ = {};
+const playground_namespaceObject = require("@godscene/playground");
+require("dotenv/config");
+const external_platform_js_namespaceObject = require("./platform.js");
+async function startServer() {
+    const prepared = await external_platform_js_namespaceObject.webPlaygroundPlatform.prepare({
+        launchOptions: {
+            openBrowser: false,
+            verbose: false
+        }
+    });
+    const { server } = await (0, playground_namespaceObject.launchPreparedPlaygroundPlatform)(prepared);
+    console.log(`Midscene playground server is running on http://localhost:${server.port}`);
+}
+startServer().catch(console.error);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});