@midscene/computer-playground 1.6.0 → 1.6.1-beta-20260327104111.0

package/dist/es/bin.mjs

@@ -1,6 +1,6 @@
 import node_os from "node:os";
 import node_path from "node:path";
-import { ComputerDevice, agentFromComputer, checkAccessibilityPermission } from "@midscene/computer";
+import { ComputerDevice, agentFromComputer, checkAccessibilityPermission, getConnectedDisplays } from "@midscene/computer";
 import { createScreenshotPreviewDescriptor, definePlaygroundPlatform, launchPreparedPlaygroundPlatform } from "@midscene/playground";
 import puppeteer from "puppeteer";
 import { PLAYGROUND_SERVER_PORT } from "@midscene/shared/constants";
@@ -60,47 +60,104 @@ const computerPlaygroundPlatform = definePlaygroundPlatform({
     description: "Computer playground platform descriptor",
     async prepare (options) {
         const accessibilityCheck = checkAccessibilityPermission(true);
-        if (!accessibilityCheck.hasPermission) {
-            console.error('❌ Permission Error:\n');
-            console.error(accessibilityCheck.error);
-            process.exit(1);
-        }
         const staticDir = options?.staticDir || node_path.join(__dirname, '../../static');
         const availablePort = await findAvailablePort(PLAYGROUND_SERVER_PORT);
         if (availablePort !== PLAYGROUND_SERVER_PORT) console.log(`⚠️  Port ${PLAYGROUND_SERVER_PORT} is busy, using port ${availablePort} instead`);
+        const sessionManager = {
+            async getSetupSchema () {
+                const displays = await getConnectedDisplays();
+                const defaultDisplay = displays.find((display)=>display.primary) || displays[0];
+                return {
+                    title: 'Connect Computer Agent',
+                    description: accessibilityCheck.hasPermission ? 'Create a Computer Agent for the selected display.' : accessibilityCheck.error,
+                    primaryActionLabel: 'Create Agent',
+                    fields: [
+                        {
+                            key: 'displayId',
+                            label: 'Display',
+                            type: 'select',
+                            required: true,
+                            options: displays.map((display)=>({
+                                    label: display.name,
+                                    value: String(display.id),
+                                    description: display.primary ? 'Primary display' : void 0
+                                })),
+                            defaultValue: defaultDisplay ? String(defaultDisplay.id) : '',
+                            placeholder: 'Select a display'
+                        }
+                    ],
+                    targets: displays.map((display)=>({
+                            id: String(display.id),
+                            label: display.name,
+                            description: display.primary ? 'Primary display' : void 0,
+                            isDefault: display.primary
+                        }))
+                };
+            },
+            async listTargets () {
+                const displays = await getConnectedDisplays();
+                return displays.map((display)=>({
+                        id: String(display.id),
+                        label: display.name,
+                        description: display.primary ? 'Primary display' : void 0,
+                        isDefault: display.primary
+                    }));
+            },
+            async createSession (input) {
+                if (!accessibilityCheck.hasPermission) throw new Error(accessibilityCheck.error || 'Accessibility permission is required');
+                const displayId = input?.displayId === void 0 || null === input.displayId ? void 0 : String(input.displayId);
+                const agent = await agentFromComputer(displayId ? {
+                    displayId
+                } : void 0);
+                const displays = await getConnectedDisplays();
+                const selectedDisplay = displays.find((display)=>display.id === displayId) || displays.find((display)=>display.primary) || displays[0];
+                return {
+                    agent,
+                    agentFactory: ()=>agentFromComputer(selectedDisplay ? {
+                            displayId: selectedDisplay.id
+                        } : void 0),
+                    preview: createScreenshotPreviewDescriptor({
+                        title: 'Desktop preview'
+                    }),
+                    displayName: selectedDisplay?.name || 'Desktop',
+                    metadata: {
+                        displayId: selectedDisplay?.id,
+                        executionUx: 'countdown-before-run'
+                    }
+                };
+            }
+        };
         return {
             platformId: 'computer',
             title: 'Midscene Computer Playground',
-            agentFactory: agentFromComputer,
+            sessionManager,
             launchOptions: {
                 port: availablePort,
                 openBrowser: false,
                 verbose: false,
-                staticPath: staticDir,
-                configureServer (server) {
-                    server.app.use('/execute', async (_req, res, next)=>{
-                        const windowController = options?.getWindowController?.();
-                        if (!windowController) {
-                            console.warn('⚠️  Window controller not initialized yet, skipping window control');
-                            next();
-                            return;
-                        }
-                        await new Promise((resolve)=>setTimeout(resolve, 1500));
-                        await windowController.minimize();
-                        const originalSend = res.send.bind(res);
-                        res.send = (body)=>{
-                            windowController.restore();
-                            return originalSend(body);
-                        };
-                        next();
-                    });
+                staticPath: staticDir
+            },
+            executionHooks: {
+                async beforeExecute () {
+                    const windowController = options?.getWindowController?.();
+                    if (!windowController) return void console.warn('⚠️  Window controller not initialized yet, skipping window control');
+                    await new Promise((resolve)=>setTimeout(resolve, 1500));
+                    await windowController.minimize();
+                },
+                async afterExecute () {
+                    const windowController = options?.getWindowController?.();
+                    if (!windowController) return;
+                    await windowController.restore();
                 }
             },
             preview: createScreenshotPreviewDescriptor({
                 title: 'Desktop preview'
             }),
             metadata: {
-                executionUx: 'countdown-before-run'
+                executionUx: 'countdown-before-run',
+                sessionConnected: false,
+                setupState: accessibilityCheck.hasPermission ? 'required' : 'blocked',
+                setupBlockingReason: accessibilityCheck.error
             }
         };
     }

package/dist/es/index.mjs

@@ -0,0 +1,163 @@
+import node_path from "node:path";
+import { agentFromComputer, checkAccessibilityPermission, getConnectedDisplays } from "@midscene/computer";
+import { createScreenshotPreviewDescriptor, definePlaygroundPlatform } from "@midscene/playground";
+import { PLAYGROUND_SERVER_PORT } from "@midscene/shared/constants";
+import { findAvailablePort } from "@midscene/shared/node";
+const computerPlaygroundPlatform = definePlaygroundPlatform({
+    id: 'computer',
+    title: 'Midscene Computer Playground',
+    description: "Computer playground platform descriptor",
+    async prepare (options) {
+        const accessibilityCheck = checkAccessibilityPermission(true);
+        const staticDir = options?.staticDir || node_path.join(__dirname, '../../static');
+        const availablePort = await findAvailablePort(PLAYGROUND_SERVER_PORT);
+        if (availablePort !== PLAYGROUND_SERVER_PORT) console.log(`⚠️  Port ${PLAYGROUND_SERVER_PORT} is busy, using port ${availablePort} instead`);
+        const sessionManager = {
+            async getSetupSchema () {
+                const displays = await getConnectedDisplays();
+                const defaultDisplay = displays.find((display)=>display.primary) || displays[0];
+                return {
+                    title: 'Connect Computer Agent',
+                    description: accessibilityCheck.hasPermission ? 'Create a Computer Agent for the selected display.' : accessibilityCheck.error,
+                    primaryActionLabel: 'Create Agent',
+                    fields: [
+                        {
+                            key: 'displayId',
+                            label: 'Display',
+                            type: 'select',
+                            required: true,
+                            options: displays.map((display)=>({
+                                    label: display.name,
+                                    value: String(display.id),
+                                    description: display.primary ? 'Primary display' : void 0
+                                })),
+                            defaultValue: defaultDisplay ? String(defaultDisplay.id) : '',
+                            placeholder: 'Select a display'
+                        }
+                    ],
+                    targets: displays.map((display)=>({
+                            id: String(display.id),
+                            label: display.name,
+                            description: display.primary ? 'Primary display' : void 0,
+                            isDefault: display.primary
+                        }))
+                };
+            },
+            async listTargets () {
+                const displays = await getConnectedDisplays();
+                return displays.map((display)=>({
+                        id: String(display.id),
+                        label: display.name,
+                        description: display.primary ? 'Primary display' : void 0,
+                        isDefault: display.primary
+                    }));
+            },
+            async createSession (input) {
+                if (!accessibilityCheck.hasPermission) throw new Error(accessibilityCheck.error || 'Accessibility permission is required');
+                const displayId = input?.displayId === void 0 || null === input.displayId ? void 0 : String(input.displayId);
+                const agent = await agentFromComputer(displayId ? {
+                    displayId
+                } : void 0);
+                const displays = await getConnectedDisplays();
+                const selectedDisplay = displays.find((display)=>display.id === displayId) || displays.find((display)=>display.primary) || displays[0];
+                return {
+                    agent,
+                    agentFactory: ()=>agentFromComputer(selectedDisplay ? {
+                            displayId: selectedDisplay.id
+                        } : void 0),
+                    preview: createScreenshotPreviewDescriptor({
+                        title: 'Desktop preview'
+                    }),
+                    displayName: selectedDisplay?.name || 'Desktop',
+                    metadata: {
+                        displayId: selectedDisplay?.id,
+                        executionUx: 'countdown-before-run'
+                    }
+                };
+            }
+        };
+        return {
+            platformId: 'computer',
+            title: 'Midscene Computer Playground',
+            sessionManager,
+            launchOptions: {
+                port: availablePort,
+                openBrowser: false,
+                verbose: false,
+                staticPath: staticDir
+            },
+            executionHooks: {
+                async beforeExecute () {
+                    const windowController = options?.getWindowController?.();
+                    if (!windowController) return void console.warn('⚠️  Window controller not initialized yet, skipping window control');
+                    await new Promise((resolve)=>setTimeout(resolve, 1500));
+                    await windowController.minimize();
+                },
+                async afterExecute () {
+                    const windowController = options?.getWindowController?.();
+                    if (!windowController) return;
+                    await windowController.restore();
+                }
+            },
+            preview: createScreenshotPreviewDescriptor({
+                title: 'Desktop preview'
+            }),
+            metadata: {
+                executionUx: 'countdown-before-run',
+                sessionConnected: false,
+                setupState: accessibilityCheck.hasPermission ? 'required' : 'blocked',
+                setupBlockingReason: accessibilityCheck.error
+            }
+        };
+    }
+});
+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 BrowserWindowController {
+    async minimize() {
+        try {
+            await this.session.send('Browser.setWindowBounds', {
+                windowId: this.windowId,
+                bounds: {
+                    windowState: 'minimized'
+                }
+            });
+            console.log('🔽 Window minimized, starting task execution...');
+        } catch (error) {
+            console.warn('⚠️  Failed to minimize window:', error);
+        }
+    }
+    async restore() {
+        try {
+            await Promise.all([
+                this.session.send('Browser.setWindowBounds', {
+                    windowId: this.windowId,
+                    bounds: {
+                        windowState: 'normal'
+                    }
+                }),
+                this.page.bringToFront()
+            ]);
+            console.log('🔼 Window restored');
+        } catch (error) {
+            console.warn('⚠️  Failed to restore window:', error);
+        }
+    }
+    constructor(session, page, windowId){
+        _define_property(this, "session", void 0);
+        _define_property(this, "page", void 0);
+        _define_property(this, "windowId", void 0);
+        this.session = session;
+        this.page = page;
+        this.windowId = windowId;
+    }
+}
+export { BrowserWindowController, computerPlaygroundPlatform };

package/dist/lib/bin.js

@@ -86,47 +86,104 @@ const computerPlaygroundPlatform = (0, playground_namespaceObject.definePlaygrou
     description: "Computer playground platform descriptor",
     async prepare (options) {
         const accessibilityCheck = (0, computer_namespaceObject.checkAccessibilityPermission)(true);
-        if (!accessibilityCheck.hasPermission) {
-            console.error('❌ Permission Error:\n');
-            console.error(accessibilityCheck.error);
-            process.exit(1);
-        }
         const staticDir = options?.staticDir || external_node_path_default().join(__dirname, '../../static');
         const availablePort = await (0, node_namespaceObject.findAvailablePort)(constants_namespaceObject.PLAYGROUND_SERVER_PORT);
         if (availablePort !== constants_namespaceObject.PLAYGROUND_SERVER_PORT) console.log(`⚠️  Port ${constants_namespaceObject.PLAYGROUND_SERVER_PORT} is busy, using port ${availablePort} instead`);
+        const sessionManager = {
+            async getSetupSchema () {
+                const displays = await (0, computer_namespaceObject.getConnectedDisplays)();
+                const defaultDisplay = displays.find((display)=>display.primary) || displays[0];
+                return {
+                    title: 'Connect Computer Agent',
+                    description: accessibilityCheck.hasPermission ? 'Create a Computer Agent for the selected display.' : accessibilityCheck.error,
+                    primaryActionLabel: 'Create Agent',
+                    fields: [
+                        {
+                            key: 'displayId',
+                            label: 'Display',
+                            type: 'select',
+                            required: true,
+                            options: displays.map((display)=>({
+                                    label: display.name,
+                                    value: String(display.id),
+                                    description: display.primary ? 'Primary display' : void 0
+                                })),
+                            defaultValue: defaultDisplay ? String(defaultDisplay.id) : '',
+                            placeholder: 'Select a display'
+                        }
+                    ],
+                    targets: displays.map((display)=>({
+                            id: String(display.id),
+                            label: display.name,
+                            description: display.primary ? 'Primary display' : void 0,
+                            isDefault: display.primary
+                        }))
+                };
+            },
+            async listTargets () {
+                const displays = await (0, computer_namespaceObject.getConnectedDisplays)();
+                return displays.map((display)=>({
+                        id: String(display.id),
+                        label: display.name,
+                        description: display.primary ? 'Primary display' : void 0,
+                        isDefault: display.primary
+                    }));
+            },
+            async createSession (input) {
+                if (!accessibilityCheck.hasPermission) throw new Error(accessibilityCheck.error || 'Accessibility permission is required');
+                const displayId = input?.displayId === void 0 || null === input.displayId ? void 0 : String(input.displayId);
+                const agent = await (0, computer_namespaceObject.agentFromComputer)(displayId ? {
+                    displayId
+                } : void 0);
+                const displays = await (0, computer_namespaceObject.getConnectedDisplays)();
+                const selectedDisplay = displays.find((display)=>display.id === displayId) || displays.find((display)=>display.primary) || displays[0];
+                return {
+                    agent,
+                    agentFactory: ()=>(0, computer_namespaceObject.agentFromComputer)(selectedDisplay ? {
+                            displayId: selectedDisplay.id
+                        } : void 0),
+                    preview: (0, playground_namespaceObject.createScreenshotPreviewDescriptor)({
+                        title: 'Desktop preview'
+                    }),
+                    displayName: selectedDisplay?.name || 'Desktop',
+                    metadata: {
+                        displayId: selectedDisplay?.id,
+                        executionUx: 'countdown-before-run'
+                    }
+                };
+            }
+        };
         return {
             platformId: 'computer',
             title: 'Midscene Computer Playground',
-            agentFactory: computer_namespaceObject.agentFromComputer,
+            sessionManager,
             launchOptions: {
                 port: availablePort,
                 openBrowser: false,
                 verbose: false,
-                staticPath: staticDir,
-                configureServer (server) {
-                    server.app.use('/execute', async (_req, res, next)=>{
-                        const windowController = options?.getWindowController?.();
-                        if (!windowController) {
-                            console.warn('⚠️  Window controller not initialized yet, skipping window control');
-                            next();
-                            return;
-                        }
-                        await new Promise((resolve)=>setTimeout(resolve, 1500));
-                        await windowController.minimize();
-                        const originalSend = res.send.bind(res);
-                        res.send = (body)=>{
-                            windowController.restore();
-                            return originalSend(body);
-                        };
-                        next();
-                    });
+                staticPath: staticDir
+            },
+            executionHooks: {
+                async beforeExecute () {
+                    const windowController = options?.getWindowController?.();
+                    if (!windowController) return void console.warn('⚠️  Window controller not initialized yet, skipping window control');
+                    await new Promise((resolve)=>setTimeout(resolve, 1500));
+                    await windowController.minimize();
+                },
+                async afterExecute () {
+                    const windowController = options?.getWindowController?.();
+                    if (!windowController) return;
+                    await windowController.restore();
                 }
             },
             preview: (0, playground_namespaceObject.createScreenshotPreviewDescriptor)({
                 title: 'Desktop preview'
             }),
             metadata: {
-                executionUx: 'countdown-before-run'
+                executionUx: 'countdown-before-run',
+                sessionConnected: false,
+                setupState: accessibilityCheck.hasPermission ? 'required' : 'blocked',
+                setupBlockingReason: accessibilityCheck.error
             }
         };
     }

package/dist/lib/index.js

@@ -0,0 +1,210 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    BrowserWindowController: ()=>BrowserWindowController,
+    computerPlaygroundPlatform: ()=>computerPlaygroundPlatform
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const computer_namespaceObject = require("@midscene/computer");
+const playground_namespaceObject = require("@midscene/playground");
+const constants_namespaceObject = require("@midscene/shared/constants");
+const node_namespaceObject = require("@midscene/shared/node");
+const computerPlaygroundPlatform = (0, playground_namespaceObject.definePlaygroundPlatform)({
+    id: 'computer',
+    title: 'Midscene Computer Playground',
+    description: "Computer playground platform descriptor",
+    async prepare (options) {
+        const accessibilityCheck = (0, computer_namespaceObject.checkAccessibilityPermission)(true);
+        const staticDir = options?.staticDir || external_node_path_default().join(__dirname, '../../static');
+        const availablePort = await (0, node_namespaceObject.findAvailablePort)(constants_namespaceObject.PLAYGROUND_SERVER_PORT);
+        if (availablePort !== constants_namespaceObject.PLAYGROUND_SERVER_PORT) console.log(`⚠️  Port ${constants_namespaceObject.PLAYGROUND_SERVER_PORT} is busy, using port ${availablePort} instead`);
+        const sessionManager = {
+            async getSetupSchema () {
+                const displays = await (0, computer_namespaceObject.getConnectedDisplays)();
+                const defaultDisplay = displays.find((display)=>display.primary) || displays[0];
+                return {
+                    title: 'Connect Computer Agent',
+                    description: accessibilityCheck.hasPermission ? 'Create a Computer Agent for the selected display.' : accessibilityCheck.error,
+                    primaryActionLabel: 'Create Agent',
+                    fields: [
+                        {
+                            key: 'displayId',
+                            label: 'Display',
+                            type: 'select',
+                            required: true,
+                            options: displays.map((display)=>({
+                                    label: display.name,
+                                    value: String(display.id),
+                                    description: display.primary ? 'Primary display' : void 0
+                                })),
+                            defaultValue: defaultDisplay ? String(defaultDisplay.id) : '',
+                            placeholder: 'Select a display'
+                        }
+                    ],
+                    targets: displays.map((display)=>({
+                            id: String(display.id),
+                            label: display.name,
+                            description: display.primary ? 'Primary display' : void 0,
+                            isDefault: display.primary
+                        }))
+                };
+            },
+            async listTargets () {
+                const displays = await (0, computer_namespaceObject.getConnectedDisplays)();
+                return displays.map((display)=>({
+                        id: String(display.id),
+                        label: display.name,
+                        description: display.primary ? 'Primary display' : void 0,
+                        isDefault: display.primary
+                    }));
+            },
+            async createSession (input) {
+                if (!accessibilityCheck.hasPermission) throw new Error(accessibilityCheck.error || 'Accessibility permission is required');
+                const displayId = input?.displayId === void 0 || null === input.displayId ? void 0 : String(input.displayId);
+                const agent = await (0, computer_namespaceObject.agentFromComputer)(displayId ? {
+                    displayId
+                } : void 0);
+                const displays = await (0, computer_namespaceObject.getConnectedDisplays)();
+                const selectedDisplay = displays.find((display)=>display.id === displayId) || displays.find((display)=>display.primary) || displays[0];
+                return {
+                    agent,
+                    agentFactory: ()=>(0, computer_namespaceObject.agentFromComputer)(selectedDisplay ? {
+                            displayId: selectedDisplay.id
+                        } : void 0),
+                    preview: (0, playground_namespaceObject.createScreenshotPreviewDescriptor)({
+                        title: 'Desktop preview'
+                    }),
+                    displayName: selectedDisplay?.name || 'Desktop',
+                    metadata: {
+                        displayId: selectedDisplay?.id,
+                        executionUx: 'countdown-before-run'
+                    }
+                };
+            }
+        };
+        return {
+            platformId: 'computer',
+            title: 'Midscene Computer Playground',
+            sessionManager,
+            launchOptions: {
+                port: availablePort,
+                openBrowser: false,
+                verbose: false,
+                staticPath: staticDir
+            },
+            executionHooks: {
+                async beforeExecute () {
+                    const windowController = options?.getWindowController?.();
+                    if (!windowController) return void console.warn('⚠️  Window controller not initialized yet, skipping window control');
+                    await new Promise((resolve)=>setTimeout(resolve, 1500));
+                    await windowController.minimize();
+                },
+                async afterExecute () {
+                    const windowController = options?.getWindowController?.();
+                    if (!windowController) return;
+                    await windowController.restore();
+                }
+            },
+            preview: (0, playground_namespaceObject.createScreenshotPreviewDescriptor)({
+                title: 'Desktop preview'
+            }),
+            metadata: {
+                executionUx: 'countdown-before-run',
+                sessionConnected: false,
+                setupState: accessibilityCheck.hasPermission ? 'required' : 'blocked',
+                setupBlockingReason: accessibilityCheck.error
+            }
+        };
+    }
+});
+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 BrowserWindowController {
+    async minimize() {
+        try {
+            await this.session.send('Browser.setWindowBounds', {
+                windowId: this.windowId,
+                bounds: {
+                    windowState: 'minimized'
+                }
+            });
+            console.log('🔽 Window minimized, starting task execution...');
+        } catch (error) {
+            console.warn('⚠️  Failed to minimize window:', error);
+        }
+    }
+    async restore() {
+        try {
+            await Promise.all([
+                this.session.send('Browser.setWindowBounds', {
+                    windowId: this.windowId,
+                    bounds: {
+                        windowState: 'normal'
+                    }
+                }),
+                this.page.bringToFront()
+            ]);
+            console.log('🔼 Window restored');
+        } catch (error) {
+            console.warn('⚠️  Failed to restore window:', error);
+        }
+    }
+    constructor(session, page, windowId){
+        _define_property(this, "session", void 0);
+        _define_property(this, "page", void 0);
+        _define_property(this, "windowId", void 0);
+        this.session = session;
+        this.page = page;
+        this.windowId = windowId;
+    }
+}
+exports.BrowserWindowController = __webpack_exports__.BrowserWindowController;
+exports.computerPlaygroundPlatform = __webpack_exports__.computerPlaygroundPlatform;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BrowserWindowController",
+    "computerPlaygroundPlatform"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+import type { CDPSession } from 'puppeteer';
+import type { Page } from 'puppeteer';
+import { PlaygroundPlatformDescriptor } from '@midscene/playground';
+
+/**
+ * Controls browser window state (minimize/restore) during task execution
+ * to avoid interference between the playground UI and desktop automation.
+ */
+export declare class BrowserWindowController {
+    private session;
+    private page;
+    private windowId;
+    constructor(session: CDPSession, page: Page, windowId: number);
+    minimize(): Promise<void>;
+    restore(): Promise<void>;
+}
+
+export declare interface ComputerPlatformOptions {
+    staticDir?: string;
+    getWindowController?: () => BrowserWindowController | null;
+}
+
+export declare const computerPlaygroundPlatform: PlaygroundPlatformDescriptor<ComputerPlatformOptions | undefined>;
+
+export { }