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

package/lib/image-utils.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScalingAvailable = exports.isImageMagickInstalled = exports.isSipsInstalled = exports.Image = exports.ImageTransformer = void 0;
+const child_process_1 = require("child_process");
+const node_os_1 = __importDefault(require("node:os"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("./logger");
+const DEFAULT_JPEG_QUALITY = 75;
+class ImageTransformer {
+    buffer;
+    newWidth = 0;
+    newFormat = "png";
+    jpegOptions = { quality: DEFAULT_JPEG_QUALITY };
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    resize(width) {
+        this.newWidth = width;
+        return this;
+    }
+    jpeg(options) {
+        this.newFormat = "jpg";
+        this.jpegOptions = options;
+        return this;
+    }
+    png() {
+        this.newFormat = "png";
+        return this;
+    }
+    toBuffer() {
+        if ((0, exports.isSipsInstalled)()) {
+            try {
+                return this.toBufferWithSips();
+            }
+            catch (error) {
+                (0, logger_1.trace)(`Sips failed, falling back to ImageMagick: ${error}`);
+            }
+        }
+        try {
+            return this.toBufferWithImageMagick();
+        }
+        catch (error) {
+            (0, logger_1.trace)(`ImageMagick failed: ${error}`);
+            throw new Error("Image scaling unavailable (requires Sips or ImageMagick).");
+        }
+    }
+    qualityToSips(q) {
+        if (q >= 90) {
+            return "best";
+        }
+        if (q >= 75) {
+            return "high";
+        }
+        if (q >= 50) {
+            return "normal";
+        }
+        return "low";
+    }
+    toBufferWithSips() {
+        const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), "image-"));
+        const inputFile = node_path_1.default.join(tempDir, "input");
+        const outputFile = node_path_1.default.join(tempDir, `output.${this.newFormat === "jpg" ? "jpg" : "png"}`);
+        try {
+            node_fs_1.default.writeFileSync(inputFile, this.buffer);
+            const args = ["-s", "format", this.newFormat === "jpg" ? "jpeg" : "png"];
+            if (this.newFormat === "jpg") {
+                args.push("-s", "formatOptions", this.qualityToSips(this.jpegOptions.quality));
+            }
+            args.push("-Z", `${this.newWidth}`);
+            args.push("--out", outputFile);
+            args.push(inputFile);
+            (0, logger_1.trace)(`Running sips command: /usr/bin/sips ${args.join(" ")}`);
+            const proc = (0, child_process_1.spawnSync)("/usr/bin/sips", args, {
+                maxBuffer: 8 * 1024 * 1024
+            });
+            if (proc.status !== 0) {
+                throw new Error(`Sips failed with status ${proc.status}`);
+            }
+            const outputBuffer = node_fs_1.default.readFileSync(outputFile);
+            (0, logger_1.trace)("Sips returned buffer of size: " + outputBuffer.length);
+            return outputBuffer;
+        }
+        finally {
+            try {
+                node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    toBufferWithImageMagick() {
+        const magickArgs = ["-", "-resize", `${this.newWidth}x`, "-quality", `${this.jpegOptions.quality}`, `${this.newFormat}:-`];
+        (0, logger_1.trace)(`Running magick command: magick ${magickArgs.join(" ")}`);
+        const proc = (0, child_process_1.spawnSync)("magick", magickArgs, {
+            maxBuffer: 8 * 1024 * 1024,
+            input: this.buffer
+        });
+        return proc.stdout;
+    }
+}
+exports.ImageTransformer = ImageTransformer;
+class Image {
+    buffer;
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    static fromBuffer(buffer) {
+        return new Image(buffer);
+    }
+    resize(width) {
+        return new ImageTransformer(this.buffer).resize(width);
+    }
+    jpeg(options) {
+        return new ImageTransformer(this.buffer).jpeg(options);
+    }
+}
+exports.Image = Image;
+const isDarwin = () => {
+    return node_os_1.default.platform() === "darwin";
+};
+const isSipsInstalled = () => {
+    if (!isDarwin()) {
+        return false;
+    }
+    try {
+        (0, child_process_1.execFileSync)("/usr/bin/sips", ["--version"]);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.isSipsInstalled = isSipsInstalled;
+const isImageMagickInstalled = () => {
+    try {
+        return (0, child_process_1.execFileSync)("magick", ["--version"])
+            .toString()
+            .split("\n")
+            .filter(line => line.includes("Version: ImageMagick"))
+            .length > 0;
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.isImageMagickInstalled = isImageMagickInstalled;
+const isScalingAvailable = () => {
+    return (0, exports.isImageMagickInstalled)() || (0, exports.isSipsInstalled)();
+};
+exports.isScalingAvailable = isScalingAvailable;

package/lib/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const server_1 = require("./server");
+const logger_1 = require("./logger");
+const express_1 = __importDefault(require("express"));
+const commander_1 = require("commander");
+const startSseServer = async (port) => {
+    const app = (0, express_1.default)();
+    const server = (0, server_1.createMcpServer)();
+    let transport = null;
+    app.post("/mcp", (req, res) => {
+        if (transport) {
+            transport.handlePostMessage(req, res);
+        }
+    });
+    app.get("/mcp", (req, res) => {
+        if (transport) {
+            transport.close();
+        }
+        transport = new sse_js_1.SSEServerTransport("/mcp", res);
+        server.connect(transport);
+    });
+    app.listen(port, () => {
+        (0, logger_1.error)(`mobile-mcp ${(0, server_1.getAgentVersion)()} sse server listening on http://localhost:${port}/mcp`);
+    });
+};
+const startStdioServer = async () => {
+    try {
+        const transport = new stdio_js_1.StdioServerTransport();
+        const server = (0, server_1.createMcpServer)();
+        await server.connect(transport);
+        (0, logger_1.error)("mobile-mcp server running on stdio");
+    }
+    catch (err) {
+        console.error("Fatal error in main():", err);
+        (0, logger_1.error)("Fatal error in main(): " + JSON.stringify(err.stack));
+        process.exit(1);
+    }
+};
+const main = async () => {
+    commander_1.program
+        .version((0, server_1.getAgentVersion)())
+        .option("--port <port>", "Start SSE server on this port")
+        .option("--stdio", "Start stdio server (default)")
+        .parse(process.argv);
+    const options = commander_1.program.opts();
+    if (options.port) {
+        await startSseServer(+options.port);
+    }
+    else {
+        await startStdioServer();
+    }
+};
+main().then();

package/lib/ios.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IosManager = exports.IosRobot = void 0;
+const node_net_1 = require("node:net");
+const node_child_process_1 = require("node:child_process");
+const webdriver_agent_1 = require("./webdriver-agent");
+const robot_1 = require("./robot");
+const utils_1 = require("./utils");
+const WDA_PORT = 8100;
+const IOS_TUNNEL_PORT = 60105;
+const getGoIosPath = () => {
+    if (process.env.GO_IOS_PATH) {
+        return process.env.GO_IOS_PATH;
+    }
+    // fallback to go-ios in PATH via `npm install -g go-ios`
+    return "ios";
+};
+class IosRobot {
+    deviceId;
+    constructor(deviceId) {
+        this.deviceId = deviceId;
+    }
+    isListeningOnPort(port) {
+        return new Promise((resolve, reject) => {
+            const client = new node_net_1.Socket();
+            client.connect(port, "localhost", () => {
+                client.destroy();
+                resolve(true);
+            });
+            client.on("error", (err) => {
+                resolve(false);
+            });
+        });
+    }
+    async isTunnelRunning() {
+        return await this.isListeningOnPort(IOS_TUNNEL_PORT);
+    }
+    async isWdaForwardRunning() {
+        return await this.isListeningOnPort(WDA_PORT);
+    }
+    async assertTunnelRunning() {
+        if (await this.isTunnelRequired()) {
+            if (!(await this.isTunnelRunning())) {
+                throw new robot_1.ActionableError("iOS tunnel is not running, please see https://github.com/mobile-next/mobile-mcp/wiki/");
+            }
+        }
+    }
+    async wda() {
+        await this.assertTunnelRunning();
+        if (!(await this.isWdaForwardRunning())) {
+            throw new robot_1.ActionableError("Port forwarding to WebDriverAgent is not running (tunnel okay), please see https://github.com/mobile-next/mobile-mcp/wiki/");
+        }
+        const wda = new webdriver_agent_1.WebDriverAgent("localhost", WDA_PORT);
+        if (!(await wda.isRunning())) {
+            throw new robot_1.ActionableError("WebDriverAgent is not running on device (tunnel okay, port forwarding okay), please see https://github.com/mobile-next/mobile-mcp/wiki/");
+        }
+        return wda;
+    }
+    async ios(...args) {
+        return (0, node_child_process_1.execFileSync)(getGoIosPath(), ["--udid", this.deviceId, ...args], {}).toString();
+    }
+    async getIosVersion() {
+        const output = await this.ios("info");
+        const json = JSON.parse(output);
+        return json.ProductVersion;
+    }
+    async isTunnelRequired() {
+        const version = await this.getIosVersion();
+        const args = version.split(".");
+        return parseInt(args[0], 10) >= 17;
+    }
+    async getScreenSize() {
+        const wda = await this.wda();
+        return await wda.getScreenSize();
+    }
+    async swipe(direction) {
+        const wda = await this.wda();
+        await wda.swipe(direction);
+    }
+    async swipeFromCoordinate(x, y, direction, distance) {
+        const wda = await this.wda();
+        await wda.swipeFromCoordinate(x, y, direction, distance);
+    }
+    async listApps() {
+        await this.assertTunnelRunning();
+        const output = await this.ios("apps", "--all", "--list");
+        return output
+            .split("\n")
+            .map(line => {
+            const [packageName, appName] = line.split(" ");
+            return {
+                packageName,
+                appName,
+            };
+        });
+    }
+    async launchApp(packageName, locale) {
+        (0, utils_1.validatePackageName)(packageName);
+        await this.assertTunnelRunning();
+        const args = ["launch", packageName];
+        if (locale) {
+            (0, utils_1.validateLocale)(locale);
+            const locales = locale.split(",").map(l => l.trim());
+            args.push("-AppleLanguages", `(${locales.join(", ")})`);
+            args.push("-AppleLocale", locales[0]);
+        }
+        await this.ios(...args);
+    }
+    async terminateApp(packageName) {
+        (0, utils_1.validatePackageName)(packageName);
+        await this.assertTunnelRunning();
+        await this.ios("kill", packageName);
+    }
+    async installApp(path) {
+        await this.assertTunnelRunning();
+        try {
+            await this.ios("install", "--path", path);
+        }
+        catch (error) {
+            const stdout = error.stdout ? error.stdout.toString() : "";
+            const stderr = error.stderr ? error.stderr.toString() : "";
+            const output = (stdout + stderr).trim();
+            throw new robot_1.ActionableError(output || error.message);
+        }
+    }
+    async uninstallApp(bundleId) {
+        await this.assertTunnelRunning();
+        try {
+            await this.ios("uninstall", "--bundleid", bundleId);
+        }
+        catch (error) {
+            const stdout = error.stdout ? error.stdout.toString() : "";
+            const stderr = error.stderr ? error.stderr.toString() : "";
+            const output = (stdout + stderr).trim();
+            throw new robot_1.ActionableError(output || error.message);
+        }
+    }
+    async openUrl(url) {
+        const wda = await this.wda();
+        await wda.openUrl(url);
+    }
+    async sendKeys(text) {
+        const wda = await this.wda();
+        await wda.sendKeys(text);
+    }
+    async pressButton(button) {
+        const wda = await this.wda();
+        await wda.pressButton(button);
+    }
+    async tap(x, y) {
+        const wda = await this.wda();
+        await wda.tap(x, y);
+    }
+    async doubleTap(x, y) {
+        const wda = await this.wda();
+        await wda.doubleTap(x, y);
+    }
+    async longPress(x, y, duration) {
+        const wda = await this.wda();
+        await wda.longPress(x, y, duration);
+    }
+    async getElementsOnScreen() {
+        const wda = await this.wda();
+        return await wda.getElementsOnScreen();
+    }
+    async getScreenshot() {
+        const wda = await this.wda();
+        return await wda.getScreenshot();
+        /* alternative:
+        await this.assertTunnelRunning();
+        const tmpFilename = path.join(tmpdir(), `screenshot-${randomBytes(8).toString("hex")}.png`);
+        await this.ios("screenshot", "--output", tmpFilename);
+        const buffer = readFileSync(tmpFilename);
+        unlinkSync(tmpFilename);
+        return buffer;
+        */
+    }
+    async setOrientation(orientation) {
+        const wda = await this.wda();
+        await wda.setOrientation(orientation);
+    }
+    async getOrientation() {
+        const wda = await this.wda();
+        return await wda.getOrientation();
+    }
+    /**
+     * 获取设备日志 (iOS syslog)
+     * @param options - 可选的过滤选项
+     * @param options.bundleName - 按日志标签/进程名过滤
+     * @param options.pid - 按进程 ID 过滤
+     * @param options.level - 最低日志级别 (Default/Info/Debug/Error/Fault)
+     * @param options.lines - 获取最近 N 行日志 (默认: 100)
+     * @param options.clear - 获取前清除日志缓冲区
+     */
+    async getDeviceLogs(options) {
+        // iOS 使用 go-ios 的 syslog 命令获取日志
+        // 注意：go-ios 的 syslog 功能有限，这里提供基本实现
+        try {
+            const args = ["syslog", "--udid", this.deviceId];
+            // 添加行数限制 (go-ios 可能不支持，这里作为备用)
+            const lines = options?.lines || 100;
+            // 获取日志
+            const output = (0, node_child_process_1.execFileSync)(getGoIosPath(), args, {
+                maxBuffer: 1024 * 1024 * 8,
+                timeout: 10000,
+            }).toString();
+            // 按行分割并过滤
+            let lines_array = output.split("\n");
+            // 按标签过滤
+            if (options?.bundleName) {
+                lines_array = lines_array.filter(line => line.includes(options.bundleName));
+            }
+            // 按 PID 过滤
+            if (options?.pid) {
+                lines_array = lines_array.filter(line => line.includes(`[${options.pid}]`));
+            }
+            // 按级别过滤
+            if (options?.level) {
+                lines_array = lines_array.filter(line => line.toLowerCase().includes(options.level.toLowerCase()));
+            }
+            // 限制行数
+            return lines_array.slice(-lines).join("\n");
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to get device logs: ${error.message}`);
+        }
+    }
+}
+exports.IosRobot = IosRobot;
+class IosManager {
+    isGoIosInstalled() {
+        try {
+            const output = (0, node_child_process_1.execFileSync)(getGoIosPath(), ["version"], { stdio: ["pipe", "pipe", "ignore"] }).toString();
+            const json = JSON.parse(output);
+            return json.version !== undefined && (json.version.startsWith("v") || json.version === "local-build");
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    getDeviceName(deviceId) {
+        const output = (0, node_child_process_1.execFileSync)(getGoIosPath(), ["info", "--udid", deviceId]).toString();
+        const json = JSON.parse(output);
+        return json.DeviceName;
+    }
+    getDeviceInfo(deviceId) {
+        const output = (0, node_child_process_1.execFileSync)(getGoIosPath(), ["info", "--udid", deviceId]).toString();
+        const json = JSON.parse(output);
+        return json;
+    }
+    listDevices() {
+        if (!this.isGoIosInstalled()) {
+            console.error("go-ios is not installed, no physical iOS devices can be detected");
+            return [];
+        }
+        const output = (0, node_child_process_1.execFileSync)(getGoIosPath(), ["list"]).toString();
+        const json = JSON.parse(output);
+        const devices = json.deviceList.map(device => ({
+            deviceId: device,
+            deviceName: this.getDeviceName(device),
+        }));
+        return devices;
+    }
+    listDevicesWithDetails() {
+        if (!this.isGoIosInstalled()) {
+            console.error("go-ios is not installed, no physical iOS devices can be detected");
+            return [];
+        }
+        const output = (0, node_child_process_1.execFileSync)(getGoIosPath(), ["list"]).toString();
+        const json = JSON.parse(output);
+        const devices = json.deviceList.map(device => {
+            const info = this.getDeviceInfo(device);
+            return {
+                deviceId: device,
+                deviceName: info.DeviceName,
+                version: info.ProductVersion,
+            };
+        });
+        return devices;
+    }
+}
+exports.IosManager = IosManager;