@midscene/shared 1.9.8-beta-20260618014851.0 → 1.9.8

package/dist/lib/env/types.js

@@ -36,7 +36,6 @@ __webpack_require__.d(__webpack_exports__, {
     MIDSCENE_ANDROID_IME_STRATEGY: ()=>MIDSCENE_ANDROID_IME_STRATEGY,
     MIDSCENE_CACHE: ()=>MIDSCENE_CACHE,
     MIDSCENE_CACHE_MAX_FILENAME_LENGTH: ()=>MIDSCENE_CACHE_MAX_FILENAME_LENGTH,
-    MIDSCENE_CHROME_PATH: ()=>MIDSCENE_CHROME_PATH,
     MIDSCENE_DANGEROUSLY_PRINT_ALL_CONFIG: ()=>MIDSCENE_DANGEROUSLY_PRINT_ALL_CONFIG,
     MIDSCENE_DEBUG_MODE: ()=>MIDSCENE_DEBUG_MODE,
     MIDSCENE_DEBUG_MODEL_PROFILE: ()=>MIDSCENE_DEBUG_MODEL_PROFILE,
@@ -61,7 +60,9 @@ __webpack_require__.d(__webpack_exports__, {
     MIDSCENE_IOS_SIMULATOR_UDID: ()=>MIDSCENE_IOS_SIMULATOR_UDID,
     MIDSCENE_LANGFUSE_DEBUG: ()=>MIDSCENE_LANGFUSE_DEBUG,
     MIDSCENE_LANGSMITH_DEBUG: ()=>MIDSCENE_LANGSMITH_DEBUG,
+    MIDSCENE_MCP_ANDROID_MODE: ()=>MIDSCENE_MCP_ANDROID_MODE,
     MIDSCENE_MCP_CHROME_PATH: ()=>MIDSCENE_MCP_CHROME_PATH,
+    MIDSCENE_MCP_USE_PUPPETEER_MODE: ()=>MIDSCENE_MCP_USE_PUPPETEER_MODE,
     MIDSCENE_MODEL_API_KEY: ()=>MIDSCENE_MODEL_API_KEY,
     MIDSCENE_MODEL_BASE_URL: ()=>MIDSCENE_MODEL_BASE_URL,
     MIDSCENE_MODEL_EXTRA_BODY_JSON: ()=>MIDSCENE_MODEL_EXTRA_BODY_JSON,
@@ -122,8 +123,9 @@ const MIDSCENE_DEBUG_MODEL_PROFILE = 'MIDSCENE_DEBUG_MODEL_PROFILE';
 const MIDSCENE_DEBUG_MODEL_RESPONSE = 'MIDSCENE_DEBUG_MODEL_RESPONSE';
 const MIDSCENE_DANGEROUSLY_PRINT_ALL_CONFIG = 'MIDSCENE_DANGEROUSLY_PRINT_ALL_CONFIG';
 const MIDSCENE_DEBUG_MODE = 'MIDSCENE_DEBUG_MODE';
-const MIDSCENE_CHROME_PATH = 'MIDSCENE_CHROME_PATH';
+const MIDSCENE_MCP_USE_PUPPETEER_MODE = 'MIDSCENE_MCP_USE_PUPPETEER_MODE';
 const MIDSCENE_MCP_CHROME_PATH = 'MIDSCENE_MCP_CHROME_PATH';
+const MIDSCENE_MCP_ANDROID_MODE = 'MIDSCENE_MCP_ANDROID_MODE';
 const DOCKER_CONTAINER = 'DOCKER_CONTAINER';
 const MIDSCENE_LANGSMITH_DEBUG = 'MIDSCENE_LANGSMITH_DEBUG';
 const MIDSCENE_LANGFUSE_DEBUG = 'MIDSCENE_LANGFUSE_DEBUG';
@@ -206,6 +208,8 @@ const BASIC_ENV_KEYS = [
 ];
 const BOOLEAN_ENV_KEYS = [
     MIDSCENE_CACHE,
+    MIDSCENE_MCP_USE_PUPPETEER_MODE,
+    MIDSCENE_MCP_ANDROID_MODE,
     MIDSCENE_LANGSMITH_DEBUG,
     MIDSCENE_LANGFUSE_DEBUG,
     MIDSCENE_REPORT_QUIET
@@ -224,7 +228,6 @@ const STRING_ENV_KEYS = [
     MIDSCENE_REPORT_TAG_NAME,
     MIDSCENE_PREFERRED_LANGUAGE,
     MATCH_BY_POSITION,
-    MIDSCENE_CHROME_PATH,
     MIDSCENE_MCP_CHROME_PATH,
     DOCKER_CONTAINER
 ];
@@ -335,7 +338,6 @@ exports.MIDSCENE_ADB_REMOTE_PORT = __webpack_exports__.MIDSCENE_ADB_REMOTE_PORT;
 exports.MIDSCENE_ANDROID_IME_STRATEGY = __webpack_exports__.MIDSCENE_ANDROID_IME_STRATEGY;
 exports.MIDSCENE_CACHE = __webpack_exports__.MIDSCENE_CACHE;
 exports.MIDSCENE_CACHE_MAX_FILENAME_LENGTH = __webpack_exports__.MIDSCENE_CACHE_MAX_FILENAME_LENGTH;
-exports.MIDSCENE_CHROME_PATH = __webpack_exports__.MIDSCENE_CHROME_PATH;
 exports.MIDSCENE_DANGEROUSLY_PRINT_ALL_CONFIG = __webpack_exports__.MIDSCENE_DANGEROUSLY_PRINT_ALL_CONFIG;
 exports.MIDSCENE_DEBUG_MODE = __webpack_exports__.MIDSCENE_DEBUG_MODE;
 exports.MIDSCENE_DEBUG_MODEL_PROFILE = __webpack_exports__.MIDSCENE_DEBUG_MODEL_PROFILE;
@@ -360,7 +362,9 @@ exports.MIDSCENE_IOS_DEVICE_UDID = __webpack_exports__.MIDSCENE_IOS_DEVICE_UDID;
 exports.MIDSCENE_IOS_SIMULATOR_UDID = __webpack_exports__.MIDSCENE_IOS_SIMULATOR_UDID;
 exports.MIDSCENE_LANGFUSE_DEBUG = __webpack_exports__.MIDSCENE_LANGFUSE_DEBUG;
 exports.MIDSCENE_LANGSMITH_DEBUG = __webpack_exports__.MIDSCENE_LANGSMITH_DEBUG;
+exports.MIDSCENE_MCP_ANDROID_MODE = __webpack_exports__.MIDSCENE_MCP_ANDROID_MODE;
 exports.MIDSCENE_MCP_CHROME_PATH = __webpack_exports__.MIDSCENE_MCP_CHROME_PATH;
+exports.MIDSCENE_MCP_USE_PUPPETEER_MODE = __webpack_exports__.MIDSCENE_MCP_USE_PUPPETEER_MODE;
 exports.MIDSCENE_MODEL_API_KEY = __webpack_exports__.MIDSCENE_MODEL_API_KEY;
 exports.MIDSCENE_MODEL_BASE_URL = __webpack_exports__.MIDSCENE_MODEL_BASE_URL;
 exports.MIDSCENE_MODEL_EXTRA_BODY_JSON = __webpack_exports__.MIDSCENE_MODEL_EXTRA_BODY_JSON;
@@ -426,7 +430,6 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MIDSCENE_ANDROID_IME_STRATEGY",
     "MIDSCENE_CACHE",
     "MIDSCENE_CACHE_MAX_FILENAME_LENGTH",
-    "MIDSCENE_CHROME_PATH",
     "MIDSCENE_DANGEROUSLY_PRINT_ALL_CONFIG",
     "MIDSCENE_DEBUG_MODE",
     "MIDSCENE_DEBUG_MODEL_PROFILE",
@@ -451,7 +454,9 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MIDSCENE_IOS_SIMULATOR_UDID",
     "MIDSCENE_LANGFUSE_DEBUG",
     "MIDSCENE_LANGSMITH_DEBUG",
+    "MIDSCENE_MCP_ANDROID_MODE",
     "MIDSCENE_MCP_CHROME_PATH",
+    "MIDSCENE_MCP_USE_PUPPETEER_MODE",
     "MIDSCENE_MODEL_API_KEY",
     "MIDSCENE_MODEL_BASE_URL",
     "MIDSCENE_MODEL_EXTRA_BODY_JSON",

package/dist/lib/mcp/base-server.js

@@ -0,0 +1,345 @@
+"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__, {
+    CLI_ARGS_CONFIG: ()=>CLI_ARGS_CONFIG,
+    launchMCPServer: ()=>launchMCPServer,
+    BaseMCPServer: ()=>BaseMCPServer
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const utils_namespaceObject = require("@midscene/shared/utils");
+const mcp_js_namespaceObject = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_namespaceObject = require("@modelcontextprotocol/sdk/server/stdio.js");
+const streamableHttp_js_namespaceObject = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const external_express_namespaceObject = require("express");
+var external_express_default = /*#__PURE__*/ __webpack_require__.n(external_express_namespaceObject);
+const external_error_formatter_js_namespaceObject = require("./error-formatter.js");
+const external_tool_defaults_js_namespaceObject = require("./tool-defaults.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;
+}
+const CLI_ARGS_CONFIG = {
+    mode: {
+        type: 'string',
+        default: 'stdio'
+    },
+    port: {
+        type: 'string',
+        default: '3000'
+    },
+    host: {
+        type: 'string',
+        default: 'localhost'
+    },
+    ...Object.fromEntries(external_tool_defaults_js_namespaceObject.TOOL_BEHAVIOR_FLAGS.map((flag)=>[
+            flag.cli,
+            {
+                type: 'boolean'
+            }
+        ]))
+};
+function launchMCPServer(server, args) {
+    server.setToolDefaults((0, external_tool_defaults_js_namespaceObject.resolveToolDefaults)((cli)=>true === args[cli]));
+    if ('http' === args.mode) return server.launchHttp({
+        port: Number.parseInt(args.port || '3000', 10),
+        host: args.host || 'localhost'
+    });
+    return server.launch();
+}
+const SESSION_TIMEOUT_MS = 1800000;
+const CLEANUP_INTERVAL_MS = 300000;
+const MAX_SESSIONS = 100;
+class BaseMCPServer {
+    setToolDefaults(toolDefaults) {
+        this.toolDefaults = (0, external_tool_defaults_js_namespaceObject.mergeToolDefaults)(this.toolDefaults, toolDefaults);
+    }
+    async initializeToolsManager() {
+        (0, utils_namespaceObject.setIsMcp)(true);
+        this.toolsManager = this.providedToolsManager || this.createToolsManager();
+        this.toolsManager.setToolDefaults?.(this.toolDefaults);
+        try {
+            await this.toolsManager.initTools();
+        } catch (error) {
+            const message = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+            console.error(`Failed to initialize tools: ${message}`);
+            console.error('Tools will be initialized on first use');
+        }
+        this.toolsManager.attachToServer(this.mcpServer);
+    }
+    async performCleanup() {
+        console.error(`${this.config.name} closing...`);
+        this.mcpServer.close();
+        await this.toolsManager?.destroy?.().catch(console.error);
+    }
+    async launch() {
+        console.log = (...args)=>{
+            console.error('[LOG]', ...args);
+        };
+        console.info = (...args)=>{
+            console.error('[INFO]', ...args);
+        };
+        console.debug = (...args)=>{
+            console.error('[DEBUG]', ...args);
+        };
+        await this.initializeToolsManager();
+        const transport = new stdio_js_namespaceObject.StdioServerTransport();
+        try {
+            await this.mcpServer.connect(transport);
+        } catch (error) {
+            const message = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+            console.error(`Failed to connect MCP stdio transport: ${message}`);
+            throw new Error(`Failed to initialize MCP stdio transport: ${message}`);
+        }
+        let isShuttingDown = false;
+        const cleanup = ()=>{
+            if (isShuttingDown) return;
+            isShuttingDown = true;
+            console.error(`${this.config.name} shutting down...`);
+            this.performCleanup().finally(()=>process.exit(0));
+        };
+        process.on('uncaughtException', (error)=>{
+            if ('EPIPE' === error.code || 'ERR_STREAM_DESTROYED' === error.code) return void cleanup();
+            console.error(`[${this.config.name}] Uncaught Exception:`, error);
+            console.error('Stack:', error.stack);
+        });
+        process.on('unhandledRejection', (reason)=>{
+            console.error(`[${this.config.name}] Unhandled Rejection:`, reason);
+            if (reason instanceof Error) console.error('Stack:', reason.stack);
+        });
+        process.stdin.on('close', cleanup);
+        process.stdin.on('end', cleanup);
+        process.stdout.on('error', cleanup);
+        process.once('SIGINT', cleanup);
+        process.once('SIGTERM', cleanup);
+        process.once('SIGHUP', cleanup);
+        return {
+            close: async ()=>{
+                this.performCleanup();
+            }
+        };
+    }
+    async launchHttp(options) {
+        if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) throw new Error(`Invalid port number: ${options.port}. Port must be between 1 and 65535.`);
+        await this.initializeToolsManager();
+        const app = external_express_default()();
+        app.use(external_express_default().json({
+            limit: '10mb'
+        }));
+        const sessions = new Map();
+        app.all('/mcp', async (req, res)=>{
+            const startTime = Date.now();
+            const requestId = (0, external_node_crypto_namespaceObject.randomUUID)().substring(0, 8);
+            try {
+                const rawSessionId = req.headers['mcp-session-id'];
+                const sessionId = Array.isArray(rawSessionId) ? rawSessionId[0] : rawSessionId;
+                let session = sessionId ? sessions.get(sessionId) : void 0;
+                if (!session && 'POST' === req.method) {
+                    if (sessions.size >= MAX_SESSIONS) {
+                        console.error(`[${new Date().toISOString()}] [${requestId}] Session limit reached: ${sessions.size}/${MAX_SESSIONS}`);
+                        res.status(503).json({
+                            error: 'Too many active sessions',
+                            message: 'Server is at maximum capacity. Please try again later.'
+                        });
+                        return;
+                    }
+                    session = await this.createHttpSession(sessions);
+                    console.log(`[${new Date().toISOString()}] [${requestId}] New session created: ${session.transport.sessionId}`);
+                }
+                if (session) {
+                    session.lastAccessedAt = new Date();
+                    await session.transport.handleRequest(req, res, req.body);
+                    const duration = Date.now() - startTime;
+                    console.log(`[${new Date().toISOString()}] [${requestId}] Request completed in ${duration}ms`);
+                } else {
+                    console.error(`[${new Date().toISOString()}] [${requestId}] Invalid session or GET without session`);
+                    res.status(400).json({
+                        error: 'Invalid session or GET without session'
+                    });
+                }
+            } catch (error) {
+                const message = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+                const duration = Date.now() - startTime;
+                console.error(`[${new Date().toISOString()}] [${requestId}] MCP request error after ${duration}ms: ${message}`);
+                if (!res.headersSent) res.status(500).json({
+                    error: 'Internal server error',
+                    message: 'Failed to process MCP request'
+                });
+            }
+        });
+        const host = options.host || 'localhost';
+        const server = app.listen(options.port, host, ()=>{
+            console.log(`${this.config.name} HTTP server listening on http://${host}:${options.port}/mcp`);
+        }).on('error', (error)=>{
+            if ('EADDRINUSE' === error.code) console.error(`ERROR: Port ${options.port} is already in use.\nPlease try a different port: --port=<number>\nExample: --mode=http --port=${options.port + 1}`);
+            else if ('EACCES' === error.code) console.error(`ERROR: Permission denied to bind to port ${options.port}.\nPorts below 1024 require root/admin privileges.\nPlease use a port above 1024 or run with elevated privileges.`);
+            else console.error(`ERROR: Failed to start HTTP server on ${host}:${options.port}\nReason: ${error.message}\nCode: ${error.code || 'unknown'}`);
+            process.exit(1);
+        });
+        const cleanupInterval = this.startSessionCleanup(sessions);
+        this.setupHttpShutdownHandlers(server, sessions, cleanupInterval);
+        return {
+            port: options.port,
+            host,
+            close: async ()=>{
+                clearInterval(cleanupInterval);
+                for (const session of sessions.values())try {
+                    await session.transport.close();
+                } catch (error) {
+                    const message = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+                    console.error(`Failed to close session ${session.transport.sessionId}: ${message}`);
+                }
+                sessions.clear();
+                return new Promise((resolve)=>{
+                    server.close(async (err)=>{
+                        if (err) console.error('Error closing HTTP server:', err);
+                        await this.performCleanup();
+                        resolve();
+                    });
+                });
+            }
+        };
+    }
+    async createHttpSession(sessions) {
+        const transport = new streamableHttp_js_namespaceObject.StreamableHTTPServerTransport({
+            sessionIdGenerator: ()=>(0, external_node_crypto_namespaceObject.randomUUID)(),
+            onsessioninitialized: (sid)=>{
+                sessions.set(sid, {
+                    transport,
+                    createdAt: new Date(),
+                    lastAccessedAt: new Date()
+                });
+                console.log(`[${new Date().toISOString()}] Session ${sid} initialized (total: ${sessions.size})`);
+            }
+        });
+        transport.onclose = ()=>{
+            if (transport.sessionId) {
+                sessions.delete(transport.sessionId);
+                console.log(`[${new Date().toISOString()}] Session ${transport.sessionId} closed (remaining: ${sessions.size})`);
+            }
+        };
+        try {
+            await this.mcpServer.connect(transport);
+        } catch (error) {
+            const message = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+            console.error(`[${new Date().toISOString()}] Failed to connect MCP transport: ${message}`);
+            if (transport.sessionId) sessions.delete(transport.sessionId);
+            throw new Error(`Failed to initialize MCP session: ${message}`);
+        }
+        return {
+            transport,
+            createdAt: new Date(),
+            lastAccessedAt: new Date()
+        };
+    }
+    startSessionCleanup(sessions) {
+        return setInterval(()=>{
+            const now = Date.now();
+            for (const [sid, session] of sessions)if (now - session.lastAccessedAt.getTime() > SESSION_TIMEOUT_MS) try {
+                session.transport.close();
+                sessions.delete(sid);
+                console.log(`[${new Date().toISOString()}] Session ${sid} cleaned up due to inactivity (remaining: ${sessions.size})`);
+            } catch (error) {
+                const message = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+                console.error(`[${new Date().toISOString()}] Failed to close session ${sid} during cleanup: ${message}`);
+                sessions.delete(sid);
+            }
+        }, CLEANUP_INTERVAL_MS);
+    }
+    setupHttpShutdownHandlers(server, sessions, cleanupInterval) {
+        const cleanup = ()=>{
+            console.error(`${this.config.name} shutting down...`);
+            clearInterval(cleanupInterval);
+            for (const session of sessions.values())try {
+                session.transport.close();
+            } catch (error) {
+                const message = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+                console.error(`Error closing session during shutdown: ${message}`);
+            }
+            sessions.clear();
+            try {
+                server.close(()=>{
+                    this.performCleanup().finally(()=>process.exit(0));
+                });
+                setTimeout(()=>{
+                    console.error('Forcefully shutting down after timeout');
+                    this.performCleanup().finally(()=>process.exit(1));
+                }, 5000);
+            } catch (error) {
+                const message = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+                console.error(`Error closing HTTP server: ${message}`);
+                this.performCleanup().finally(()=>process.exit(1));
+            }
+        };
+        process.once('SIGINT', cleanup);
+        process.once('SIGTERM', cleanup);
+    }
+    getServer() {
+        return this.mcpServer;
+    }
+    getToolsManager() {
+        return this.toolsManager;
+    }
+    constructor(config, toolsManager){
+        _define_property(this, "mcpServer", void 0);
+        _define_property(this, "toolsManager", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "providedToolsManager", void 0);
+        _define_property(this, "toolDefaults", {});
+        this.config = config;
+        this.mcpServer = new mcp_js_namespaceObject.McpServer({
+            name: config.name,
+            version: config.version,
+            description: config.description
+        });
+        this.providedToolsManager = toolsManager;
+    }
+}
+exports.BaseMCPServer = __webpack_exports__.BaseMCPServer;
+exports.CLI_ARGS_CONFIG = __webpack_exports__.CLI_ARGS_CONFIG;
+exports.launchMCPServer = __webpack_exports__.launchMCPServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BaseMCPServer",
+    "CLI_ARGS_CONFIG",
+    "launchMCPServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/{agent-tools → mcp}/base-tools.js

@@ -43,7 +43,7 @@ function _define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
-const debug = (0, logger_namespaceObject.getDebug)('agent-tools:base-tools');
+const debug = (0, logger_namespaceObject.getDebug)('mcp:base-tools');
 class BaseMidsceneTools {
     getInitArgKeys() {
         return this.initArgSpec ? Object.keys(this.initArgSpec.shape) : [];
@@ -132,6 +132,12 @@ class BaseMidsceneTools {
         this.toolDefinitions.push(...actionTools, ...commonTools);
         debug('Total tools prepared:', this.toolDefinitions.length);
     }
+    attachToServer(server) {
+        this.mcpServer = server;
+        if (0 === this.toolDefinitions.length) debug('Warning: No tools to register. Tools may be initialized lazily.');
+        for (const toolDef of this.toolDefinitions)this.mcpServer.tool(toolDef.name, toolDef.description, toolDef.schema, toolDef.handler);
+        debug('Registered', this.toolDefinitions.length, 'tools');
+    }
     async destroy() {
         await this.agent?.destroy?.();
     }
@@ -177,6 +183,7 @@ class BaseMidsceneTools {
         };
     }
     constructor(){
+        _define_property(this, "mcpServer", void 0);
         _define_property(this, "agent", void 0);
         _define_property(this, "toolDefinitions", []);
         _define_property(this, "toolDefaults", {});

package/dist/lib/{agent-tools → mcp}/chrome-path.js

@@ -29,11 +29,6 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_node_fs_namespaceObject = require("node:fs");
 const index_js_namespaceObject = require("../env/index.js");
-const external_logger_js_namespaceObject = require("../logger.js");
-const warnChromePath = (0, external_logger_js_namespaceObject.getDebug)('agent-tools:chrome-path', {
-    console: true
-});
-let hasWarnedLegacyChromePath = false;
 function getSystemChromePath() {
     const platform = process.platform;
     const chromePaths = {
@@ -60,17 +55,11 @@ function getSystemChromePath() {
     return paths.find((p)=>(0, external_node_fs_namespaceObject.existsSync)(p));
 }
 function resolveChromePath() {
-    const primaryEnvPath = index_js_namespaceObject.globalConfigManager.getEnvConfigValue(index_js_namespaceObject.MIDSCENE_CHROME_PATH);
-    const legacyEnvPath = index_js_namespaceObject.globalConfigManager.getEnvConfigValue(index_js_namespaceObject.MIDSCENE_MCP_CHROME_PATH);
-    const envPath = primaryEnvPath || legacyEnvPath;
-    if (!primaryEnvPath && legacyEnvPath && !hasWarnedLegacyChromePath) {
-        warnChromePath('MIDSCENE_MCP_CHROME_PATH is deprecated. Use MIDSCENE_CHROME_PATH instead.');
-        hasWarnedLegacyChromePath = true;
-    }
+    const envPath = index_js_namespaceObject.globalConfigManager.getEnvConfigValue(index_js_namespaceObject.MIDSCENE_MCP_CHROME_PATH);
     if (envPath && 'auto' !== envPath && (0, external_node_fs_namespaceObject.existsSync)(envPath)) return envPath;
     const systemPath = getSystemChromePath();
     if (systemPath) return systemPath;
-    throw new Error('Chrome not found. Install Google Chrome or set MIDSCENE_CHROME_PATH environment variable.');
+    throw new Error('Chrome not found. Install Google Chrome or set MIDSCENE_MCP_CHROME_PATH environment variable.');
 }
 exports.getSystemChromePath = __webpack_exports__.getSystemChromePath;
 exports.resolveChromePath = __webpack_exports__.resolveChromePath;

package/dist/lib/{agent-tools → mcp}/index.js

@@ -3,6 +3,9 @@ var __webpack_modules__ = {
     "./agent-behavior-init-args" (module) {
         module.exports = require("./agent-behavior-init-args.js");
     },
+    "./base-server" (module) {
+        module.exports = require("./base-server.js");
+    },
     "./base-tools" (module) {
         module.exports = require("./base-tools.js");
     },
@@ -15,6 +18,12 @@ var __webpack_modules__ = {
     "./init-arg-utils" (module) {
         module.exports = require("./init-arg-utils.js");
     },
+    "./inject-report-html-plugin" (module) {
+        module.exports = require("./inject-report-html-plugin.js");
+    },
+    "./launcher-helper" (module) {
+        module.exports = require("./launcher-helper.js");
+    },
     "./tool-defaults" (module) {
         module.exports = require("./tool-defaults.js");
     },
@@ -68,37 +77,49 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _base_tools__rspack_import_0 = __webpack_require__("./base-tools");
+    var _base_server__rspack_import_0 = __webpack_require__("./base-server");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _base_server__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_base_server__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _base_tools__rspack_import_1 = __webpack_require__("./base-tools");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _base_tools__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_base_tools__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _tool_defaults__rspack_import_2 = __webpack_require__("./tool-defaults");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _tool_defaults__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tool_defaults__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _agent_behavior_init_args__rspack_import_3 = __webpack_require__("./agent-behavior-init-args");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _base_tools__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_base_tools__rspack_import_0[__rspack_import_key];
+    for(const __rspack_import_key in _agent_behavior_init_args__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_agent_behavior_init_args__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _tool_defaults__rspack_import_1 = __webpack_require__("./tool-defaults");
+    var _init_arg_utils__rspack_import_4 = __webpack_require__("./init-arg-utils");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _tool_defaults__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tool_defaults__rspack_import_1[__rspack_import_key];
+    for(const __rspack_import_key in _init_arg_utils__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_init_arg_utils__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _agent_behavior_init_args__rspack_import_2 = __webpack_require__("./agent-behavior-init-args");
+    var _error_formatter__rspack_import_5 = __webpack_require__("./error-formatter");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _agent_behavior_init_args__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_agent_behavior_init_args__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _error_formatter__rspack_import_5)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_error_formatter__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _init_arg_utils__rspack_import_3 = __webpack_require__("./init-arg-utils");
+    var _tool_generator__rspack_import_6 = __webpack_require__("./tool-generator");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _init_arg_utils__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_init_arg_utils__rspack_import_3[__rspack_import_key];
+    for(const __rspack_import_key in _tool_generator__rspack_import_6)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tool_generator__rspack_import_6[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _error_formatter__rspack_import_4 = __webpack_require__("./error-formatter");
+    var _types__rspack_import_7 = __webpack_require__("./types");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _error_formatter__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_error_formatter__rspack_import_4[__rspack_import_key];
+    for(const __rspack_import_key in _types__rspack_import_7)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_7[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _tool_generator__rspack_import_5 = __webpack_require__("./tool-generator");
+    var _inject_report_html_plugin__rspack_import_8 = __webpack_require__("./inject-report-html-plugin");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _tool_generator__rspack_import_5)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tool_generator__rspack_import_5[__rspack_import_key];
+    for(const __rspack_import_key in _inject_report_html_plugin__rspack_import_8)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_inject_report_html_plugin__rspack_import_8[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _types__rspack_import_6 = __webpack_require__("./types");
+    var _launcher_helper__rspack_import_9 = __webpack_require__("./launcher-helper");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _types__rspack_import_6)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_6[__rspack_import_key];
+    for(const __rspack_import_key in _launcher_helper__rspack_import_9)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_launcher_helper__rspack_import_9[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _chrome_path__rspack_import_7 = __webpack_require__("./chrome-path");
+    var _chrome_path__rspack_import_10 = __webpack_require__("./chrome-path");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _chrome_path__rspack_import_7)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_chrome_path__rspack_import_7[__rspack_import_key];
+    for(const __rspack_import_key in _chrome_path__rspack_import_10)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_chrome_path__rspack_import_10[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];