@midscene/shared 1.0.1-beta-20251208075922.0 → 1.0.1-beta-20251208112226.0

package/dist/lib/mcp/tool-generator.js

@@ -1,252 +0,0 @@
-"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__, {
-    generateToolsFromActionSpace: ()=>generateToolsFromActionSpace,
-    generateCommonTools: ()=>generateCommonTools
-});
-const img_namespaceObject = require("@midscene/shared/img");
-const external_zod_namespaceObject = require("zod");
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function isZodOptional(value) {
-    return '_def' in value && value._def?.typeName === 'ZodOptional';
-}
-function isZodObject(value) {
-    return '_def' in value && value._def?.typeName === 'ZodObject' && 'shape' in value;
-}
-function unwrapOptional(value) {
-    if (isZodOptional(value)) return {
-        innerValue: value._def.innerType,
-        isOptional: true
-    };
-    return {
-        innerValue: value,
-        isOptional: false
-    };
-}
-function isLocateField(value) {
-    if (!isZodObject(value)) return false;
-    return 'prompt' in value.shape;
-}
-function makePromptOptional(value, wrapInOptional) {
-    const newShape = {
-        ...value.shape
-    };
-    newShape.prompt = value.shape.prompt.optional();
-    let newSchema = external_zod_namespaceObject.z.object(newShape).passthrough();
-    if (wrapInOptional) newSchema = newSchema.optional();
-    return newSchema;
-}
-function transformSchemaField(key, value) {
-    const { innerValue, isOptional } = unwrapOptional(value);
-    if (isZodObject(innerValue) && isLocateField(innerValue)) return [
-        key,
-        makePromptOptional(innerValue, isOptional)
-    ];
-    return [
-        key,
-        value
-    ];
-}
-function extractActionSchema(paramSchema) {
-    if (!paramSchema) return {};
-    const schema = paramSchema;
-    if (!isZodObject(schema)) return schema;
-    return Object.fromEntries(Object.entries(schema.shape).map(([key, value])=>transformSchemaField(key, value)));
-}
-function serializeArgsToDescription(args) {
-    try {
-        return Object.entries(args).map(([key, value])=>{
-            if ('object' == typeof value && null !== value) try {
-                return `${key}: ${JSON.stringify(value)}`;
-            } catch  {
-                return `${key}: [object]`;
-            }
-            return `${key}: "${value}"`;
-        }).join(', ');
-    } catch (error) {
-        const errorMessage = getErrorMessage(error);
-        console.error('Error serializing args:', errorMessage);
-        return `[args serialization failed: ${errorMessage}]`;
-    }
-}
-function buildActionInstruction(actionName, args) {
-    const argsDescription = serializeArgsToDescription(args);
-    return argsDescription ? `Use the action "${actionName}" with ${argsDescription}` : `Use the action "${actionName}"`;
-}
-async function captureScreenshotResult(agent, actionName) {
-    try {
-        const screenshot = await agent.page?.screenshotBase64();
-        if (!screenshot) return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Action "${actionName}" completed.`
-                }
-            ]
-        };
-        const { mimeType, body } = (0, img_namespaceObject.parseBase64)(screenshot);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Action "${actionName}" completed.`
-                },
-                {
-                    type: 'image',
-                    data: body,
-                    mimeType
-                }
-            ]
-        };
-    } catch (error) {
-        const errorMessage = getErrorMessage(error);
-        console.error('Error capturing screenshot:', errorMessage);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Action "${actionName}" completed (screenshot unavailable: ${errorMessage})`
-                }
-            ]
-        };
-    }
-}
-function createErrorResult(message) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: message
-            }
-        ],
-        isError: true
-    };
-}
-function generateToolsFromActionSpace(actionSpace, getAgent) {
-    return actionSpace.map((action)=>{
-        const schema = extractActionSchema(action.paramSchema);
-        return {
-            name: action.name,
-            description: action.description || `Execute ${action.name} action`,
-            schema,
-            handler: async (args)=>{
-                try {
-                    const agent = await getAgent();
-                    if (agent.aiAction) {
-                        const instruction = buildActionInstruction(action.name, args);
-                        try {
-                            await agent.aiAction(instruction);
-                        } catch (error) {
-                            const errorMessage = getErrorMessage(error);
-                            console.error(`Error executing action "${action.name}":`, errorMessage);
-                            return createErrorResult(`Failed to execute action "${action.name}": ${errorMessage}`);
-                        }
-                    }
-                    return await captureScreenshotResult(agent, action.name);
-                } catch (error) {
-                    const errorMessage = getErrorMessage(error);
-                    console.error(`Error in handler for "${action.name}":`, errorMessage);
-                    return createErrorResult(`Failed to get agent or execute action "${action.name}": ${errorMessage}`);
-                }
-            },
-            autoDestroy: true
-        };
-    });
-}
-function generateCommonTools(getAgent) {
-    return [
-        {
-            name: 'take_screenshot',
-            description: 'Capture screenshot of current page/screen',
-            schema: {},
-            handler: async ()=>{
-                try {
-                    const agent = await getAgent();
-                    const screenshot = await agent.page?.screenshotBase64();
-                    if (!screenshot) return createErrorResult('Screenshot not available');
-                    const { mimeType, body } = (0, img_namespaceObject.parseBase64)(screenshot);
-                    return {
-                        content: [
-                            {
-                                type: 'image',
-                                data: body,
-                                mimeType
-                            }
-                        ]
-                    };
-                } catch (error) {
-                    const errorMessage = getErrorMessage(error);
-                    console.error('Error taking screenshot:', errorMessage);
-                    return createErrorResult(`Failed to capture screenshot: ${errorMessage}`);
-                }
-            },
-            autoDestroy: true
-        },
-        {
-            name: 'wait_for',
-            description: 'Wait until condition becomes true',
-            schema: {
-                assertion: external_zod_namespaceObject.z.string().describe('Condition to wait for'),
-                timeoutMs: external_zod_namespaceObject.z.number().optional().default(15000),
-                checkIntervalMs: external_zod_namespaceObject.z.number().optional().default(3000)
-            },
-            handler: async (args)=>{
-                try {
-                    const agent = await getAgent();
-                    const { assertion, timeoutMs, checkIntervalMs } = args;
-                    if (agent.aiWaitFor) await agent.aiWaitFor(assertion, {
-                        timeoutMs,
-                        checkIntervalMs
-                    });
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Condition met: "${assertion}"`
-                            }
-                        ]
-                    };
-                } catch (error) {
-                    const errorMessage = getErrorMessage(error);
-                    console.error('Error in wait_for:', errorMessage);
-                    return createErrorResult(`Wait condition failed: ${errorMessage}`);
-                }
-            },
-            autoDestroy: true
-        }
-    ];
-}
-exports.generateCommonTools = __webpack_exports__.generateCommonTools;
-exports.generateToolsFromActionSpace = __webpack_exports__.generateToolsFromActionSpace;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "generateCommonTools",
-    "generateToolsFromActionSpace"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/lib/mcp/types.js

@@ -1,40 +0,0 @@
-"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__, {
-    defaultAppLoadingCheckIntervalMs: ()=>defaultAppLoadingCheckIntervalMs,
-    defaultAppLoadingTimeoutMs: ()=>defaultAppLoadingTimeoutMs
-});
-const defaultAppLoadingTimeoutMs = 10000;
-const defaultAppLoadingCheckIntervalMs = 2000;
-exports.defaultAppLoadingCheckIntervalMs = __webpack_exports__.defaultAppLoadingCheckIntervalMs;
-exports.defaultAppLoadingTimeoutMs = __webpack_exports__.defaultAppLoadingTimeoutMs;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "defaultAppLoadingCheckIntervalMs",
-    "defaultAppLoadingTimeoutMs"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

@@ -1,77 +0,0 @@
-import type { ParseArgsConfig } from 'node:util';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { IMidsceneTools } from './types';
-export interface BaseMCPServerConfig {
-    name: string;
-    version: string;
-    description: string;
-}
-export interface HttpLaunchOptions {
-    port: number;
-    host?: string;
-}
-/**
- * CLI argument configuration for MCP servers
- */
-export declare const CLI_ARGS_CONFIG: ParseArgsConfig['options'];
-export interface CLIArgs {
-    mode?: string;
-    port?: string;
-    host?: string;
-}
-/**
- * Launch an MCP server based on CLI arguments
- * Shared helper to reduce duplication across platform CLI entry points
- */
-export declare function launchMCPServer(server: BaseMCPServer, args: CLIArgs): Promise<void>;
-/**
- * Base MCP Server class with programmatic launch() API
- * Each platform extends this to provide their own tools manager
- */
-export declare abstract class BaseMCPServer {
-    protected mcpServer: McpServer;
-    protected toolsManager?: IMidsceneTools;
-    protected config: BaseMCPServerConfig;
-    constructor(config: BaseMCPServerConfig);
-    /**
-     * Platform-specific: create tools manager instance
-     */
-    protected abstract createToolsManager(): IMidsceneTools;
-    /**
-     * Initialize tools manager and attach to MCP server
-     */
-    private initializeToolsManager;
-    /**
-     * Perform cleanup on shutdown
-     */
-    private performCleanup;
-    /**
-     * Initialize and launch the MCP server with stdio transport
-     */
-    launch(): Promise<void>;
-    /**
-     * Launch MCP server with HTTP transport
-     * Supports stateful sessions for web applications and service integration
-     */
-    launchHttp(options: HttpLaunchOptions): Promise<void>;
-    /**
-     * Create a new HTTP session with transport
-     */
-    private createHttpSession;
-    /**
-     * Start periodic session cleanup for inactive sessions
-     */
-    private startSessionCleanup;
-    /**
-     * Setup shutdown handlers for HTTP server
-     */
-    private setupHttpShutdownHandlers;
-    /**
-     * Get the underlying MCP server instance
-     */
-    getServer(): McpServer;
-    /**
-     * Get the tools manager instance
-     */
-    getToolsManager(): IMidsceneTools | undefined;
-}

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

@@ -1,55 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { BaseAgent, BaseDevice, IMidsceneTools, ToolDefinition } from './types';
-/**
- * Base class for platform-specific MCP tools
- * Generic type TAgent allows subclasses to use their specific agent types
- */
-export declare abstract class BaseMidsceneTools<TAgent extends BaseAgent = BaseAgent> implements IMidsceneTools {
-    protected mcpServer?: McpServer;
-    protected agent?: TAgent;
-    protected toolDefinitions: ToolDefinition[];
-    /**
-     * Ensure agent is initialized and ready for use.
-     * Must be implemented by subclasses to create platform-specific agent.
-     * @param initParam Optional initialization parameter (platform-specific, e.g., URL, device ID)
-     * @returns Promise resolving to initialized agent instance
-     * @throws Error if agent initialization fails
-     */
-    protected abstract ensureAgent(initParam?: string): Promise<TAgent>;
-    /**
-     * Optional: prepare platform-specific tools (e.g., device connection)
-     */
-    protected preparePlatformTools(): ToolDefinition[];
-    /**
-     * Must be implemented by subclasses to create a temporary device instance
-     * This allows getting real actionSpace without connecting to device
-     */
-    protected abstract createTemporaryDevice(): BaseDevice;
-    /**
-     * Initialize all tools by querying actionSpace
-     * Uses two-layer fallback strategy:
-     * 1. Try to get actionSpace from connected agent (if available)
-     * 2. Create temporary device instance to read actionSpace (always succeeds)
-     */
-    initTools(): Promise<void>;
-    /**
-     * Attach to MCP server and register all tools
-     */
-    attachToServer(server: McpServer): void;
-    /**
-     * Wrapper for auto-destroy behavior
-     */
-    private toolWithAutoDestroy;
-    /**
-     * Cleanup method - destroy agent and release resources
-     */
-    closeBrowser(): Promise<void>;
-    /**
-     * Helper: Convert base64 screenshot to image content array
-     */
-    protected buildScreenshotContent(screenshot: string): {
-        type: "image";
-        data: string;
-        mimeType: string;
-    }[];
-}

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

@@ -1,5 +0,0 @@
-export * from './base-server';
-export * from './base-tools';
-export * from './tool-generator';
-export * from './types';
-export * from './inject-report-html-plugin';

package/dist/types/mcp/inject-report-html-plugin.d.ts

@@ -1,18 +0,0 @@
-interface RslibPluginApi {
-    onAfterBuild: (callback: () => void) => void;
-}
-/**
- * Rslib plugin to inject report HTML from @midscene/core dist into MCP bundle.
- * This runs after build and reads the already-injected HTML from core.
- *
- * Prerequisites:
- * - @midscene/report must be in devDependencies to ensure correct build order
- * - @midscene/core dist must exist with injected HTML
- *
- * @param packageDir - The directory of the MCP package (use __dirname)
- */
-export declare function injectReportHtmlFromCore(packageDir: string): {
-    name: string;
-    setup(api: RslibPluginApi): void;
-};
-export {};

package/dist/types/mcp/tool-generator.d.ts

@@ -1,11 +0,0 @@
-import type { ActionSpaceItem, BaseAgent, ToolDefinition } from './types';
-/**
- * Converts DeviceAction from actionSpace into MCP ToolDefinition
- * This is the core logic that removes need for hardcoded tool definitions
- */
-export declare function generateToolsFromActionSpace(actionSpace: ActionSpaceItem[], getAgent: () => Promise<BaseAgent>): ToolDefinition[];
-/**
- * Generate common tools (screenshot, waitFor)
- * SIMPLIFIED: Only keep essential helper tools, removed assert
- */
-export declare function generateCommonTools(getAgent: () => Promise<BaseAgent>): ToolDefinition[];

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

@@ -1,100 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { z } from 'zod';
-/**
- * Default timeout constants for app loading verification
- */
-export declare const defaultAppLoadingTimeoutMs = 10000;
-export declare const defaultAppLoadingCheckIntervalMs = 2000;
-/**
- * Content item types for tool results (MCP compatible)
- */
-export type ToolResultContent = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'image';
-    data: string;
-    mimeType: string;
-} | {
-    type: 'audio';
-    data: string;
-    mimeType: string;
-} | {
-    type: 'resource';
-    resource: {
-        text: string;
-        uri: string;
-        mimeType?: string;
-    } | {
-        uri: string;
-        blob: string;
-        mimeType?: string;
-    };
-};
-/**
- * Result type for tool execution (MCP compatible)
- */
-export interface ToolResult {
-    [x: string]: unknown;
-    content: ToolResultContent[];
-    isError?: boolean;
-    _meta?: Record<string, unknown>;
-}
-/**
- * Tool handler function type
- * Takes parsed arguments and returns a tool result
- */
-export type ToolHandler<T = Record<string, unknown>> = (args: T) => Promise<ToolResult>;
-/**
- * Tool schema type using Zod
- */
-export type ToolSchema = Record<string, z.ZodTypeAny>;
-/**
- * Tool definition for MCP server
- */
-export interface ToolDefinition<T = Record<string, unknown>> {
-    name: string;
-    description: string;
-    schema: ToolSchema;
-    handler: ToolHandler<T>;
-    autoDestroy?: boolean;
-}
-/**
- * Action space item definition
- * Note: Intentionally no index signature to maintain compatibility with DeviceAction
- */
-export interface ActionSpaceItem {
-    name: string;
-    description?: string;
-    args?: Record<string, unknown>;
-    paramSchema?: z.ZodTypeAny;
-}
-/**
- * Base agent interface
- * Represents a platform-specific agent (Android, iOS, Web)
- * Note: Return types use `unknown` for compatibility with platform-specific implementations
- */
-export interface BaseAgent {
-    getActionSpace(): Promise<ActionSpaceItem[]>;
-    destroy?(): Promise<void>;
-    page?: {
-        screenshotBase64(): Promise<string>;
-    };
-    aiAction?: (description: string, params?: Record<string, unknown>) => Promise<unknown>;
-    aiWaitFor?: (assertion: string, options: Record<string, unknown>) => Promise<unknown>;
-}
-/**
- * Base device interface for temporary device instances
- */
-export interface BaseDevice {
-    actionSpace(): ActionSpaceItem[];
-    destroy?(): Promise<void>;
-}
-/**
- * Interface for platform-specific MCP tools manager
- */
-export interface IMidsceneTools {
-    attachToServer(server: McpServer): void;
-    initTools(): Promise<void>;
-    closeBrowser?(): Promise<void>;
-}