@sqaitech/playground 0.5.0

package/dist/lib/sdk/index.js

@@ -0,0 +1,136 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    PlaygroundSDK: ()=>PlaygroundSDK
+});
+const constants_namespaceObject = require("@sqaitech/shared/constants");
+const local_execution_js_namespaceObject = require("../adapters/local-execution.js");
+const remote_execution_js_namespaceObject = require("../adapters/remote-execution.js");
+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 PlaygroundSDK {
+    createAdapter(type, serverUrl, agent) {
+        switch(type){
+            case 'local-execution':
+                if (!agent) throw new Error('Agent is required for local execution');
+                return new local_execution_js_namespaceObject.LocalExecutionAdapter(agent);
+            case 'remote-execution':
+                {
+                    const finalServerUrl = serverUrl || ('undefined' != typeof window && window.location.protocol.includes('http') ? window.location.origin : `http://localhost:${constants_namespaceObject.PLAYGROUND_SERVER_PORT}`);
+                    return new remote_execution_js_namespaceObject.RemoteExecutionAdapter(finalServerUrl);
+                }
+            default:
+                throw new Error(`Unsupported execution type: ${type}`);
+        }
+    }
+    async executeAction(actionType, value, options) {
+        const result = await this.adapter.executeAction(actionType, value, options);
+        if (options.requestId) this.stopProgressPolling(options.requestId);
+        return result;
+    }
+    async getActionSpace(context) {
+        return this.adapter.getActionSpace(context);
+    }
+    validateStructuredParams(value, action) {
+        return this.adapter.validateParams(value, action);
+    }
+    formatErrorMessage(error) {
+        return this.adapter.formatErrorMessage(error);
+    }
+    createDisplayContent(value, needsStructuredParams, action) {
+        return this.adapter.createDisplayContent(value, needsStructuredParams, action);
+    }
+    get id() {
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) return this.adapter.id;
+        if (this.adapter instanceof local_execution_js_namespaceObject.LocalExecutionAdapter) return this.adapter.id;
+    }
+    async checkStatus() {
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) return this.adapter.checkStatus();
+        return true;
+    }
+    async overrideConfig(aiConfig) {
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) return this.adapter.overrideConfig(aiConfig);
+    }
+    async getTaskProgress(requestId) {
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) return this.adapter.getTaskProgress(requestId);
+        if (this.adapter instanceof local_execution_js_namespaceObject.LocalExecutionAdapter) return this.adapter.getTaskProgress(requestId);
+        return {
+            tip: void 0
+        };
+    }
+    async cancelTask(requestId) {
+        this.stopProgressPolling(requestId);
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) return this.adapter.cancelTask(requestId);
+        return {
+            error: 'Cancel task not supported in local execution mode'
+        };
+    }
+    onProgressUpdate(callback) {
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) this.adapter.setProgressCallback(callback);
+        else if (this.adapter instanceof local_execution_js_namespaceObject.LocalExecutionAdapter) this.adapter.setProgressCallback(callback);
+    }
+    startProgressPolling(requestId) {
+        console.warn('startProgressPolling is deprecated - polling is now automatic');
+    }
+    stopProgressPolling(requestId) {
+        console.warn('stopProgressPolling is deprecated - polling cleanup is now automatic');
+    }
+    async cancelExecution(requestId) {
+        this.stopProgressPolling(requestId);
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) await this.adapter.cancelTask(requestId);
+        else if (this.adapter instanceof local_execution_js_namespaceObject.LocalExecutionAdapter) console.warn('Local execution cancellation not fully implemented');
+    }
+    async getScreenshot() {
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) return this.adapter.getScreenshot();
+        return null;
+    }
+    async getInterfaceInfo() {
+        if (this.adapter instanceof local_execution_js_namespaceObject.LocalExecutionAdapter) return this.adapter.getInterfaceInfo();
+        if (this.adapter instanceof remote_execution_js_namespaceObject.RemoteExecutionAdapter) return this.adapter.getInterfaceInfo();
+        return null;
+    }
+    constructor(config){
+        _define_property(this, "adapter", void 0);
+        this.adapter = this.createAdapter(config.type, config.serverUrl, config.agent);
+    }
+}
+exports.PlaygroundSDK = __webpack_exports__.PlaygroundSDK;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "PlaygroundSDK"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.js.map

package/dist/lib/sdk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk\\index.js","sources":["webpack://@sqaitech/playground/webpack/runtime/define_property_getters","webpack://@sqaitech/playground/webpack/runtime/has_own_property","webpack://@sqaitech/playground/webpack/runtime/make_namespace_object","webpack://@sqaitech/playground/./src/sdk/index.ts"],"sourcesContent":["__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n        }\n    }\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","import type { DeviceAction } from '@sqaitech/core';\r\nimport { PLAYGROUND_SERVER_PORT } from '@sqaitech/shared/constants';\r\nimport type { BasePlaygroundAdapter } from '../adapters/base';\r\nimport { LocalExecutionAdapter } from '../adapters/local-execution';\r\nimport { RemoteExecutionAdapter } from '../adapters/remote-execution';\r\nimport type {\r\n  ExecutionOptions,\r\n  FormValue,\r\n  PlaygroundAgent,\r\n  PlaygroundConfig,\r\n  ValidationResult,\r\n} from '../types';\r\n\r\nexport class PlaygroundSDK {\r\n  private adapter: BasePlaygroundAdapter;\r\n\r\n  constructor(config: PlaygroundConfig) {\r\n    this.adapter = this.createAdapter(\r\n      config.type,\r\n      config.serverUrl,\r\n      config.agent,\r\n    );\r\n  }\r\n\r\n  private createAdapter(\r\n    type: string,\r\n    serverUrl?: string,\r\n    agent?: PlaygroundAgent,\r\n  ): BasePlaygroundAdapter {\r\n    switch (type) {\r\n      case 'local-execution':\r\n        if (!agent) {\r\n          throw new Error('Agent is required for local execution');\r\n        }\r\n        return new LocalExecutionAdapter(agent);\r\n      case 'remote-execution': {\r\n        // Use provided serverUrl first, then fallback to localhost if current page origin is file:// or default\r\n        const finalServerUrl =\r\n          serverUrl ||\r\n          (typeof window !== 'undefined' &&\r\n          window.location.protocol.includes('http')\r\n            ? window.location.origin\r\n            : `http://localhost:${PLAYGROUND_SERVER_PORT}`);\r\n\r\n        return new RemoteExecutionAdapter(finalServerUrl);\r\n      }\r\n      default:\r\n        throw new Error(`Unsupported execution type: ${type}`);\r\n    }\r\n  }\r\n\r\n  async executeAction(\r\n    actionType: string,\r\n    value: FormValue,\r\n    options: ExecutionOptions,\r\n  ): Promise<unknown> {\r\n    const result = await this.adapter.executeAction(actionType, value, options);\r\n\r\n    // Stop any active polling for this request after execution completes\r\n    if (options.requestId) {\r\n      this.stopProgressPolling(options.requestId);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  async getActionSpace(context?: unknown): Promise<DeviceAction<unknown>[]> {\r\n    // Both adapters now accept context parameter\r\n    // Local will prioritize internal agent, Remote will use server + fallback\r\n    return this.adapter.getActionSpace(context);\r\n  }\r\n\r\n  validateStructuredParams(\r\n    value: FormValue,\r\n    action: DeviceAction<unknown> | undefined,\r\n  ): ValidationResult {\r\n    return this.adapter.validateParams(value, action);\r\n  }\r\n\r\n  formatErrorMessage(error: any): string {\r\n    return this.adapter.formatErrorMessage(error);\r\n  }\r\n\r\n  createDisplayContent(\r\n    value: FormValue,\r\n    needsStructuredParams: boolean,\r\n    action: DeviceAction<unknown> | undefined,\r\n  ): string {\r\n    return this.adapter.createDisplayContent(\r\n      value,\r\n      needsStructuredParams,\r\n      action,\r\n    );\r\n  }\r\n\r\n  // Get adapter ID (works for both remote and local execution)\r\n  get id(): string | undefined {\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      return this.adapter.id;\r\n    }\r\n    if (this.adapter instanceof LocalExecutionAdapter) {\r\n      return this.adapter.id;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  // Server communication methods (for remote execution)\r\n  async checkStatus(): Promise<boolean> {\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      return this.adapter.checkStatus();\r\n    }\r\n    return true; // For local execution, always return true\r\n  }\r\n\r\n  async overrideConfig(aiConfig: any): Promise<void> {\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      return this.adapter.overrideConfig(aiConfig);\r\n    }\r\n    // For local execution, this is a no-op\r\n  }\r\n\r\n  async getTaskProgress(requestId: string): Promise<{ tip?: string }> {\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      return this.adapter.getTaskProgress(requestId);\r\n    }\r\n    if (this.adapter instanceof LocalExecutionAdapter) {\r\n      return this.adapter.getTaskProgress(requestId);\r\n    }\r\n    return { tip: undefined }; // Fallback\r\n  }\r\n\r\n  // Cancel task (for remote execution)\r\n  async cancelTask(requestId: string): Promise<any> {\r\n    // Stop progress polling for this request\r\n    this.stopProgressPolling(requestId);\r\n\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      return this.adapter.cancelTask(requestId);\r\n    }\r\n    return { error: 'Cancel task not supported in local execution mode' };\r\n  }\r\n\r\n  // Progress callback management\r\n  onProgressUpdate(callback: (tip: string) => void): void {\r\n    // Pass the callback to the adapter if it supports it\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      this.adapter.setProgressCallback(callback);\r\n    } else if (this.adapter instanceof LocalExecutionAdapter) {\r\n      this.adapter.setProgressCallback(callback);\r\n    }\r\n  }\r\n\r\n  // Start progress polling for remote execution (deprecated - now handled by adapter)\r\n  startProgressPolling(requestId: string): void {\r\n    // This method is now handled by the RemoteExecutionAdapter automatically\r\n    // when executeAction is called with a requestId\r\n    console.warn(\r\n      'startProgressPolling is deprecated - polling is now automatic',\r\n    );\r\n  }\r\n\r\n  // Stop progress polling for a specific request (deprecated - now handled by adapter)\r\n  stopProgressPolling(requestId: string): void {\r\n    // This method is now handled by the RemoteExecutionAdapter automatically\r\n    console.warn(\r\n      'stopProgressPolling is deprecated - polling cleanup is now automatic',\r\n    );\r\n  }\r\n\r\n  // Cancel execution - supports both remote and local\r\n  async cancelExecution(requestId: string): Promise<void> {\r\n    this.stopProgressPolling(requestId);\r\n\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      await this.adapter.cancelTask(requestId);\r\n    } else if (this.adapter instanceof LocalExecutionAdapter) {\r\n      // For local execution, we might need to implement agent cancellation\r\n      console.warn('Local execution cancellation not fully implemented');\r\n    }\r\n  }\r\n\r\n  // Screenshot method for remote execution\r\n  async getScreenshot(): Promise<{\r\n    screenshot: string;\r\n    timestamp: number;\r\n  } | null> {\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      return this.adapter.getScreenshot();\r\n    }\r\n    return null; // For local execution, not supported yet\r\n  }\r\n\r\n  // Get interface information (type and description)\r\n  async getInterfaceInfo(): Promise<{\r\n    type: string;\r\n    description?: string;\r\n  } | null> {\r\n    if (this.adapter instanceof LocalExecutionAdapter) {\r\n      return this.adapter.getInterfaceInfo();\r\n    }\r\n    if (this.adapter instanceof RemoteExecutionAdapter) {\r\n      return this.adapter.getInterfaceInfo();\r\n    }\r\n    return null;\r\n  }\r\n}\r\n"],"names":["__webpack_require__","definition","key","Object","obj","prop","Symbol","PlaygroundSDK","type","serverUrl","agent","Error","LocalExecutionAdapter","finalServerUrl","window","PLAYGROUND_SERVER_PORT","RemoteExecutionAdapter","actionType","value","options","result","context","action","error","needsStructuredParams","aiConfig","requestId","undefined","callback","console","config"],"mappings":"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"}

package/dist/lib/server.js

@@ -0,0 +1,435 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+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__, {
+    PlaygroundServer: ()=>PlaygroundServer,
+    default: ()=>server
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_url_namespaceObject = require("node:url");
+const utils_namespaceObject = require("@sqaitech/core/utils");
+const constants_namespaceObject = require("@sqaitech/shared/constants");
+const env_namespaceObject = require("@sqaitech/shared/env");
+const shared_utils_namespaceObject = require("@sqaitech/shared/utils");
+const external_express_namespaceObject = require("express");
+var external_express_default = /*#__PURE__*/ __webpack_require__.n(external_express_namespaceObject);
+const external_common_js_namespaceObject = require("./common.js");
+require("dotenv/config");
+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 defaultPort = constants_namespaceObject.PLAYGROUND_SERVER_PORT;
+const server_filename = (0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__);
+const server_dirname = (0, external_node_path_namespaceObject.dirname)(server_filename);
+const STATIC_PATH = (0, external_node_path_namespaceObject.join)(server_dirname, '..', '..', 'static');
+const errorHandler = (err, req, res, next)=>{
+    console.error(err);
+    const errorMessage = err instanceof Error ? err.message : 'Internal server error';
+    res.status(500).json({
+        error: errorMessage
+    });
+};
+class PlaygroundServer {
+    get app() {
+        return this._app;
+    }
+    initializeApp() {
+        if (this._initialized) return;
+        this._app.use(external_express_default().json({
+            limit: '50mb'
+        }));
+        this._app.use((req, _res, next)=>{
+            const { context } = req.body || {};
+            if (context && 'updateContext' in this.agent.interface && 'function' == typeof this.agent.interface.updateContext) {
+                this.agent.interface.updateContext(context);
+                console.log('Context updated by PlaygroundServer middleware');
+            }
+            next();
+        });
+        this.setupRoutes();
+        this.setupStaticRoutes();
+        this._app.use(errorHandler);
+        this._initialized = true;
+    }
+    filePathForUuid(uuid) {
+        return (0, external_node_path_namespaceObject.join)(this.tmpDir, `${uuid}.json`);
+    }
+    saveContextFile(uuid, context) {
+        const tmpFile = this.filePathForUuid(uuid);
+        console.log(`save context file: ${tmpFile}`);
+        (0, external_node_fs_namespaceObject.writeFileSync)(tmpFile, context);
+        return tmpFile;
+    }
+    async recreateAgent() {
+        if (!this.agentFactory) return void console.warn('Cannot recreate agent: factory function not provided. Agent recreation is only available when using factory mode.');
+        console.log('Recreating agent to cancel current task...');
+        try {
+            if (this.agent && 'function' == typeof this.agent.destroy) await this.agent.destroy();
+        } catch (error) {
+            console.warn('Failed to destroy old agent:', error);
+        }
+        try {
+            this.agent = await this.agentFactory();
+            console.log('Agent recreated successfully');
+        } catch (error) {
+            console.error('Failed to recreate agent:', error);
+            throw error;
+        }
+    }
+    setupRoutes() {
+        this._app.get('/status', async (req, res)=>{
+            res.send({
+                status: 'ok',
+                id: this.id
+            });
+        });
+        this._app.get('/context/:uuid', async (req, res)=>{
+            const { uuid } = req.params;
+            const contextFile = this.filePathForUuid(uuid);
+            if (!(0, external_node_fs_namespaceObject.existsSync)(contextFile)) return res.status(404).json({
+                error: 'Context not found'
+            });
+            const context = (0, external_node_fs_namespaceObject.readFileSync)(contextFile, 'utf8');
+            res.json({
+                context
+            });
+        });
+        this._app.get('/task-progress/:requestId', async (req, res)=>{
+            const { requestId } = req.params;
+            res.json({
+                tip: this.taskProgressTips[requestId] || ''
+            });
+        });
+        this._app.post('/action-space', async (req, res)=>{
+            try {
+                let actionSpace = [];
+                actionSpace = await this.agent.interface.actionSpace();
+                const processedActionSpace = actionSpace.map((action)=>{
+                    if (action && 'object' == typeof action && 'paramSchema' in action) {
+                        const typedAction = action;
+                        if (typedAction.paramSchema && 'object' == typeof typedAction.paramSchema) {
+                            let processedSchema = null;
+                            try {
+                                if (typedAction.paramSchema.shape && 'object' == typeof typedAction.paramSchema.shape) processedSchema = {
+                                    type: 'ZodObject',
+                                    shape: typedAction.paramSchema.shape
+                                };
+                            } catch (e) {
+                                const actionName = 'name' in typedAction && 'string' == typeof typedAction.name ? typedAction.name : 'unknown';
+                                console.warn('Failed to process paramSchema for action:', actionName, e);
+                            }
+                            return {
+                                ...typedAction,
+                                paramSchema: processedSchema
+                            };
+                        }
+                    }
+                    return action;
+                });
+                res.json(processedActionSpace);
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.error('Failed to get action space:', error);
+                res.status(500).json({
+                    error: errorMessage
+                });
+            }
+        });
+        this._app.post('/playground-with-context', async (req, res)=>{
+            const context = req.body.context;
+            if (!context) return res.status(400).json({
+                error: 'context is required'
+            });
+            const requestId = (0, shared_utils_namespaceObject.uuid)();
+            this.saveContextFile(requestId, context);
+            return res.json({
+                location: `/playground/${requestId}`,
+                uuid: requestId
+            });
+        });
+        this._app.post('/execute', async (req, res)=>{
+            const { type, prompt, params, requestId, deepThink, screenshotIncluded, domIncluded } = req.body;
+            if (!type) return res.status(400).json({
+                error: 'type is required'
+            });
+            if (this.currentTaskId) return res.status(409).json({
+                error: 'Another task is already running',
+                currentTaskId: this.currentTaskId
+            });
+            if (requestId) {
+                this.currentTaskId = requestId;
+                this.taskProgressTips[requestId] = '';
+                this.agent.onTaskStartTip = (tip)=>{
+                    this.taskProgressTips[requestId] = tip;
+                };
+            }
+            const response = {
+                result: null,
+                dump: null,
+                error: null,
+                reportHTML: null,
+                requestId
+            };
+            const startTime = Date.now();
+            try {
+                const actionSpace = await this.agent.interface.actionSpace();
+                const value = {
+                    type,
+                    prompt,
+                    params
+                };
+                response.result = await (0, external_common_js_namespaceObject.executeAction)(this.agent, type, actionSpace, value, {
+                    deepThink,
+                    screenshotIncluded,
+                    domIncluded
+                });
+            } catch (error) {
+                response.error = (0, external_common_js_namespaceObject.formatErrorMessage)(error);
+            }
+            try {
+                response.dump = JSON.parse(this.agent.dumpDataString());
+                response.reportHTML = this.agent.reportHTMLString() || null;
+                this.agent.writeOutActionDumps();
+                this.agent.resetDump();
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.error(`write out dump failed: requestId: ${requestId}, ${errorMessage}`);
+            }
+            res.send(response);
+            const timeCost = Date.now() - startTime;
+            if (response.error) console.error(`handle request failed after ${timeCost}ms: requestId: ${requestId}, ${response.error}`);
+            else console.log(`handle request done after ${timeCost}ms: requestId: ${requestId}`);
+            if (requestId) {
+                delete this.taskProgressTips[requestId];
+                if (this.currentTaskId === requestId) this.currentTaskId = null;
+            }
+        });
+        this._app.post('/cancel/:requestId', async (req, res)=>{
+            const { requestId } = req.params;
+            if (!requestId) return res.status(400).json({
+                error: 'requestId is required'
+            });
+            try {
+                if (this.currentTaskId !== requestId) return res.json({
+                    status: 'not_found',
+                    message: 'Task not found or already completed'
+                });
+                console.log(`Cancelling task: ${requestId}`);
+                await this.recreateAgent();
+                delete this.taskProgressTips[requestId];
+                this.currentTaskId = null;
+                res.json({
+                    status: 'cancelled',
+                    message: 'Task cancelled successfully by recreating agent'
+                });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.error(`Failed to cancel: ${errorMessage}`);
+                res.status(500).json({
+                    error: `Failed to cancel: ${errorMessage}`
+                });
+            }
+        });
+        this._app.get('/screenshot', async (_req, res)=>{
+            try {
+                if ('function' != typeof this.agent.interface.screenshotBase64) return res.status(500).json({
+                    error: 'Screenshot method not available on current interface'
+                });
+                const base64Screenshot = await this.agent.interface.screenshotBase64();
+                res.json({
+                    screenshot: base64Screenshot,
+                    timestamp: Date.now()
+                });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.error(`Failed to take screenshot: ${errorMessage}`);
+                res.status(500).json({
+                    error: `Failed to take screenshot: ${errorMessage}`
+                });
+            }
+        });
+        this._app.get('/interface-info', async (_req, res)=>{
+            try {
+                var _this_agent_interface_describe, _this_agent_interface;
+                const type = this.agent.interface.interfaceType || 'Unknown';
+                const description = (null == (_this_agent_interface_describe = (_this_agent_interface = this.agent.interface).describe) ? void 0 : _this_agent_interface_describe.call(_this_agent_interface)) || void 0;
+                res.json({
+                    type,
+                    description
+                });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.error(`Failed to get interface info: ${errorMessage}`);
+                res.status(500).json({
+                    error: `Failed to get interface info: ${errorMessage}`
+                });
+            }
+        });
+        this.app.post('/config', async (req, res)=>{
+            const { aiConfig } = req.body;
+            if (!aiConfig || 'object' != typeof aiConfig) return res.status(400).json({
+                error: 'aiConfig is required and must be an object'
+            });
+            if (0 === Object.keys(aiConfig).length) return res.json({
+                status: 'ok',
+                message: 'AI config not changed due to empty object'
+            });
+            try {
+                (0, env_namespaceObject.overrideAIConfig)(aiConfig);
+                return res.json({
+                    status: 'ok',
+                    message: 'AI config updated successfully'
+                });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.error(`Failed to update AI config: ${errorMessage}`);
+                return res.status(500).json({
+                    error: `Failed to update AI config: ${errorMessage}`
+                });
+            }
+        });
+    }
+    setupStaticRoutes() {
+        this._app.get('/', (_req, res)=>{
+            this.serveHtmlWithPorts(res);
+        });
+        this._app.get('/index.html', (_req, res)=>{
+            this.serveHtmlWithPorts(res);
+        });
+        this._app.use(external_express_default()["static"](this.staticPath));
+        this._app.get('*', (_req, res)=>{
+            this.serveHtmlWithPorts(res);
+        });
+    }
+    serveHtmlWithPorts(res) {
+        try {
+            const htmlPath = (0, external_node_path_namespaceObject.join)(this.staticPath, 'index.html');
+            let html = (0, external_node_fs_namespaceObject.readFileSync)(htmlPath, 'utf8');
+            const scrcpyPort = global.scrcpyServerPort || this.port + 1;
+            const configScript = `
+        <script>
+          window.SCRCPY_PORT = ${scrcpyPort};
+        </script>
+      `;
+            html = html.replace('</head>', `${configScript}</head>`);
+            res.setHeader('Content-Type', 'text/html');
+            res.send(html);
+        } catch (error) {
+            console.error('Error serving HTML with ports:', error);
+            res.status(500).send('Internal Server Error');
+        }
+    }
+    async launch(port) {
+        if (this.agentFactory) {
+            console.log('Initializing agent from factory function...');
+            this.agent = await this.agentFactory();
+            console.log('Agent initialized successfully');
+        }
+        this.initializeApp();
+        this.port = port || defaultPort;
+        return new Promise((resolve)=>{
+            const serverPort = this.port;
+            this.server = this._app.listen(serverPort, ()=>{
+                resolve(this);
+            });
+        });
+    }
+    async close() {
+        return new Promise((resolve, reject)=>{
+            if (this.server) {
+                try {
+                    this.agent.destroy();
+                } catch (error) {
+                    console.warn('Failed to destroy agent:', error);
+                }
+                this.taskProgressTips = {};
+                this.server.close((error)=>{
+                    if (error) reject(error);
+                    else {
+                        this.server = void 0;
+                        resolve();
+                    }
+                });
+            } else resolve();
+        });
+    }
+    constructor(agent, staticPath = STATIC_PATH, id){
+        _define_property(this, "_app", void 0);
+        _define_property(this, "tmpDir", void 0);
+        _define_property(this, "server", void 0);
+        _define_property(this, "port", void 0);
+        _define_property(this, "agent", void 0);
+        _define_property(this, "staticPath", void 0);
+        _define_property(this, "taskProgressTips", void 0);
+        _define_property(this, "id", void 0);
+        _define_property(this, "_initialized", false);
+        _define_property(this, "agentFactory", void 0);
+        _define_property(this, "currentTaskId", null);
+        this._app = external_express_default()();
+        this.tmpDir = (0, utils_namespaceObject.getTmpDir)();
+        this.staticPath = staticPath;
+        this.taskProgressTips = {};
+        this.id = id || (0, shared_utils_namespaceObject.uuid)();
+        if ('function' == typeof agent) {
+            this.agentFactory = agent;
+            this.agent = null;
+        } else {
+            this.agent = agent;
+            this.agentFactory = null;
+        }
+    }
+}
+const server = PlaygroundServer;
+exports.PlaygroundServer = __webpack_exports__.PlaygroundServer;
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "PlaygroundServer",
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=server.js.map