@rvaim/deveco-mobile-mcp 0.1.0-rvaim.1

package/lib/server.js

@@ -0,0 +1,615 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = exports.getAgentVersion = void 0;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const logger_1 = require("./logger");
+const android_1 = require("./android");
+const robot_1 = require("./robot");
+const ios_1 = require("./ios");
+const harmony_1 = require("./harmony");
+const png_1 = require("./png");
+const jpeg_1 = require("./jpeg");
+const image_utils_1 = require("./image-utils");
+const mobilecli_1 = require("./mobilecli");
+const mobile_device_1 = require("./mobile-device");
+const utils_1 = require("./utils");
+const ALLOWED_SCREENSHOT_EXTENSIONS = [".png", ".jpg", ".jpeg"];
+const ALLOWED_RECORDING_EXTENSIONS = [".mp4"];
+const getAgentVersion = () => {
+    const json = require("../package.json");
+    return json.version;
+};
+exports.getAgentVersion = getAgentVersion;
+const createMcpServer = () => {
+    const server = new mcp_js_1.McpServer({
+        name: "mobile-mcp",
+        version: (0, exports.getAgentVersion)(),
+    });
+    const getClientName = () => {
+        try {
+            const clientInfo = server.server.getClientVersion();
+            const clientName = clientInfo?.name || "unknown";
+            return clientName;
+        }
+        catch (error) {
+            return "unknown";
+        }
+    };
+    const tool = (name, title, description, paramsSchema, annotations, cb) => {
+        server.registerTool(name, {
+            title,
+            description,
+            inputSchema: paramsSchema,
+            annotations,
+        }, (async (args, _extra) => {
+            try {
+                (0, logger_1.trace)(`Invoking ${name} with args: ${JSON.stringify(args)}`);
+                const start = +new Date();
+                const response = await cb(args);
+                const duration = +new Date() - start;
+                (0, logger_1.trace)(`=> ${response}`);
+                posthog("tool_invoked", { "ToolName": name, "Duration": duration }).then();
+                return {
+                    content: [{ type: "text", text: response }],
+                };
+            }
+            catch (error) {
+                posthog("tool_failed", { "ToolName": name }).then();
+                if (error instanceof robot_1.ActionableError) {
+                    return {
+                        content: [{ type: "text", text: `${error.message}. Please fix the issue and try again.` }],
+                    };
+                }
+                else {
+                    // a real exception
+                    (0, logger_1.trace)(`Tool '${description}' failed: ${error.message} stack: ${error.stack}`);
+                    return {
+                        content: [{ type: "text", text: `Error: ${error.message}` }],
+                        isError: true,
+                    };
+                }
+            }
+        }));
+    };
+    const posthog = async (event, properties) => {
+        try {
+            const url = "https://us.i.posthog.com/i/v0/e/";
+            const api_key = "phc_KHRTZmkDsU7A8EbydEK8s4lJpPoTDyyBhSlwer694cS";
+            const name = node_os_1.default.hostname() + process.execPath;
+            const distinct_id = node_crypto_1.default.createHash("sha256").update(name).digest("hex");
+            const systemProps = {
+                Platform: node_os_1.default.platform(),
+                Product: "mobile-mcp",
+                Version: (0, exports.getAgentVersion)(),
+                NodeVersion: process.version,
+            };
+            const clientName = getClientName();
+            if (clientName !== "unknown") {
+                systemProps.AgentName = clientName;
+            }
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    api_key,
+                    event,
+                    properties: {
+                        ...systemProps,
+                        ...properties,
+                    },
+                    distinct_id,
+                })
+            });
+        }
+        catch (err) {
+            // ignore
+        }
+    };
+    const mobilecli = new mobilecli_1.Mobilecli();
+    const activeRecordings = new Map();
+    posthog("launch", {}).then();
+    const ensureMobilecliAvailable = () => {
+        try {
+            const version = mobilecli.getVersion();
+            if (version.startsWith("failed")) {
+                throw new Error("mobilecli version check failed");
+            }
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`mobilecli is not available or not working properly. Please review the documentation at https://github.com/mobile-next/mobile-mcp/wiki for installation instructions`);
+        }
+    };
+    const isHarmonyDevice = (deviceId) => {
+        const harmonyManager = new harmony_1.HarmonyDeviceManager();
+        const harmonyDevices = harmonyManager.getConnectedDevices();
+        return harmonyDevices.some(d => d.deviceId === deviceId);
+    };
+    const getRobotFromDevice = (deviceId) => {
+        // from now on, we must have mobilecli working
+        ensureMobilecliAvailable();
+        // Check if it's a HarmonyOS device (emulator or real device)
+        const harmonyManager = new harmony_1.HarmonyDeviceManager();
+        const harmonyDevices = harmonyManager.getConnectedDevices();
+        const harmonyDevice = harmonyDevices.find(d => d.deviceId === deviceId);
+        if (harmonyDevice) {
+            return new harmony_1.HarmonyRobot(deviceId);
+        }
+        // Check if it's an iOS device
+        const iosManager = new ios_1.IosManager();
+        const iosDevices = iosManager.listDevices();
+        const iosDevice = iosDevices.find(d => d.deviceId === deviceId);
+        if (iosDevice) {
+            return new ios_1.IosRobot(deviceId);
+        }
+        // Check if it's an Android device
+        const androidManager = new android_1.AndroidDeviceManager();
+        const androidDevices = androidManager.getConnectedDevices();
+        const androidDevice = androidDevices.find(d => d.deviceId === deviceId);
+        if (androidDevice) {
+            return new android_1.AndroidRobot(deviceId);
+        }
+        // Check if it's a simulator (will later replace all other device types as well)
+        const response = mobilecli.getDevices({
+            platform: "ios",
+            type: "simulator",
+            includeOffline: false,
+        });
+        if (response.status === "ok" && response.data && response.data.devices) {
+            for (const device of response.data.devices) {
+                if (device.id === deviceId) {
+                    return new mobile_device_1.MobileDevice(deviceId);
+                }
+            }
+        }
+        throw new robot_1.ActionableError(`Device "${deviceId}" not found. Use of mobile_list_available_devices tool to see available devices.`);
+    };
+    tool("mobile_list_available_devices", "List Devices", "List all available devices. This includes both physical mobile devices and mobile simulators and emulators. It returns Android, iOS, and HarmonyOS devices.\n\nFor HarmonyOS emulators that are offline, use mobile_start_emulator to start them.", {}, { readOnlyHint: true }, async ({}) => {
+        // from today onward, we must have mobilecli working
+        ensureMobilecliAvailable();
+        const iosManager = new ios_1.IosManager();
+        const androidManager = new android_1.AndroidDeviceManager();
+        const harmonyManager = new harmony_1.HarmonyDeviceManager();
+        const devices = [];
+        // Get HarmonyOS devices (emulators and real devices)
+        try {
+            const harmonyDevices = harmonyManager.getAllAvailableDevices();
+            for (const device of harmonyDevices) {
+                devices.push({
+                    id: device.deviceId,
+                    name: device.name,
+                    platform: "harmonyos",
+                    type: device.deviceType,
+                    version: device.version,
+                    state: device.deviceId ? "online" : "offline",
+                });
+            }
+        }
+        catch (error) {
+            // If HarmonyOS tools are not available, silently skip
+        }
+        // Get Android devices with details
+        const androidDevices = androidManager.getConnectedDevicesWithDetails();
+        for (const device of androidDevices) {
+            devices.push({
+                id: device.deviceId,
+                name: device.name,
+                platform: "android",
+                type: "emulator",
+                version: device.version,
+                state: "online",
+            });
+        }
+        // Get iOS physical devices with details
+        try {
+            const iosDevices = iosManager.listDevicesWithDetails();
+            for (const device of iosDevices) {
+                devices.push({
+                    id: device.deviceId,
+                    name: device.deviceName,
+                    platform: "ios",
+                    type: "real",
+                    version: device.version,
+                    state: "online",
+                });
+            }
+        }
+        catch (error) {
+            // If go-ios is not available, silently skip
+        }
+        // Get iOS simulators from mobilecli (excluding offline devices)
+        const response = mobilecli.getDevices({
+            platform: "ios",
+            type: "simulator",
+            includeOffline: false,
+        });
+        if (response.status === "ok" && response.data && response.data.devices) {
+            for (const device of response.data.devices) {
+                devices.push({
+                    id: device.id,
+                    name: device.name,
+                    platform: device.platform,
+                    type: device.type,
+                    version: device.version,
+                    state: "online",
+                });
+            }
+        }
+        const out = { devices };
+        return JSON.stringify(out);
+    });
+    tool("mobile_start_emulator", "Start Emulator", "Start a HarmonyOS emulator by name. Use mobile_list_available_devices to see available emulators.", {
+        name: zod_1.z.string().describe("The name of the emulator to start (e.g., 'Enjoy 90 Pro Max')"),
+    }, { destructiveHint: true }, async ({ name }) => {
+        const harmonyManager = new harmony_1.HarmonyDeviceManager();
+        const deviceId = await harmonyManager.startEmulator(name);
+        if (deviceId) {
+            return `Emulator "${name}" started successfully. Device ID: ${deviceId}`;
+        }
+        return `Emulator "${name}" started but device ID was not returned. It may still be booting.`;
+    });
+    if (process.env.MOBILEFLEET_ENABLE === "1") {
+        tool("mobile_list_fleet_devices", "List Fleet Devices", "List devices available in the remote fleet", {}, { readOnlyHint: true }, async ({}) => {
+            ensureMobilecliAvailable();
+            const result = mobilecli.fleetListDevices();
+            return result;
+        });
+        tool("mobile_allocate_fleet_device", "Allocate Fleet Device", "Reserve a device from the remote fleet", {
+            platform: zod_1.z.enum(["ios", "android"]).describe("The platform to allocate a device for"),
+        }, { destructiveHint: true }, async ({ platform }) => {
+            ensureMobilecliAvailable();
+            const result = mobilecli.fleetAllocate(platform);
+            return result;
+        });
+        tool("mobile_release_fleet_device", "Release Fleet Device", "Release a device back to the remote fleet", {
+            device: zod_1.z.string().describe("The device identifier to release back to the fleet"),
+        }, { destructiveHint: true }, async ({ device }) => {
+            ensureMobilecliAvailable();
+            const result = mobilecli.fleetRelease(device);
+            return result;
+        });
+    }
+    tool("mobile_list_apps", "List Apps", "List all the installed apps on the device", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
+    }, { readOnlyHint: true }, async ({ device }) => {
+        const robot = getRobotFromDevice(device);
+        const result = await robot.listApps();
+        return `Found these apps on device: ${result.map(app => `${app.appName} (${app.packageName})`).join(", ")}`;
+    });
+    tool("mobile_launch_app", "Launch App", "Launch an app on mobile device. Use this to open a specific app. You can find the package name of the app by calling list_apps_on_device.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        packageName: zod_1.z.string().describe("The package name of the app to launch"),
+        locale: zod_1.z.string().optional().describe("Comma-separated BCP 47 locale tags to launch the app with (e.g., fr-FR,en-GB)"),
+    }, { destructiveHint: true }, async ({ device, packageName, locale }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.launchApp(packageName, locale);
+        return `Launched app ${packageName}`;
+    });
+    tool("mobile_terminate_app", "Terminate App", "Stop and terminate an app on mobile device", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        packageName: zod_1.z.string().describe("The package name of the app to terminate"),
+    }, { destructiveHint: true }, async ({ device, packageName }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.terminateApp(packageName);
+        return `Terminated app ${packageName}`;
+    });
+    tool("mobile_install_app", "Install App", "Install an app on mobile device", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        path: zod_1.z.string().describe("The path to the app file to install. For iOS simulators, provide a .zip file or a .app directory. For Android provide an .apk file. For iOS real devices provide an .ipa file"),
+    }, { destructiveHint: true }, async ({ device, path }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.installApp(path);
+        return `Installed app from ${path}`;
+    });
+    tool("mobile_uninstall_app", "Uninstall App", "Uninstall an app from mobile device", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        bundle_id: zod_1.z.string().describe("Bundle identifier (iOS) or package name (Android) of the app to be uninstalled"),
+    }, { destructiveHint: true }, async ({ device, bundle_id }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.uninstallApp(bundle_id);
+        return `Uninstalled app ${bundle_id}`;
+    });
+    tool("mobile_get_screen_size", "Get Screen Size", "Get the screen size of the mobile device in pixels", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
+    }, { readOnlyHint: true }, async ({ device }) => {
+        const robot = getRobotFromDevice(device);
+        const screenSize = await robot.getScreenSize();
+        return `Screen size is ${screenSize.width}x${screenSize.height} pixels`;
+    });
+    tool("mobile_click_on_screen_at_coordinates", "Click Screen", "Click on the screen at given x,y coordinates. If clicking on an element, use the list_elements_on_screen tool to find the coordinates.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        x: zod_1.z.coerce.number().describe("The x coordinate to click on the screen, in pixels"),
+        y: zod_1.z.coerce.number().describe("The y coordinate to click on the screen, in pixels"),
+    }, { destructiveHint: true }, async ({ device, x, y }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.tap(x, y);
+        return `Clicked on screen at coordinates: ${x}, ${y}`;
+    });
+    tool("mobile_double_tap_on_screen", "Double Tap Screen", "Double-tap on the screen at given x,y coordinates.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        x: zod_1.z.coerce.number().describe("The x coordinate to double-tap, in pixels"),
+        y: zod_1.z.coerce.number().describe("The y coordinate to double-tap, in pixels"),
+    }, { destructiveHint: true }, async ({ device, x, y }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.doubleTap(x, y);
+        return `Double-tapped on screen at coordinates: ${x}, ${y}`;
+    });
+    tool("mobile_long_press_on_screen_at_coordinates", "Long Press Screen", "Long press on the screen at given x,y coordinates. If long pressing on an element, use the list_elements_on_screen tool to find the coordinates.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        x: zod_1.z.coerce.number().describe("The x coordinate to long press on the screen, in pixels"),
+        y: zod_1.z.coerce.number().describe("The y coordinate to long press on the screen, in pixels"),
+        duration: zod_1.z.coerce.number().min(1).max(10000).optional().describe("Duration of the long press in milliseconds. Defaults to 500ms."),
+    }, { destructiveHint: true }, async ({ device, x, y, duration }) => {
+        const robot = getRobotFromDevice(device);
+        const pressDuration = duration ?? 500;
+        await robot.longPress(x, y, pressDuration);
+        return `Long pressed on screen at coordinates: ${x}, ${y} for ${pressDuration}ms`;
+    });
+    tool("mobile_list_elements_on_screen", "List Screen Elements", "List elements on screen and their coordinates, with display text or accessibility label. Do not cache this result.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
+    }, { readOnlyHint: true }, async ({ device }) => {
+        const robot = getRobotFromDevice(device);
+        const result = await robot.getElementsOnScreen();
+        // For HarmonyOS, result is a file path to the raw hidumper dump
+        if (typeof result === "string") {
+            return `Elements saved to file: ${result}`;
+        }
+        // For other platforms, format as JSON array
+        const formattedResult = result.map(element => {
+            const out = {
+                type: element.type,
+                text: element.text,
+                label: element.label,
+                name: element.name,
+                value: element.value,
+                identifier: element.identifier,
+                coordinates: {
+                    x: element.rect.x,
+                    y: element.rect.y,
+                    width: element.rect.width,
+                    height: element.rect.height,
+                },
+            };
+            if (element.focused) {
+                out.focused = true;
+            }
+            return out;
+        });
+        return `Found these elements on screen: ${JSON.stringify(formattedResult)}`;
+    });
+    tool("mobile_press_button", "Press Button", "Press a button on device", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        button: zod_1.z.string().describe("The button to press. Supported buttons: BACK (android only), HOME, VOLUME_UP, VOLUME_DOWN, ENTER, DEL, DPAD_CENTER (android tv only), DPAD_UP (android tv only), DPAD_DOWN (android tv only), DPAD_LEFT (android tv only), DPAD_RIGHT (android tv only)"),
+    }, { destructiveHint: true }, async ({ device, button }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.pressButton(button);
+        return `Pressed the button: ${button}`;
+    });
+    tool("mobile_open_url", "Open URL", "Open a URL in browser on device", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        url: zod_1.z.string().describe("The URL to open"),
+    }, { destructiveHint: true }, async ({ device, url }) => {
+        // HarmonyOS 设备支持自定义 URL scheme（如 alipays://），跳过检查
+        const isHarmony = isHarmonyDevice(device);
+        const allowUnsafeUrls = process.env.MOBILEMCP_ALLOW_UNSAFE_URLS === "1";
+        if (!isHarmony && !allowUnsafeUrls && !url.startsWith("http://") && !url.startsWith("https://")) {
+            throw new robot_1.ActionableError("Only http:// and https:// URLs are allowed. Set MOBILEMCP_ALLOW_UNSAFE_URLS=1 to allow other URL schemes.");
+        }
+        const robot = getRobotFromDevice(device);
+        await robot.openUrl(url);
+        return `Opened URL: ${url}`;
+    });
+    tool("mobile_swipe_on_screen", "Swipe Screen", "Swipe on the screen", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        direction: zod_1.z.enum(["up", "down", "left", "right"]).describe("The direction to swipe"),
+        x: zod_1.z.coerce.number().optional().describe("The x coordinate to start the swipe from, in pixels. If not provided, uses center of screen"),
+        y: zod_1.z.coerce.number().optional().describe("The y coordinate to start the swipe from, in pixels. If not provided, uses center of screen"),
+        distance: zod_1.z.coerce.number().optional().describe("The distance to swipe in pixels. Defaults to 400 pixels for iOS or 30% of screen dimension for Android"),
+    }, { destructiveHint: true }, async ({ device, direction, x, y, distance }) => {
+        const robot = getRobotFromDevice(device);
+        if (x !== undefined && y !== undefined) {
+            // Use coordinate-based swipe
+            await robot.swipeFromCoordinate(x, y, direction, distance);
+            const distanceText = distance ? ` ${distance} pixels` : "";
+            return `Swiped ${direction}${distanceText} from coordinates: ${x}, ${y}`;
+        }
+        else {
+            // Use center-based swipe
+            await robot.swipe(direction);
+            return `Swiped ${direction} on screen`;
+        }
+    });
+    tool("mobile_type_keys", "Type Text", "Type text into the focused element. For HarmonyOS devices, x and y coordinates are REQUIRED to specify the input position. For iOS/Android, coordinates are optional as text is input to the currently focused element.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        text: zod_1.z.string().describe("The text to type"),
+        submit: zod_1.z.boolean().describe("Whether to submit the text. If true, the text will be submitted as if the user pressed the enter key."),
+        x: zod_1.z.number().optional().describe("Optional x coordinate for input position (REQUIRED for HarmonyOS). Use the same coordinates as the input field."),
+        y: zod_1.z.number().optional().describe("Optional y coordinate for input position (REQUIRED for HarmonyOS). Use the same coordinates as the input field."),
+    }, { destructiveHint: true }, async ({ device, text, submit, x, y }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.sendKeys(text, x, y);
+        if (submit) {
+            await robot.pressButton("ENTER");
+        }
+        return `Typed text: ${text}${x !== undefined && y !== undefined ? ` at position (${x}, ${y})` : ""}`;
+    });
+    tool("mobile_save_screenshot", "Save Screenshot", "Save a screenshot of the mobile device to a file", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        saveTo: zod_1.z.string().describe("The path to save the screenshot to. Filename must end with .png, .jpg, or .jpeg"),
+    }, { destructiveHint: true }, async ({ device, saveTo }) => {
+        (0, utils_1.validateFileExtension)(saveTo, ALLOWED_SCREENSHOT_EXTENSIONS, "save_screenshot");
+        (0, utils_1.validateOutputPath)(saveTo);
+        const robot = getRobotFromDevice(device);
+        const screenshot = await robot.getScreenshot();
+        node_fs_1.default.writeFileSync(saveTo, screenshot);
+        return `Screenshot saved to: ${saveTo}`;
+    });
+    server.registerTool("mobile_take_screenshot", {
+        title: "Take Screenshot",
+        description: "Take a screenshot of the mobile device. Use this to understand what's on screen, if you need to press an element that is available through view hierarchy then you must list elements on screen instead. Do not cache this result.",
+        inputSchema: {
+            device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    }, async ({ device }) => {
+        try {
+            const robot = getRobotFromDevice(device);
+            const isHarmony = isHarmonyDevice(device);
+            let screenshot = await robot.getScreenshot();
+            let mimeType = "image/png";
+            let imageWidth;
+            let imageHeight;
+            if (isHarmony) {
+                // HarmonyOS returns JPEG directly
+                mimeType = "image/jpeg";
+                const jpeg = new jpeg_1.JPEG(screenshot);
+                const jpegSize = jpeg.getDimensions();
+                if (jpegSize.width <= 0 || jpegSize.height <= 0) {
+                    throw new robot_1.ActionableError("Screenshot is invalid. Please try again.");
+                }
+                imageWidth = jpegSize.width;
+                imageHeight = jpegSize.height;
+            }
+            else {
+                // iOS and Android return PNG
+                const screenSize = await robot.getScreenSize();
+                const image = new png_1.PNG(screenshot);
+                const pngSize = image.getDimensions();
+                if (pngSize.width <= 0 || pngSize.height <= 0) {
+                    throw new robot_1.ActionableError("Screenshot is invalid. Please try again.");
+                }
+                imageWidth = pngSize.width;
+                imageHeight = pngSize.height;
+                if ((0, image_utils_1.isScalingAvailable)()) {
+                    (0, logger_1.trace)("Image scaling is available, resizing screenshot");
+                    const img = image_utils_1.Image.fromBuffer(screenshot);
+                    const beforeSize = screenshot.length;
+                    screenshot = img.resize(Math.floor(pngSize.width / screenSize.scale))
+                        .jpeg({ quality: 75 })
+                        .toBuffer();
+                    const afterSize = screenshot.length;
+                    (0, logger_1.trace)(`Screenshot resized from ${beforeSize} bytes to ${afterSize} bytes`);
+                    mimeType = "image/jpeg";
+                }
+            }
+            const screenshot64 = screenshot.toString("base64");
+            (0, logger_1.trace)(`Screenshot taken: ${screenshot.length} bytes`);
+            posthog("tool_invoked", {
+                "ToolName": "mobile_take_screenshot",
+                "ScreenshotFilesize": screenshot64.length,
+                "ScreenshotMimeType": mimeType,
+                "ScreenshotWidth": imageWidth,
+                "ScreenshotHeight": imageHeight,
+            }).then();
+            return {
+                content: [{ type: "image", data: screenshot64, mimeType }]
+            };
+        }
+        catch (err) {
+            (0, logger_1.error)(`Error taking screenshot: ${err.message} ${err.stack}`);
+            return {
+                content: [{ type: "text", text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+    tool("mobile_set_orientation", "Set Orientation", "Change the screen orientation of the device", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        orientation: zod_1.z.enum(["portrait", "landscape"]).describe("The desired orientation"),
+    }, { destructiveHint: true }, async ({ device, orientation }) => {
+        const robot = getRobotFromDevice(device);
+        await robot.setOrientation(orientation);
+        return `Changed device orientation to ${orientation}`;
+    });
+    tool("mobile_get_orientation", "Get Orientation", "Get the current screen orientation of the device", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
+    }, { readOnlyHint: true }, async ({ device }) => {
+        const robot = getRobotFromDevice(device);
+        const orientation = await robot.getOrientation();
+        return `Current device orientation is ${orientation}`;
+    });
+    tool("mobile_start_screen_recording", "Start Screen Recording", "Start recording the screen of a mobile device. The recording runs in the background until stopped with mobile_stop_screen_recording. Returns the path where the recording will be saved.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        output: zod_1.z.string().optional().describe("The file path to save the recording to. Filename must end with .mp4. If not provided, a temporary path will be used."),
+        timeLimit: zod_1.z.coerce.number().optional().describe("Maximum recording duration in seconds. The recording will stop automatically after this time."),
+    }, { destructiveHint: true }, async ({ device, output, timeLimit }) => {
+        if (output) {
+            (0, utils_1.validateFileExtension)(output, ALLOWED_RECORDING_EXTENSIONS, "start_screen_recording");
+            (0, utils_1.validateOutputPath)(output);
+        }
+        getRobotFromDevice(device);
+        if (activeRecordings.has(device)) {
+            throw new robot_1.ActionableError(`Device "${device}" is already being recorded. Stop the current recording first with mobile_stop_screen_recording.`);
+        }
+        const outputPath = output || node_path_1.default.join(node_os_1.default.tmpdir(), `screen-recording-${Date.now()}.mp4`);
+        const args = ["screenrecord", "--device", device, "--output", outputPath, "--silent"];
+        if (timeLimit !== undefined) {
+            args.push("--time-limit", String(timeLimit));
+        }
+        const child = mobilecli.spawnCommand(args);
+        const cleanup = () => {
+            activeRecordings.delete(device);
+        };
+        child.on("error", cleanup);
+        child.on("exit", cleanup);
+        activeRecordings.set(device, {
+            process: child,
+            outputPath,
+            startedAt: Date.now(),
+        });
+        return `Screen recording started. Output will be saved to: ${outputPath}`;
+    });
+    tool("mobile_stop_screen_recording", "Stop Screen Recording", "Stop an active screen recording on a mobile device. Returns the file path, size, and approximate duration of the recording.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+    }, { destructiveHint: true }, async ({ device }) => {
+        const recording = activeRecordings.get(device);
+        if (!recording) {
+            throw new robot_1.ActionableError(`No active recording found for device "${device}". Start a recording first with mobile_start_screen_recording.`);
+        }
+        const { process: child, outputPath, startedAt } = recording;
+        activeRecordings.delete(device);
+        child.kill("SIGINT");
+        await new Promise(resolve => {
+            const timeout = setTimeout(() => {
+                child.kill("SIGKILL");
+                resolve();
+            }, 5 * 60 * 1000);
+            child.on("close", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+        const durationSeconds = Math.round((Date.now() - startedAt) / 1000);
+        if (!node_fs_1.default.existsSync(outputPath)) {
+            return `Recording stopped after ~${durationSeconds}s but the output file was not found at: ${outputPath}`;
+        }
+        const stats = node_fs_1.default.statSync(outputPath);
+        const fileSizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+        return `Recording stopped. File: ${outputPath} (${fileSizeMB} MB, ~${durationSeconds}s)`;
+    });
+    tool("mobile_get_device_logs", "Get Device Logs", "Get device logs (hilog for HarmonyOS, logcat for Android, syslog for iOS). Useful for debugging app issues.", {
+        device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
+        bundleName: zod_1.z.string().optional().describe("Filter logs by tag/process name"),
+        pid: zod_1.z.number().optional().describe("Filter logs by process ID"),
+        level: zod_1.z.string().optional().describe("Minimum log level: D/I/W/E/F for HarmonyOS/Android, Default/Info/Debug/Error/Fault for iOS"),
+        lines: zod_1.z.number().optional().describe("Number of recent log lines to retrieve (default: 200)"),
+        clear: zod_1.z.boolean().optional().describe("Clear log buffer before retrieving logs"),
+    }, { destructiveHint: false }, async ({ device, bundleName, pid, level, lines, clear }) => {
+        const robot = getRobotFromDevice(device);
+        const logs = await robot.getDeviceLogs({ bundleName, pid, level, lines, clear });
+        return logs;
+    });
+    return server;
+};
+exports.createMcpServer = createMcpServer;