@mobilenext/mobile-mcp 0.0.26 → 0.0.27

package/lib/android.js

@@ -336,6 +336,122 @@ class AndroidRobot {
         const rotation = this.adb("shell", "settings", "get", "system", "user_rotation").toString().trim();
         return rotation === "0" ? "portrait" : "landscape";
     }
+    async getDeviceLogs(options) {
+        const timeWindow = options?.timeWindow || "1m";
+        const filter = options?.filter;
+        const processFilter = options?.process;
+        let packageFilter = null;
+        let searchQuery = null;
+        let effectiveFilter = filter;
+        // For Android: if both process and filter are provided, combine them as "package:<process> <filter>"
+        if (processFilter && filter && !filter.includes("package:")) {
+            effectiveFilter = `package:${processFilter} ${filter}`;
+        }
+        else if (processFilter && !filter) {
+            effectiveFilter = `package:${processFilter}`;
+        }
+        // Handle Android package filtering syntax
+        if (effectiveFilter) {
+            if (effectiveFilter.startsWith("package:mine")) {
+                // Filter to user apps only
+                const query = effectiveFilter.replace("package:mine", "").trim();
+                searchQuery = query || null;
+                // Will filter user packages in post-processing
+            }
+            else if (effectiveFilter.includes("package:")) {
+                // Handle specific package filters like package:com.example.app search_term
+                const packageMatch = effectiveFilter.match(/package:([^\s]+)(?:\s+(.+))?/);
+                if (packageMatch) {
+                    packageFilter = packageMatch[1];
+                    searchQuery = packageMatch[2] || null;
+                }
+            }
+            else {
+                // Regular search filter
+                searchQuery = effectiveFilter;
+            }
+        }
+        const args = ["shell", "logcat"];
+        if (timeWindow) {
+            // Calculate timestamp for time-based filtering using -T
+            const timeInSeconds = this.parseTimeWindow(timeWindow);
+            const startTime = new Date(Date.now() - (timeInSeconds * 1000));
+            // Format as MM-dd HH:mm:ss.mmm
+            const month = String(startTime.getMonth() + 1).padStart(2, "0");
+            const day = String(startTime.getDate()).padStart(2, "0");
+            const hours = String(startTime.getHours()).padStart(2, "0");
+            const minutes = String(startTime.getMinutes()).padStart(2, "0");
+            const seconds = String(startTime.getSeconds()).padStart(2, "0");
+            const milliseconds = String(startTime.getMilliseconds()).padStart(3, "0");
+            const timeFormat = `${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+            args.push("-T", timeFormat);
+        }
+        else {
+            args.push("-d");
+        }
+        // Add package filtering directly to logcat if we have a specific package
+        if (packageFilter && packageFilter !== "mine") {
+            // Use logcat's native package filtering with --pid
+            try {
+                // First get the PID(s) for this package
+                const pidOutput = this.adb("shell", "pidof", packageFilter).toString().trim();
+                if (pidOutput) {
+                    const pids = pidOutput.split(/\s+/);
+                    for (const pid of pids) {
+                        args.push("--pid", pid);
+                    }
+                }
+            }
+            catch (error) {
+                // If pidof fails, fall back to post-processing
+            }
+        }
+        const output = this.adb(...args).toString();
+        // Post-process filtering
+        const lines = output.split("\n").filter(line => line.trim());
+        let filteredLines = lines;
+        // Filter by specific package if provided (fallback if --pid didn't work)
+        if (packageFilter && packageFilter !== "mine") {
+            filteredLines = filteredLines.filter(line => {
+                return line.includes(packageFilter);
+            });
+        }
+        // Filter for user packages if package:mine
+        if (filter && filter.startsWith("package:mine")) {
+            filteredLines = filteredLines.filter(line => {
+                // Look for user app indicators - avoid system/Android logs
+                return !line.includes("com.android.") &&
+                    !line.includes("android.") &&
+                    !line.includes("system_") &&
+                    (line.includes("com.") || line.includes("io.") || line.includes("net.") || line.includes("app."));
+            });
+        }
+        // Apply text search if provided
+        if (searchQuery) {
+            filteredLines = filteredLines.filter(line => {
+                return line.toLowerCase().includes(searchQuery.toLowerCase());
+            });
+        }
+        return filteredLines.join("\n");
+    }
+    parseTimeWindow(timeWindow) {
+        const match = timeWindow.match(/^(\d+)([smh])$/);
+        if (!match) {
+            return 60;
+        }
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        switch (unit) {
+            case "s":
+                return value;
+            case "m":
+                return value * 60;
+            case "h":
+                return value * 3600;
+            default:
+                return 60;
+        }
+    }
     async getUiAutomatorDump() {
         for (let tries = 0; tries < 10; tries++) {
             const dump = this.adb("exec-out", "uiautomator", "dump", "/dev/tty").toString();

package/lib/image-utils.js

@@ -1,7 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImageMagickInstalled = exports.Image = exports.ImageTransformer = void 0;
+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;
@@ -25,7 +32,71 @@ class ImageTransformer {
         return this;
     }
     toBuffer() {
-        const proc = (0, child_process_1.spawnSync)("magick", ["-", "-resize", `${this.newWidth}x`, "-quality", `${this.jpegOptions.quality}`, `${this.newFormat}:-`], {
+        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
         });
@@ -49,6 +120,22 @@ class Image {
     }
 }
 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"])
@@ -62,3 +149,7 @@ const isImageMagickInstalled = () => {
     }
 };
 exports.isImageMagickInstalled = isImageMagickInstalled;
+const isScalingAvailable = () => {
+    return (0, exports.isImageMagickInstalled)() || (0, exports.isSipsInstalled)();
+};
+exports.isScalingAvailable = isScalingAvailable;

package/lib/ios.js

@@ -145,6 +145,42 @@ class IosRobot {
         const wda = await this.wda();
         return await wda.getOrientation();
     }
+    async getDeviceLogs(options) {
+        await this.assertTunnelRunning();
+        const timeWindow = options?.timeWindow || "1m";
+        const filter = options?.filter;
+        const args = ["syslog"];
+        if (timeWindow) {
+            const timeInSeconds = this.parseTimeWindow(timeWindow);
+            args.push("--since");
+            args.push(`${timeInSeconds}s`);
+        }
+        let output = await this.ios(...args);
+        if (filter) {
+            const lines = output.split("\n");
+            const filteredLines = lines.filter(line => line.toLowerCase().includes(filter.toLowerCase()));
+            output = filteredLines.join("\n");
+        }
+        return output;
+    }
+    parseTimeWindow(timeWindow) {
+        const match = timeWindow.match(/^(\d+)([smh])$/);
+        if (!match) {
+            return 60;
+        }
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        switch (unit) {
+            case "s":
+                return value;
+            case "m":
+                return value * 60;
+            case "h":
+                return value * 3600;
+            default:
+                return 60;
+        }
+    }
 }
 exports.IosRobot = IosRobot;
 class IosManager {

package/lib/iphone-simulator.js

@@ -124,6 +124,64 @@ class Simctl {
         const wda = await this.wda();
         return wda.getOrientation();
     }
+    async getDeviceLogs(options) {
+        const timeWindow = options?.timeWindow || "1m";
+        const filter = options?.filter;
+        const processFilter = options?.process;
+        const deviceUuid = this.simulatorUuid;
+        let predicate = "";
+        let currentApp = null;
+        // If a specific process is provided, use that
+        if (processFilter) {
+            currentApp = processFilter;
+            predicate = `subsystem == "${processFilter}"`;
+        }
+        else {
+            // Try to detect currently running user apps from installed apps
+            try {
+                const runningApps = await this.listApps();
+                // Filter to non-Apple user apps
+                const userApps = runningApps
+                    .map((app) => app.packageName)
+                    .filter((appId) => !appId.startsWith("com.apple.") && appId.includes("."));
+                if (userApps.length > 0) {
+                    // For now, just use the first user app found
+                    // In the future, we could try to detect which is actually running
+                    currentApp = userApps[0];
+                    predicate = `subsystem == "${currentApp}"`;
+                }
+            }
+            catch (error) {
+                // Failed to get apps, continue with fallback
+            }
+            // If no user app detected, use broader filter for non-Apple apps
+            if (!predicate) {
+                predicate = "subsystem CONTAINS \"com.\" AND NOT subsystem BEGINSWITH \"com.apple.\"";
+            }
+        }
+        if (filter) {
+            predicate += ` AND composedMessage CONTAINS[c] "${filter}"`;
+        }
+        const args = [
+            "spawn", deviceUuid, "log", "show",
+            "--last", timeWindow,
+            "--predicate", predicate,
+            "--info",
+            "--debug"
+        ];
+        try {
+            const logs = this.simctl(...args).toString();
+            const appInfo = currentApp ? ` (focused on: ${currentApp})` : " (all non-Apple apps)";
+            const debugInfo = `DEBUG: Using predicate: ${predicate}${appInfo}\n\n`;
+            return `${debugInfo}${logs}`;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("No logging subsystem")) {
+                return "No logs found for the current running applications.";
+            }
+            throw error;
+        }
+    }
 }
 exports.Simctl = Simctl;
 class SimctlManager {

package/lib/server.js

@@ -330,8 +330,8 @@ const createMcpServer = () => {
             if (pngSize.width <= 0 || pngSize.height <= 0) {
                 throw new robot_1.ActionableError("Screenshot is invalid. Please try again.");
             }
-            if ((0, image_utils_1.isImageMagickInstalled)()) {
-                (0, logger_1.trace)("ImageMagick is installed, resizing screenshot");
+            if ((0, image_utils_1.isScalingAvailable)()) {
+                (0, logger_1.trace)("Image scaling is available, resizing screenshot");
                 const image = image_utils_1.Image.fromBuffer(screenshot);
                 const beforeSize = screenshot.length;
                 screenshot = image.resize(Math.floor(pngSize.width / screenSize.scale))
@@ -369,6 +369,25 @@ const createMcpServer = () => {
         const orientation = await robot.getOrientation();
         return `Current device orientation is ${orientation}`;
     });
+    /*
+    tool(
+        "mobile_get_logs",
+        "Get device logs",
+        {
+            timeWindow: z.string().optional().describe("Time window to look back (e.g., '5m' for 5 minutes, '1h' for 1 hour). Defaults to '1m'"),
+            filter: z.string().optional().describe("Filter logs containing this query (case-insensitive). For Android: supports 'package:mine <query>' (user apps only), 'package:com.app.bundle <query>' (specific app), or '<query>' (text search). For iOS: simple text search only."),
+            process: z.string().optional().describe("Filter logs to a specific process/app bundle ID")
+        },
+        async ({ timeWindow, filter, process }) => {
+            requireRobot();
+            const logs = await robot!.getDeviceLogs({ timeWindow, filter, process });
+            const filterText = filter ? ` (filtered by: ${filter})` : "";
+            const processText = process ? ` (process: ${process})` : "";
+            const timeText = timeWindow ? ` from last ${timeWindow}` : "";
+            return `Device logs${timeText}${filterText}${processText}:\n${logs}`;
+        }
+    );
+    */
     // async check for latest agent version
     checkForLatestAgentVersion().then();
     return server;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mobilenext/mobile-mcp",
   "mcpName": "io.github.mobile-next/mobile-mcp",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "Mobile MCP",
   "repository": {
     "type": "git",