@xiuchang-midscene/shared 2.0.2 → 2.0.3

package/dist/types/img/canvas-fallback.d.ts.bak

@@ -1,105 +0,0 @@
-/**
- * Canvas-based fallback for image processing when Photon WASM fails to load.
- * Provides a compatible API with Photon for browser environments.
- */
-/**
- * Canvas-based image class that mimics PhotonImage API
- */
-export declare class CanvasImage {
-    private canvas;
-    private ctx;
-    private _width;
-    private _height;
-    constructor(canvas: HTMLCanvasElement);
-    get_width(): number;
-    get_height(): number;
-    get_raw_pixels(): Uint8Array;
-    get_bytes_jpeg(quality: number): Uint8Array;
-    free(): void;
-    _getCanvas(): HTMLCanvasElement;
-    _getContext(): CanvasRenderingContext2D;
-    /**
-     * Create a CanvasImage from a base64 string
-     */
-    static new_from_base64(base64Body: string): Promise<CanvasImage>;
-    /**
-     * Create a CanvasImage from a byte array (async version)
-     */
-    static new_from_byteslice(bytes: Uint8Array): Promise<CanvasImage>;
-}
-/**
- * Sampling filter enum (compatible with Photon)
- */
-export declare const CanvasSamplingFilter: {
-    readonly Nearest: "nearest";
-    readonly Triangle: "triangle";
-    readonly CatmullRom: "catmullrom";
-    readonly Gaussian: "gaussian";
-    readonly Lanczos3: "lanczos3";
-};
-/**
- * RGBA color class (compatible with Photon)
- */
-export declare class CanvasRgba {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-    constructor(r: number, g: number, b: number, a: number);
-}
-/**
- * Resize an image
- */
-export declare function canvasResize(image: CanvasImage, newWidth: number, newHeight: number, _filter: string): CanvasImage;
-/**
- * Crop an image
- */
-export declare function canvasCrop(image: CanvasImage, x1: number, y1: number, x2: number, y2: number): CanvasImage;
-/**
- * Add padding to the right of an image
- */
-export declare function canvasPaddingRight(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
-/**
- * Add padding to the bottom of an image
- */
-export declare function canvasPaddingBottom(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
-/**
- * Add uniform padding to an image
- */
-export declare function canvasPaddingUniform(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
-/**
- * Add padding to the left of an image
- */
-export declare function canvasPaddingLeft(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
-/**
- * Add padding to the top of an image
- */
-export declare function canvasPaddingTop(image: CanvasImage, padding: number, color: CanvasRgba): CanvasImage;
-/**
- * Watermark an image (overlay one image on another)
- */
-export declare function canvasWatermark(base: CanvasImage, overlay: CanvasImage, x: number, y: number): CanvasImage;
-/**
- * Create and return the canvas fallback module with Photon-compatible API
- */
-export declare function createCanvasFallbackModule(): {
-    PhotonImage: typeof CanvasImage;
-    SamplingFilter: {
-        readonly Nearest: "nearest";
-        readonly Triangle: "triangle";
-        readonly CatmullRom: "catmullrom";
-        readonly Gaussian: "gaussian";
-        readonly Lanczos3: "lanczos3";
-    };
-    resize: typeof canvasResize;
-    crop: typeof canvasCrop;
-    open_image: () => never;
-    base64_to_image: typeof CanvasImage.new_from_base64;
-    padding_uniform: typeof canvasPaddingUniform;
-    padding_left: typeof canvasPaddingLeft;
-    padding_right: typeof canvasPaddingRight;
-    padding_top: typeof canvasPaddingTop;
-    padding_bottom: typeof canvasPaddingBottom;
-    watermark: typeof canvasWatermark;
-    Rgba: typeof CanvasRgba;
-};

package/dist/types/img/get-photon.d.ts.bak

@@ -1,19 +0,0 @@
-export default function getPhoton(): Promise<{
-    PhotonImage: typeof import('@silvia-odwyer/photon-node').PhotonImage;
-    SamplingFilter: typeof import('@silvia-odwyer/photon-node').SamplingFilter;
-    resize: typeof import('@silvia-odwyer/photon-node').resize;
-    crop: typeof import('@silvia-odwyer/photon-node').crop;
-    open_image: typeof import('@silvia-odwyer/photon-node').open_image;
-    base64_to_image: typeof import('@silvia-odwyer/photon-node').base64_to_image;
-    padding_uniform: typeof import('@silvia-odwyer/photon-node').padding_uniform;
-    padding_left: typeof import('@silvia-odwyer/photon-node').padding_left;
-    padding_right: typeof import('@silvia-odwyer/photon-node').padding_right;
-    padding_top: typeof import('@silvia-odwyer/photon-node').padding_top;
-    padding_bottom: typeof import('@silvia-odwyer/photon-node').padding_bottom;
-    watermark: typeof import('@silvia-odwyer/photon-node').watermark;
-    Rgba: typeof import('@silvia-odwyer/photon-node').Rgba;
-}>;
-/**
- * Check if we're using the Canvas fallback instead of Photon
- */
-export declare function isUsingCanvasFallback(): boolean;

package/dist/types/img/get-sharp.d.ts.bak

@@ -1,3 +0,0 @@
-type TSharpModule = typeof import('sharp');
-export default function getSharp(): Promise<TSharpModule>;
-export {};

package/dist/types/img/index.d.ts.bak

@@ -1,3 +0,0 @@
-export { imageInfoOfBase64, isValidPNGImageBuffer, isValidJPEGImageBuffer, isValidImageBuffer, } from './info';
-export { resizeAndConvertImgBuffer, resizeImgBase64, convertToJpegBase64, zoomForGPT4o, saveBase64Image, paddingToMatchBlockByBase64, cropByRect, scaleImage, localImg2Base64, httpImg2Base64, preProcessImageUrl, parseBase64, createImgBase64ByFormat, } from './transform';
-export { processImageElementInfo, compositeElementInfoImg, annotateRects, } from './box-select';

package/dist/types/img/info.d.ts.bak

@@ -1,29 +0,0 @@
-import type { Size } from '../types';
-export interface ImageInfo extends Size {
-}
-/**
- * Retrieves the dimensions of an image from a base64-encoded string
- *
- * @param imageBase64 - The base64-encoded image data
- * @returns A Promise that resolves to an object containing the width and height of the image
- * @throws Error if the image data is invalid
- */
-export declare function imageInfoOfBase64(imageBase64: string): Promise<ImageInfo>;
-/**
- * Check if the Buffer is a valid PNG image
- * @param buffer The Buffer to check
- * @returns true if the Buffer is a valid PNG image, otherwise false
- */
-export declare function isValidPNGImageBuffer(buffer: Buffer): boolean;
-/**
- * Check if the Buffer is a valid JPEG image
- * @param buffer The Buffer to check
- * @returns true if the Buffer is a valid JPEG image, otherwise false
- */
-export declare function isValidJPEGImageBuffer(buffer: Buffer): boolean;
-/**
- * Check if the Buffer is a valid image (PNG or JPEG)
- * @param buffer The Buffer to check
- * @returns true if the Buffer is a valid PNG or JPEG image, otherwise false
- */
-export declare function isValidImageBuffer(buffer: Buffer): boolean;

package/dist/types/img/transform.d.ts.bak

@@ -1,107 +0,0 @@
-import { Buffer } from 'node:buffer';
-import type { PhotonImage as PhotonImageType } from '@silvia-odwyer/photon-node';
-import type { Rect } from '../types';
-/**
- * Saves a Base64-encoded image to a file
- *
- * @param options - An object containing the Base64-encoded image data and the output file path
- * @param options.base64Data - The Base64-encoded image data
- * @param options.outputPath - The path where the image will be saved
- * @throws Error if there is an error during the saving process
- */
-export declare function saveBase64Image(options: {
-    base64Data: string;
-    outputPath: string;
-}): Promise<void>;
-/**
- * Resizes an image from Buffer, maybe return a new format
- * - If the image is Resized, the returned format will be jpg.
- * - If the image is not Resized, it will return to its original format.
- * @returns { buffer: resized buffer, format: the new format}
- */
-export declare function resizeAndConvertImgBuffer(inputFormat: string, inputData: Buffer, newSize: {
-    width: number;
-    height: number;
-}): Promise<{
-    buffer: Buffer;
-    format: string;
-}>;
-export declare const createImgBase64ByFormat: (format: string, body: string) => string;
-export declare function resizeImgBase64(inputBase64: string, newSize: {
-    width: number;
-    height: number;
-}): Promise<string>;
-/**
- * Calculates new dimensions for an image while maintaining its aspect ratio.
- *
- * This function is designed to resize an image to fit within a specified maximum width and height
- * while maintaining the original aspect ratio. If the original width or height exceeds the maximum
- * dimensions, the image will be scaled down to fit.
- *
- * @param {number} originalWidth - The original width of the image.
- * @param {number} originalHeight - The original height of the image.
- * @returns {Object} An object containing the new width and height.
- * @throws {Error} Throws an error if the width or height is not a positive number.
- */
-export declare function zoomForGPT4o(originalWidth: number, originalHeight: number): {
-    width: number;
-    height: number;
-};
-export declare function photonFromBase64(base64: string): Promise<PhotonImageType>;
-export declare function paddingToMatchBlock(image: PhotonImageType, blockSize?: number): Promise<{
-    width: number;
-    height: number;
-    image: PhotonImageType;
-}>;
-export declare function paddingToMatchBlockByBase64(imageBase64: string, blockSize?: number): Promise<{
-    width: number;
-    height: number;
-    imageBase64: string;
-}>;
-export declare function cropByRect(imageBase64: string, rect: Rect, paddingImage: boolean): Promise<{
-    width: number;
-    height: number;
-    imageBase64: string;
-}>;
-export declare function photonToBase64(image: PhotonImageType, quality?: number): Promise<string>;
-export declare const httpImg2Base64: (url: string) => Promise<string>;
-/**
- * Convert image file to base64 string
- * Because this method is synchronous, the npm package `sharp` cannot be used to detect the file type.
- * TODO: convert to webp to reduce base64 size.
- */
-export declare const localImg2Base64: (imgPath: string, withoutHeader?: boolean) => string;
-/**
- * PreProcess image url to ensure image is accessible to LLM.
- * @param url - The url of the image, it can be a http url or a base64 string or a file path
- * @param convertHttpImage2Base64 - Whether to convert http image to base64, if true, the http image will be converted to base64, otherwise, the http image will be returned as is
- * @returns The base64 string of the image (when convertHttpImage2Base64 is true or url is a file path) or the http image url
- */
-export declare const preProcessImageUrl: (url: string, convertHttpImage2Base64: boolean) => Promise<string>;
-/**
- * parse base64 string to get mimeType and body
- */
-export declare const parseBase64: (fullBase64String: string) => {
-    mimeType: string;
-    body: string;
-};
-/**
- * Convert a base64 image to JPEG with specified quality (no resize).
- * If the image is already JPEG, re-encodes at the given quality.
- *
- * @param inputBase64 - Full data-URI base64 string (e.g. "data:image/png;base64,...")
- * @param quality - JPEG quality 1-100
- * @returns JPEG data-URI base64 string
- */
-export declare function convertToJpegBase64(inputBase64: string, quality: number): Promise<string>;
-/**
- * Scales an image by a specified factor using Sharp or Photon
- * @param imageBase64 - Base64 encoded image
- * @param scale - Scale factor (e.g., 2 for 2x, 1.5 for 1.5x)
- * @returns Scaled image with new dimensions
- */
-export declare function scaleImage(imageBase64: string, scale: number): Promise<{
-    width: number;
-    height: number;
-    imageBase64: string;
-}>;

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

@@ -1,4 +0,0 @@
-export { createCopyStaticPlugin, createPlaygroundCopyPlugin, } from './build/copy-static';
-export { commonIgnoreWarnings } from './build/rspack-config';
-declare const _default: {};
-export default _default;

package/dist/types/logger.d.ts.bak

@@ -1,5 +0,0 @@
-export type DebugFunction = (...args: unknown[]) => void;
-export declare function getDebug(topic: string, options?: {
-    console?: boolean;
-}): DebugFunction;
-export declare function enableDebug(topic: string): void;

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

@@ -1,93 +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;
-}
-export interface LaunchMCPServerResult {
-    /**
-     * The MCP server port (for HTTP mode)
-     */
-    port?: number;
-    /**
-     * The server host (for HTTP mode)
-     */
-    host?: string;
-    /**
-     * Function to gracefully shutdown the MCP server
-     */
-    close: () => Promise<void>;
-}
-/**
- * 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<LaunchMCPServerResult>;
-/**
- * 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;
-    protected providedToolsManager?: IMidsceneTools;
-    constructor(config: BaseMCPServerConfig, toolsManager?: IMidsceneTools);
-    /**
-     * Platform-specific: create tools manager instance
-     * This is only called if no tools manager was provided in constructor
-     */
-    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<LaunchMCPServerResult>;
-    /**
-     * Launch MCP server with HTTP transport
-     * Supports stateful sessions for web applications and service integration
-     */
-    launchHttp(options: HttpLaunchOptions): Promise<LaunchMCPServerResult>;
-    /**
-     * 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.bak

@@ -1,79 +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;
-    /**
-     * Cleanup method - destroy agent and release resources
-     */
-    destroy(): Promise<void>;
-    /**
-     * Get tool definitions
-     */
-    getToolDefinitions(): ToolDefinition[];
-    /**
-     * Set agent for the tools manager
-     */
-    setAgent(agent: TAgent): void;
-    /**
-     * Helper: Convert base64 screenshot to image content array
-     */
-    protected buildScreenshotContent(screenshot: string): {
-        type: "image";
-        data: string;
-        mimeType: string;
-    }[];
-    /**
-     * Helper: Build a simple text result for tool responses
-     */
-    protected buildTextResult(text: string): {
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    };
-    /**
-     * Create a disconnect handler for releasing platform resources
-     * @param platformName Human-readable platform name for the response message
-     * @returns Handler function that destroys the agent and returns appropriate response
-     */
-    protected createDisconnectHandler(platformName: string): () => Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-}

package/dist/types/mcp/chrome-path.d.ts.bak

@@ -1,2 +0,0 @@
-export declare function getSystemChromePath(): string | undefined;
-export declare function resolveChromePath(): string;

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

@@ -1,7 +0,0 @@
-export * from './base-server';
-export * from './base-tools';
-export * from './tool-generator';
-export * from './types';
-export * from './inject-report-html-plugin';
-export * from './launcher-helper';
-export * from './chrome-path';

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

@@ -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/launcher-helper.d.ts.bak

@@ -1,94 +0,0 @@
-import type { BaseMCPServer } from './base-server';
-import type { HttpLaunchOptions, LaunchMCPServerResult } from './base-server';
-import type { IMidsceneTools } from './types';
-export interface LaunchMCPServerOptions extends HttpLaunchOptions {
-    /**
-     * Whether to show server logs
-     * @default true
-     */
-    verbose?: boolean;
-}
-/**
- * Generic agent type (avoid importing from @midscene/core to prevent circular deps)
- */
-export interface GenericAgent<TDevice = any> {
-    interface: TDevice;
-    constructor: {
-        name: string;
-    };
-}
-/**
- * Additional information for logging server startup
- */
-export interface StartupInfo {
-    port?: number;
-    host?: string;
-}
-export interface MCPServerLauncherConfig<AgentType extends GenericAgent = GenericAgent, ToolsManagerType extends IMidsceneTools = IMidsceneTools> {
-    agent: AgentType;
-    platformName: string;
-    ToolsManagerClass: new (...args: any[]) => ToolsManagerType;
-    MCPServerClass: new (toolsManager?: ToolsManagerType) => BaseMCPServer;
-}
-/**
- * Create a generic MCP server launcher for a given agent, tools manager, and MCP server.
- *
- * This helper centralizes the common wiring logic used by platform-specific launchers:
- * it constructs a tools manager, attaches the provided `agent` to it, then instantiates
- * the `MCPServerClass` and exposes convenience methods to start the server over stdio
- * (`launch`) or HTTP (`launchHttp`).
- *
- * Use this helper when adding a new platform-specific launcher or when you want to
- * avoid duplicating boilerplate code for starting an MCP server. Typically, callers
- * provide:
- * - an `agent` instance that contains the underlying device on its `interface` property
- * - a `ToolsManagerClass` that knows how to expose tools for that agent
- * - an `MCPServerClass` that implements the MCP protocol and supports `launch` and
- *   `launchHttp` methods.
- *
- * The returned object has two methods:
- * - `launch(options?)` to start the server using stdio transport
- * - `launchHttp(options)` to start the server using HTTP transport
- * Both methods accept a `verbose` flag to control console logging.
- *
- * @param config Configuration describing the agent, platform name (for logging),
- *               tools manager implementation, and MCP server implementation.
- *
- * @returns An object with `launch` and `launchHttp` methods to start the MCP server.
- *
- * @example
- * ```typescript
- * import { createMCPServerLauncher } from '@midscene/shared/mcp';
- * import { Agent } from '@midscene/core/agent';
- * import { WebMidsceneTools } from './web-tools';
- * import { WebMCPServer } from './server';
- *
- * const agent = new Agent();
- * const launcher = createMCPServerLauncher({
- *   agent,
- *   platformName: 'Web',
- *   ToolsManagerClass: WebMidsceneTools,
- *   MCPServerClass: WebMCPServer,
- * });
- *
- * // Start with stdio
- * await launcher.launch({ verbose: true });
- *
- * // Or start with HTTP
- * await launcher.launchHttp({ port: 3000, host: 'localhost' });
- * ```
- *
- * @internal
- */
-export declare function createMCPServerLauncher<AgentType extends GenericAgent, ToolsManagerType extends IMidsceneTools>(config: MCPServerLauncherConfig<AgentType, ToolsManagerType>): {
-    /**
-     * Launch the MCP server with stdio transport
-     */
-    launch(options?: {
-        verbose?: boolean;
-    }): Promise<LaunchMCPServerResult>;
-    /**
-     * Launch the MCP server with HTTP transport
-     */
-    launchHttp(options: LaunchMCPServerOptions): Promise<LaunchMCPServerResult>;
-};

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

@@ -1,10 +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, act)
- */
-export declare function generateCommonTools(getAgent: () => Promise<BaseAgent>): ToolDefinition[];