@midscene/shared 1.9.8 → 1.10.1-beta-20260624112700.0

package/src/utils.ts

@@ -64,17 +64,8 @@ export function assert(condition: any, message?: string): asserts condition {
   }
 }
 
-let isMcp = false;
-
-export function setIsMcp(value: boolean) {
-  isMcp = value;
-}
-
-//mcp need use obj format to console msg: https://github.com/modelcontextprotocol/typescript-sdk/issues/244
 export function logMsg(...message: Parameters<typeof console.log>) {
-  if (!isMcp) {
-    console.log(...message);
-  }
+  console.log(...message);
 }
 
 export async function repeat(

package/dist/es/mcp/base-server.mjs

@@ -1,295 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { setIsMcp } from "@midscene/shared/utils";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import express from "express";
-import { getErrorMessage } from "./error-formatter.mjs";
-import { TOOL_BEHAVIOR_FLAGS, mergeToolDefaults, resolveToolDefaults } from "./tool-defaults.mjs";
-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(TOOL_BEHAVIOR_FLAGS.map((flag)=>[
-            flag.cli,
-            {
-                type: 'boolean'
-            }
-        ]))
-};
-function launchMCPServer(server, args) {
-    server.setToolDefaults(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 = mergeToolDefaults(this.toolDefaults, toolDefaults);
-    }
-    async initializeToolsManager() {
-        setIsMcp(true);
-        this.toolsManager = this.providedToolsManager || this.createToolsManager();
-        this.toolsManager.setToolDefaults?.(this.toolDefaults);
-        try {
-            await this.toolsManager.initTools();
-        } catch (error) {
-            const message = 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 StdioServerTransport();
-        try {
-            await this.mcpServer.connect(transport);
-        } catch (error) {
-            const message = 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 = express();
-        app.use(express.json({
-            limit: '10mb'
-        }));
-        const sessions = new Map();
-        app.all('/mcp', async (req, res)=>{
-            const startTime = Date.now();
-            const requestId = 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 = 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 = 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 StreamableHTTPServerTransport({
-            sessionIdGenerator: ()=>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 = 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 = 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 = 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 = 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 McpServer({
-            name: config.name,
-            version: config.version,
-            description: config.description
-        });
-        this.providedToolsManager = toolsManager;
-    }
-}
-export { BaseMCPServer, CLI_ARGS_CONFIG, launchMCPServer };

package/dist/es/mcp/inject-report-html-plugin.mjs

@@ -1,53 +0,0 @@
-import node_fs from "node:fs";
-import node_path from "node:path";
-const MAGIC_STRING = 'REPLACE_ME_WITH_REPORT_HTML';
-const REPLACED_MARK = '/*REPORT_HTML_REPLACED*/';
-const REG_EXP_FOR_REPLACE = /\/\*REPORT_HTML_REPLACED\*\/.*/;
-function injectReportHtmlFromCore(packageDir) {
-    return {
-        name: 'inject-report-html-from-core',
-        setup (api) {
-            api.onAfterBuild(()=>{
-                const coreUtilsPath = node_path.resolve(packageDir, '..', 'core', 'dist', 'lib', 'utils.js');
-                if (!node_fs.existsSync(coreUtilsPath)) return void console.warn('[inject-report-html] @midscene/core dist not found, skipping');
-                const coreContent = node_fs.readFileSync(coreUtilsPath, 'utf-8');
-                if (!coreContent.includes(REPLACED_MARK)) return void console.warn('[inject-report-html] HTML not found in core dist. Ensure report builds first.');
-                const markerIndex = coreContent.indexOf(REPLACED_MARK);
-                const jsonStart = markerIndex + REPLACED_MARK.length;
-                let jsonEnd = jsonStart;
-                if ('"' === coreContent[jsonStart]) {
-                    jsonEnd = jsonStart + 1;
-                    while(jsonEnd < coreContent.length)if ('\\' === coreContent[jsonEnd]) jsonEnd += 2;
-                    else if ('"' === coreContent[jsonEnd]) {
-                        jsonEnd += 1;
-                        break;
-                    } else jsonEnd += 1;
-                }
-                const jsonString = coreContent.slice(jsonStart, jsonEnd);
-                if (!jsonString || jsonString.length < 10) return void console.warn('[inject-report-html] Failed to extract HTML from core');
-                const finalContent = `${REPLACED_MARK}${jsonString}`;
-                const distDir = node_path.join(packageDir, 'dist');
-                if (!node_fs.existsSync(distDir)) return;
-                const jsFiles = node_fs.readdirSync(distDir).filter((f)=>f.endsWith('.js'));
-                let injectedCount = 0;
-                for (const file of jsFiles){
-                    const filePath = node_path.join(distDir, file);
-                    const content = node_fs.readFileSync(filePath, 'utf-8');
-                    if (content.includes(REPLACED_MARK)) {
-                        if (REG_EXP_FOR_REPLACE.test(content)) {
-                            node_fs.writeFileSync(filePath, content.replace(REG_EXP_FOR_REPLACE, ()=>finalContent));
-                            console.log(`[inject-report-html] Updated: ${file}`);
-                            injectedCount++;
-                        }
-                    } else if (content.includes(`'${MAGIC_STRING}'`)) {
-                        node_fs.writeFileSync(filePath, content.replace(`'${MAGIC_STRING}'`, ()=>finalContent));
-                        console.log(`[inject-report-html] Injected: ${file}`);
-                        injectedCount++;
-                    }
-                }
-                if (injectedCount > 0) console.log(`[inject-report-html] Completed: ${injectedCount} file(s)`);
-            });
-        }
-    };
-}
-export { injectReportHtmlFromCore };

package/dist/es/mcp/launcher-helper.mjs

@@ -1,52 +0,0 @@
-function createMCPServerLauncher(config) {
-    const { agent, platformName, ToolsManagerClass, MCPServerClass } = config;
-    function validateAgent() {
-        const device = agent.interface;
-        if (!device) throw new Error(`Agent must have an 'interface' property that references the underlying device.
-Please ensure your agent instance is properly initialized with a device interface.
-Expected: agent.interface to be defined, but got: ${typeof device}
-Solution: Check that your agent constructor properly sets the interface property.`);
-    }
-    function createToolsManager() {
-        const toolsManager = new ToolsManagerClass();
-        toolsManager.agent = agent;
-        return toolsManager;
-    }
-    function logStartupInfo(mode, additionalInfo) {
-        const device = agent.interface;
-        console.log(`Starting Midscene ${platformName} MCP Server (${mode})...`);
-        console.log(`Agent: ${agent.constructor.name}`);
-        console.log(`Device: ${device.constructor.name}`);
-        if (additionalInfo?.port !== void 0) console.log(`Port: ${additionalInfo.port}`);
-        if (additionalInfo?.host) console.log(`Host: ${additionalInfo.host}`);
-    }
-    return {
-        async launch (options = {}) {
-            const { verbose = true } = options;
-            validateAgent();
-            if (verbose) logStartupInfo('stdio');
-            const toolsManager = createToolsManager();
-            const server = new MCPServerClass(toolsManager);
-            const result = await server.launch();
-            if (verbose) console.log(`${platformName} MCP Server started (stdio mode)`);
-            return result;
-        },
-        async launchHttp (options) {
-            const { port, host = 'localhost', verbose = true } = options;
-            validateAgent();
-            if (verbose) logStartupInfo('HTTP', {
-                port,
-                host
-            });
-            const toolsManager = createToolsManager();
-            const server = new MCPServerClass(toolsManager);
-            const result = await server.launchHttp({
-                port,
-                host
-            });
-            if (verbose) console.log(`${platformName} MCP Server started on http://${result.host}:${result.port}/mcp`);
-            return result;
-        }
-    };
-}
-export { createMCPServerLauncher };