@donggui/web 1.5.5-donggui.3

package/dist/types/bridge-mode/io-server.d.ts

@@ -0,0 +1,27 @@
+import { type BridgeCall } from './common';
+export declare const killRunningServer: (port?: number, host?: string) => Promise<void>;
+export declare class BridgeServer {
+    host: string;
+    port: number;
+    onConnect?: (() => void) | undefined;
+    onDisconnect?: ((reason: string) => void) | undefined;
+    closeConflictServer?: boolean | undefined;
+    private callId;
+    private io;
+    private socket;
+    private listeningTimeoutId;
+    private listeningTimerFlag;
+    private connectionTipTimer;
+    calls: Record<string, BridgeCall>;
+    private connectionLost;
+    private connectionLostReason;
+    constructor(host: string, port: number, onConnect?: (() => void) | undefined, onDisconnect?: ((reason: string) => void) | undefined, closeConflictServer?: boolean | undefined);
+    listen(opts?: {
+        timeout?: number | false;
+    }): Promise<void>;
+    private connectionLostErrorMsg;
+    private triggerCallResponseCallback;
+    private emitCall;
+    call<T = any>(method: string, args: any[], timeout?: number): Promise<T>;
+    close(): Promise<void | undefined>;
+}

package/dist/types/bridge-mode/page-browser-side.d.ts

@@ -0,0 +1,21 @@
+import ChromeExtensionProxyPage from '../chrome-extension/page';
+import type { ChromePageDestroyOptions } from '../web-page';
+import { type BridgeConnectTabOptions } from './common';
+import { BridgeClient } from './io-client';
+export declare class ExtensionBridgePageBrowserSide extends ChromeExtensionProxyPage {
+    serverEndpoint?: string | undefined;
+    onDisconnect: () => void;
+    onLogMessage: (message: string, type: 'log' | 'status') => void;
+    onConnectionRequest?: (() => Promise<boolean>) | undefined;
+    bridgeClient: BridgeClient | null;
+    private destroyOptions?;
+    private newlyCreatedTabIds;
+    private confirmationPromise;
+    constructor(serverEndpoint?: string | undefined, onDisconnect?: () => void, onLogMessage?: (message: string, type: 'log' | 'status') => void, forceSameTabNavigation?: boolean, onConnectionRequest?: (() => Promise<boolean>) | undefined);
+    private setupBridgeClient;
+    connect(): Promise<void>;
+    connectNewTabWithUrl(url: string, options?: BridgeConnectTabOptions): Promise<void>;
+    connectCurrentTab(options?: BridgeConnectTabOptions): Promise<void>;
+    setDestroyOptions(options: ChromePageDestroyOptions): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/types/chrome-extension/agent.d.ts

@@ -0,0 +1,5 @@
+import { type AgentOpt, Agent as PageAgent } from '@midscene/core/agent';
+import type ChromeExtensionProxyPage from './page';
+export declare class ChromeExtensionProxyPageAgent extends PageAgent {
+    constructor(page: ChromeExtensionProxyPage, opts?: AgentOpt);
+}

package/dist/types/chrome-extension/cdpInput.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type KeyInput } from '@midscene/shared/us-keyboard-layout';
+/**
+ * @public
+ */
+export interface KeyDownOptions {
+    /**
+     * @deprecated Do not use. This is automatically handled.
+     */
+    text?: string;
+    /**
+     * @deprecated Do not use. This is automatically handled.
+     */
+    commands?: string[];
+}
+/**
+ * @public
+ */
+export interface KeyboardTypeOptions {
+    /**
+     * Time to wait between key presses in milliseconds
+     * @default undefined
+     */
+    delay?: number;
+}
+/**
+ * @public
+ */
+export type KeyPressOptions = KeyDownOptions & KeyboardTypeOptions;
+type InternalCDPSession = {
+    send: (command: string, params: any) => Promise<void>;
+};
+/**
+ * @internal
+ */
+export declare class CdpKeyboard {
+    #private;
+    _modifiers: number;
+    constructor(client: InternalCDPSession);
+    updateClient(client: InternalCDPSession): void;
+    down(key: KeyInput, options?: Readonly<KeyDownOptions>): Promise<void>;
+    up(key: KeyInput): Promise<void>;
+    sendCharacter(char: string): Promise<void>;
+    private charIsKey;
+    type(text: string, options?: Readonly<KeyboardTypeOptions>): Promise<void>;
+    press(key: KeyInput | KeyInput[], options?: Readonly<KeyPressOptions>): Promise<void>;
+}
+export {};

package/dist/types/chrome-extension/dynamic-scripts.d.ts

@@ -0,0 +1,3 @@
+export declare const getHtmlElementScript: () => Promise<string>;
+export declare const injectWaterFlowAnimation: () => Promise<string>;
+export declare const injectStopWaterFlowAnimation: () => Promise<string>;

package/dist/types/chrome-extension/index.d.ts

@@ -0,0 +1,5 @@
+import { ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED } from '@midscene/shared/common';
+import { ChromeExtensionProxyPageAgent } from './agent';
+import ChromeExtensionProxyPage from './page';
+export { overrideAIConfig } from '@midscene/shared/env';
+export { ChromeExtensionProxyPage, ChromeExtensionProxyPageAgent, ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED, };

package/dist/types/chrome-extension/page.d.ts

@@ -0,0 +1,110 @@
+import type { ElementCacheFeature, ElementTreeNode, Point, Rect, Size } from '@midscene/core';
+import type { AbstractInterface, DeviceAction } from '@midscene/core/device';
+import type { ElementInfo } from '@midscene/shared/extractor';
+import { type CacheFeatureOptions } from '../common/cache-helper';
+import { type KeyInput, type MouseButton } from '../web-page';
+export default class ChromeExtensionProxyPage implements AbstractInterface {
+    interfaceType: string;
+    forceSameTabNavigation: boolean;
+    private viewportSize?;
+    private activeTabId;
+    private destroyed;
+    private isMobileEmulation;
+    _continueWhenFailedToAttachDebugger: boolean;
+    constructor(forceSameTabNavigation: boolean);
+    actionSpace(): DeviceAction[];
+    setActiveTabId(tabId: number): Promise<void>;
+    getActiveTabId(): Promise<number | null>;
+    /**
+     * Get a list of current tabs
+     * @returns {Promise<Array<{id: number, title: string, url: string}>>}
+     */
+    getBrowserTabList(): Promise<{
+        id: string;
+        title: string;
+        url: string;
+        currentActiveTab: boolean;
+    }[]>;
+    getTabIdOrConnectToCurrentTab(): Promise<number>;
+    /**
+     * Ensure debugger is attached to the current tab.
+     * Uses lazy attach pattern - only attaches when needed.
+     */
+    private ensureDebuggerAttached;
+    private showMousePointer;
+    private hideMousePointer;
+    /**
+     * Public method to detach debugger without destroying the page instance.
+     * Useful for error recovery scenarios where we want to remove the debugger banner
+     * without completely destroying the page.
+     */
+    detachDebugger(tabId?: number): Promise<void>;
+    private enableWaterFlowAnimation;
+    private disableWaterFlowAnimation;
+    /**
+     * Send a command to the debugger with automatic attach and retry on detachment.
+     * Uses lazy attach pattern - will automatically attach if not already attached.
+     */
+    private sendCommandToDebugger;
+    private getPageContentByCDP;
+    evaluateJavaScript(script: string): Promise<any>;
+    beforeInvokeAction(): Promise<void>;
+    private waitUntilNetworkIdle;
+    getElementsInfo(): Promise<ElementInfo[]>;
+    getXpathsByPoint(point: Point, isOrderSensitive?: boolean): Promise<any>;
+    getElementInfoByXpath(xpath: string): Promise<any>;
+    cacheFeatureForPoint(center: [number, number], options?: CacheFeatureOptions): Promise<ElementCacheFeature>;
+    rectMatchesCacheFeature(feature: ElementCacheFeature): Promise<Rect>;
+    getElementsNodeTree(): Promise<ElementTreeNode<ElementInfo>>;
+    size(): Promise<Size>;
+    screenshotBase64(): Promise<string>;
+    url(): Promise<string>;
+    navigate(url: string): Promise<void>;
+    reload(): Promise<void>;
+    goBack(): Promise<void>;
+    scrollUntilTop(startingPoint?: Point): Promise<void>;
+    scrollUntilBottom(startingPoint?: Point): Promise<void>;
+    scrollUntilLeft(startingPoint?: Point): Promise<void>;
+    scrollUntilRight(startingPoint?: Point): Promise<void>;
+    scrollUp(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollDown(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollLeft(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollRight(distance?: number, startingPoint?: Point): Promise<void>;
+    clearInput(element: ElementInfo): Promise<void>;
+    private latestMouseX;
+    private latestMouseY;
+    mouse: {
+        click: (x: number, y: number, options?: {
+            button?: MouseButton;
+            count?: number;
+        }) => Promise<void>;
+        wheel: (deltaX: number, deltaY: number, startX?: number, startY?: number) => Promise<void>;
+        move: (x: number, y: number) => Promise<void>;
+        drag: (from: {
+            x: number;
+            y: number;
+        }, to: {
+            x: number;
+            y: number;
+        }) => Promise<void>;
+    };
+    keyboard: {
+        type: (text: string) => Promise<void>;
+        press: (action: {
+            key: KeyInput;
+            command?: string;
+        } | {
+            key: KeyInput;
+            command?: string;
+        }[]) => Promise<void>;
+    };
+    destroy(): Promise<void>;
+    longPress(x: number, y: number, duration?: number): Promise<void>;
+    swipe(from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, duration?: number): Promise<void>;
+}

package/dist/types/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/common/cache-helper.d.ts

@@ -0,0 +1,20 @@
+import type { ElementCacheFeature, Rect } from '@midscene/core';
+import type { IModelConfig } from '@midscene/shared/env';
+import type { DebugFunction } from '@midscene/shared/logger';
+export type WebElementCacheFeature = ElementCacheFeature & {
+    xpaths?: string[];
+};
+export declare const sanitizeXpaths: (xpaths: unknown) => string[];
+export interface CacheFeatureOptions {
+    targetDescription?: string;
+    modelConfig?: IModelConfig;
+}
+export declare function judgeOrderSensitive(options: CacheFeatureOptions | undefined, debug: DebugFunction): Promise<boolean>;
+export declare function buildRectFromElementInfo(elementInfo: {
+    rect: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+}): Rect;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { PlaywrightAiFixture } from './playwright';
+export type { PlayWrightAiFixtureType } from './playwright';
+export { Agent as PageAgent, type AgentOpt } from '@midscene/core/agent';
+export { PuppeteerAgent } from './puppeteer';
+export { PlaywrightAgent } from './playwright';
+export { StaticPageAgent, StaticPage } from './static';
+export { WebMidsceneTools } from './mcp-tools';

package/dist/types/mcp-server.d.ts

@@ -0,0 +1,26 @@
+import type { GenericAgent } from '@midscene/shared/mcp';
+import { BaseMCPServer, type Tool } from '@midscene/shared/mcp';
+import { WebMidsceneTools } from './mcp-tools';
+/**
+ * Web MCP Server class
+ */
+export declare class WebMCPServer extends BaseMCPServer {
+    constructor(toolsManager?: WebMidsceneTools);
+    protected createToolsManager(): WebMidsceneTools;
+}
+/**
+ * Create an MCP server launcher for a specific Agent
+ */
+export declare function mcpServerForAgent(agent: GenericAgent): {
+    launch(options?: {
+        verbose?: boolean;
+    }): Promise<import("@midscene/shared/mcp").LaunchMCPServerResult>;
+    launchHttp(options: import("@midscene/shared/mcp").LaunchMCPServerOptions): Promise<import("@midscene/shared/mcp").LaunchMCPServerResult>;
+};
+/**
+ * Create MCP kit for a specific Agent
+ */
+export declare function mcpKitForAgent(agent: GenericAgent): Promise<{
+    description: string;
+    tools: Tool[];
+}>;

package/dist/types/mcp-tools-puppeteer.d.ts

@@ -0,0 +1,13 @@
+import { BaseMidsceneTools, type ToolDefinition } from '@midscene/shared/mcp';
+import { PuppeteerAgent } from './puppeteer';
+import { StaticPage } from './static';
+/**
+ * Tools manager for Web Puppeteer-mode MCP.
+ * Uses a persistent headless Chrome browser that survives across CLI calls.
+ */
+export declare class WebPuppeteerMidsceneTools extends BaseMidsceneTools<PuppeteerAgent> {
+    protected createTemporaryDevice(): StaticPage;
+    protected ensureAgent(navigateToUrl?: string): Promise<PuppeteerAgent>;
+    destroy(): Promise<void>;
+    protected preparePlatformTools(): ToolDefinition[];
+}

package/dist/types/mcp-tools.d.ts

@@ -0,0 +1,12 @@
+import { BaseMidsceneTools, type ToolDefinition } from '@midscene/shared/mcp';
+import { AgentOverChromeBridge } from './bridge-mode';
+import { StaticPage } from './static';
+/**
+ * Tools manager for Web bridge-mode MCP
+ */
+export declare class WebMidsceneTools extends BaseMidsceneTools<AgentOverChromeBridge> {
+    protected createTemporaryDevice(): StaticPage;
+    protected ensureAgent(openNewTabWithUrl?: string): Promise<AgentOverChromeBridge>;
+    private initBridgeModeAgent;
+    protected preparePlatformTools(): ToolDefinition[];
+}

package/dist/types/playwright/ai-fixture.d.ts

@@ -0,0 +1,131 @@
+import { type PlaywrightWebPage } from './index';
+import type { Agent as PageAgent } from '@midscene/core/agent';
+import { type TestInfo, type TestType } from '@playwright/test';
+import type { Page as OriginPlaywrightPage } from 'playwright';
+export type APITestType = Pick<TestType<any, any>, 'step'>;
+export declare const midsceneDumpAnnotationId = "MIDSCENE_DUMP_ANNOTATION";
+type PlaywrightCacheConfig = {
+    strategy?: 'read-only' | 'read-write' | 'write-only';
+    id?: string;
+};
+type PlaywrightCache = false | true | PlaywrightCacheConfig;
+export declare const PlaywrightAiFixture: (options?: {
+    forceSameTabNavigation?: boolean;
+    waitForNetworkIdleTimeout?: number;
+    waitForNavigationTimeout?: number;
+    cache?: PlaywrightCache;
+}) => {
+    agentForPage: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    ai: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiAct: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    /**
+     * @deprecated Use {@link PlaywrightAiFixture.aiAct} instead.
+     */
+    aiAction: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiTap: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiRightClick: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiDoubleClick: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiHover: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiInput: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiKeyboardPress: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiScroll: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiQuery: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiAssert: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiWaitFor: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiLocate: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiNumber: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiString: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiBoolean: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    aiAsk: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    runYaml: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    setAIActionContext: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    evaluateJavaScript: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    recordToReport: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    logScreenshot: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    freezePageContext: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+    unfreezePageContext: ({ page }: {
+        page: OriginPlaywrightPage;
+    }, use: any, testInfo: TestInfo) => Promise<void>;
+};
+export type PlayWrightAiFixtureType = {
+    agentForPage: (page?: any, opts?: any) => Promise<PageAgent<PlaywrightWebPage>>;
+    ai: <T = any>(...args: Parameters<PageAgent['ai']>) => Promise<T>;
+    aiAct: (...args: Parameters<PageAgent['aiAct']>) => ReturnType<PageAgent['aiAct']>;
+    /**
+     * @deprecated Use {@link PlayWrightAiFixtureType.aiAct} instead.
+     */
+    aiAction: (...args: Parameters<PageAgent['aiAction']>) => ReturnType<PageAgent['aiAction']>;
+    aiTap: (...args: Parameters<PageAgent['aiTap']>) => ReturnType<PageAgent['aiTap']>;
+    aiRightClick: (...args: Parameters<PageAgent['aiRightClick']>) => ReturnType<PageAgent['aiRightClick']>;
+    aiDoubleClick: (...args: Parameters<PageAgent['aiDoubleClick']>) => ReturnType<PageAgent['aiDoubleClick']>;
+    aiHover: (...args: Parameters<PageAgent['aiHover']>) => ReturnType<PageAgent['aiHover']>;
+    aiInput: (...args: Parameters<PageAgent['aiInput']>) => ReturnType<PageAgent['aiInput']>;
+    aiKeyboardPress: (...args: Parameters<PageAgent['aiKeyboardPress']>) => ReturnType<PageAgent['aiKeyboardPress']>;
+    aiScroll: (...args: Parameters<PageAgent['aiScroll']>) => ReturnType<PageAgent['aiScroll']>;
+    aiQuery: <T = any>(...args: Parameters<PageAgent['aiQuery']>) => Promise<T>;
+    aiAssert: (...args: Parameters<PageAgent['aiAssert']>) => ReturnType<PageAgent['aiAssert']>;
+    aiWaitFor: (...args: Parameters<PageAgent['aiWaitFor']>) => Promise<void>;
+    aiLocate: (...args: Parameters<PageAgent['aiLocate']>) => ReturnType<PageAgent['aiLocate']>;
+    aiNumber: (...args: Parameters<PageAgent['aiNumber']>) => ReturnType<PageAgent['aiNumber']>;
+    aiString: (...args: Parameters<PageAgent['aiString']>) => ReturnType<PageAgent['aiString']>;
+    aiBoolean: (...args: Parameters<PageAgent['aiBoolean']>) => ReturnType<PageAgent['aiBoolean']>;
+    aiAsk: (...args: Parameters<PageAgent['aiAsk']>) => ReturnType<PageAgent['aiAsk']>;
+    runYaml: (...args: Parameters<PageAgent['runYaml']>) => ReturnType<PageAgent['runYaml']>;
+    setAIActionContext: (...args: Parameters<PageAgent['setAIActionContext']>) => ReturnType<PageAgent['setAIActionContext']>;
+    evaluateJavaScript: (...args: Parameters<PageAgent['evaluateJavaScript']>) => ReturnType<PageAgent['evaluateJavaScript']>;
+    recordToReport: (...args: Parameters<PageAgent['recordToReport']>) => ReturnType<PageAgent['recordToReport']>;
+    logScreenshot: (...args: Parameters<PageAgent['logScreenshot']>) => ReturnType<PageAgent['logScreenshot']>;
+    freezePageContext: (...args: Parameters<PageAgent['freezePageContext']>) => ReturnType<PageAgent['freezePageContext']>;
+    unfreezePageContext: (...args: Parameters<PageAgent['unfreezePageContext']>) => ReturnType<PageAgent['unfreezePageContext']>;
+};
+export {};

package/dist/types/playwright/index.d.ts

@@ -0,0 +1,13 @@
+import { Agent as PageAgent } from '@midscene/core/agent';
+import type { Page as PlaywrightPage } from 'playwright';
+import { WebPage as PlaywrightWebPage } from './page';
+export type { PlayWrightAiFixtureType } from './ai-fixture';
+export { PlaywrightAiFixture } from './ai-fixture';
+export { overrideAIConfig } from '@midscene/shared/env';
+export { WebPage as PlaywrightWebPage } from './page';
+export type { WebPageAgentOpt } from '../web-element';
+import type { WebPageAgentOpt } from '../web-element';
+export declare class PlaywrightAgent extends PageAgent<PlaywrightWebPage> {
+    constructor(page: PlaywrightPage, opts?: WebPageAgentOpt);
+    waitForNetworkIdle(timeout?: number): Promise<void>;
+}

package/dist/types/playwright/page.d.ts

@@ -0,0 +1,11 @@
+import type { Page as PlaywrightPageType } from 'playwright';
+import { Page as BasePage } from '../puppeteer/base-page';
+import type { WebPageOpt } from '../web-element';
+export declare class WebPage extends BasePage<'playwright', PlaywrightPageType> {
+    private playwrightFileChooserHandler?;
+    constructor(page: PlaywrightPageType, opts?: WebPageOpt);
+    registerFileChooserListener(handler: (chooser: import('@midscene/core/device').FileChooserHandler) => Promise<void>): Promise<{
+        dispose: () => void;
+        getError: () => Error | undefined;
+    }>;
+}

package/dist/types/playwright/reporter/index.d.ts

@@ -0,0 +1,42 @@
+import type { FullConfig, Reporter, Suite, TestCase, TestResult } from '@playwright/test/reporter';
+interface MidsceneReporterOptions {
+    type?: 'merged' | 'separate';
+    /**
+     * Output format for the report.
+     * - 'single-html': All screenshots embedded as base64 in a single HTML file (default)
+     * - 'html-and-external-assets': Screenshots saved as separate PNG files in a screenshots/ subdirectory
+     *
+     * Note: 'html-and-external-assets' reports must be served via HTTP server due to CORS restrictions.
+     */
+    outputFormat?: 'single-html' | 'html-and-external-assets';
+}
+declare class MidsceneReporter implements Reporter {
+    private mergedFilename?;
+    private testTitleToFilename;
+    mode?: 'merged' | 'separate';
+    outputFormat: 'single-html' | 'html-and-external-assets';
+    private tempFiles;
+    private pendingReports;
+    private mergedReportInitialized;
+    private writeQueue;
+    private hasMultipleProjects;
+    private writtenScreenshots;
+    constructor(options?: MidsceneReporterOptions);
+    private static getMode;
+    private getSeparatedFilename;
+    private getReportFilename;
+    /**
+     * Get the report path - for directory mode, returns a directory path with index.html
+     */
+    private getReportPath;
+    /**
+     * Copy screenshots from temp location to report screenshots directory
+     */
+    private copyScreenshotsToReport;
+    private updateReport;
+    onBegin(config: FullConfig, suite: Suite): Promise<void>;
+    onTestBegin(_test: TestCase, _result: TestResult): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(): Promise<void>;
+}
+export default MidsceneReporter;

package/dist/types/puppeteer/agent-launcher.d.ts

@@ -0,0 +1,61 @@
+import { PuppeteerAgent } from './index';
+import type { AgentOpt, MidsceneYamlScriptWebEnv } from '@midscene/core';
+import { type Browser, type Page } from 'puppeteer';
+export declare const defaultUA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36";
+export declare const defaultViewportWidth = 1440;
+export declare const defaultViewportHeight = 768;
+export declare const defaultViewportScale = 0;
+export declare const defaultWaitForNetworkIdleTimeout = 2000;
+export declare function resolveAiActionContext(target: MidsceneYamlScriptWebEnv, preference?: Partial<Pick<AgentOpt, 'aiActionContext' | 'aiActContext'>>): AgentOpt['aiActionContext'] | undefined;
+interface FreeFn {
+    name: string;
+    fn: () => void;
+}
+export interface BuildChromeArgsOptions {
+    userAgent?: string;
+    windowSize?: {
+        width: number;
+        height: number;
+    };
+    chromeArgs?: string[];
+}
+/**
+ * Builds Chrome launch arguments with sensible defaults.
+ *
+ * Platform-specific behavior:
+ * - On non-Windows systems, automatically adds --no-sandbox and --disable-setuid-sandbox
+ *   for compatibility with containerized/CI environments
+ *
+ * @param options - Configuration options for Chrome arguments
+ * @returns Array of Chrome launch arguments
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const args = buildChromeArgs();
+ *
+ * // With custom arguments
+ * const args = buildChromeArgs({
+ *   chromeArgs: ['--disable-gpu', '--disable-dev-shm-usage'],
+ *   userAgent: 'CustomUA/1.0',
+ *   windowSize: { width: 1920, height: 1080 },
+ * });
+ * ```
+ */
+export declare function buildChromeArgs(options?: BuildChromeArgsOptions): string[];
+export declare function launchPuppeteerPage(target: MidsceneYamlScriptWebEnv, preference?: {
+    headed?: boolean;
+    keepWindow?: boolean;
+    ignoreDefaultArgs?: boolean | string[];
+}, browser?: Browser, existingPage?: Page): Promise<{
+    page: Page;
+    freeFn: FreeFn[];
+}>;
+export declare function puppeteerAgentForTarget(target: MidsceneYamlScriptWebEnv, preference?: {
+    headed?: boolean;
+    keepWindow?: boolean;
+} & Partial<Pick<AgentOpt, 'testId' | 'groupName' | 'groupDescription' | 'generateReport' | 'autoPrintReportMsg' | 'reportFileName' | 'replanningCycleLimit' | 'cache' | 'aiActionContext'>>, browser?: Browser, existingPage?: Page): Promise<{
+    agent: PuppeteerAgent;
+    freeFn: FreeFn[];
+}>;
+export {};