android-mcp-toolkit 1.2.0 → 1.3.0

package/dist/index.js

@@ -4,11 +4,160 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 
+// vendor/svg2vectordrawable/svgo-adapter.js
+var require_svgo_adapter = __commonJS({
+  "vendor/svg2vectordrawable/svgo-adapter.js"(exports2, module2) {
+    var { optimize } = require("svgo");
+    var JSAPI = class _JSAPI {
+      constructor(data, parentNode) {
+        this.parentNode = parentNode || null;
+        this.type = data.type || "element";
+        this.name = data.name || "";
+        this.children = [];
+        this.attrs = {};
+        if (data.attributes) {
+          for (const [key, value] of Object.entries(data.attributes)) {
+            this._addAttrInternal(key, value);
+          }
+        } else if (data.attrs) {
+          this.attrs = data.attrs;
+        }
+        if (data.children && Array.isArray(data.children)) {
+          this.children = data.children.map((c) => new _JSAPI(c, this));
+        }
+      }
+      _addAttrInternal(name, value) {
+        const parts = name.split(":");
+        let local = parts[0];
+        let prefix = "";
+        if (parts.length > 1) {
+          prefix = parts[0];
+          local = parts[1];
+        }
+        this.attrs[name] = {
+          name,
+          value,
+          local,
+          prefix
+        };
+      }
+      // Legacy JSAPI text node handling? 
+      // SVGO v2 had text nodes? XAST has { type: 'text', value: '...' }
+      // Android VectorDrawable doesn't support text, so maybe it's ignored or handled?
+      // The converter doesn't seem to handle text nodes explicitly, it iterates children.
+      hasAttr(name, value) {
+        const attr = this.attrs[name];
+        if (!attr) return false;
+        if (value !== void 0) return attr.value === value;
+        return true;
+      }
+      attr(name) {
+        return this.attrs[name];
+      }
+      addAttr(attrObj) {
+        this.attrs[attrObj.name] = attrObj;
+      }
+      removeAttr(name) {
+        delete this.attrs[name];
+      }
+      renameElem(newName) {
+        this.name = newName;
+      }
+      eachAttr(callback, context) {
+        for (const key in this.attrs) {
+          callback.call(context || this, this.attrs[key]);
+        }
+      }
+      isEmpty() {
+        return !this.children || this.children.length === 0;
+      }
+      // Helper to find specific children (used in converter?)
+      // converter uses querySelectorAll on `data` (which is Root node)
+      // We need to implement querySelectorAll if it was part of JSAPI or SVGO API.
+      // Looking at converter: 
+      // `data.querySelectorAll('use')`
+      // `root.querySelector('svg')`
+      // Wait, JSAPI v2 had querySelector/All?
+      // If so, I MUST implement them.
+      querySelector(selector) {
+        const results = this.querySelectorAll(selector);
+        return results.length > 0 ? results[0] : null;
+      }
+      querySelectorAll(selector) {
+        const results = [];
+        this._traverse((node) => {
+          if (this._matches(node, selector)) {
+            results.push(node);
+          }
+        });
+        return results;
+      }
+      _traverse(callback) {
+        callback(this);
+        if (this.children) {
+          this.children.forEach((c) => c._traverse(callback));
+        }
+      }
+      _matches(node, selector) {
+        if (node.type !== "element") return false;
+        if (selector.includes(",")) {
+          const parts = selector.split(",").map((s) => s.trim());
+          return parts.some((p) => this._matches(node, p));
+        }
+        if (/^[a-zA-Z0-9\-_:]+$/.test(selector)) {
+          return node.name === selector;
+        }
+        const attrMatch = selector.match(/^([a-zA-Z0-9\-_:]+)?\[([a-zA-Z0-9\-_:]+)="([^"]+)"\]$/);
+        if (attrMatch) {
+          const tagName = attrMatch[1];
+          const attrName = attrMatch[2];
+          const attrVal = attrMatch[3];
+          if (tagName && node.name !== tagName) return false;
+          return node.hasAttr(attrName, attrVal);
+        }
+        return false;
+      }
+      spliceContent(index, count, newItems) {
+        const items = Array.isArray(newItems) ? newItems : [newItems];
+        const validItems = items.filter((i) => i && (i instanceof _JSAPI || Array.isArray(i) && i.length === 0 ? false : true));
+        const flatItems = items.flat();
+        flatItems.forEach((item) => {
+          if (item instanceof _JSAPI) {
+            item.parentNode = this;
+          }
+        });
+        this.children.splice(index, count, ...flatItems);
+      }
+    };
+    function parseSvg(svgString) {
+      let xastRoot = null;
+      optimize(svgString, {
+        plugins: [
+          {
+            name: "fetch-ast",
+            fn: (root) => {
+              xastRoot = root;
+              return {};
+            }
+          }
+        ]
+      });
+      if (!xastRoot) {
+        throw new Error("SVGO failed to parse SVG");
+      }
+      return new JSAPI(xastRoot);
+    }
+    module2.exports = {
+      JSAPI,
+      parseSvg
+    };
+  }
+});
+
 // vendor/svg2vectordrawable/svg-to-vectordrawable.js
 var require_svg_to_vectordrawable = __commonJS({
   "vendor/svg2vectordrawable/svg-to-vectordrawable.js"(exports2, module2) {
-    var { parseSvg } = require("svgo/lib/parser");
-    var JSAPI = require("svgo/lib/svgo/jsAPI");
+    var { parseSvg, JSAPI } = require_svgo_adapter();
     var pathBounds = require("svg-path-bounds");
     var svgpath = require("svgpath");
     var JS2XML = function() {
@@ -908,189 +1057,50 @@ var require_svg_to_vectordrawable = __commonJS({
 var require_svgo_config = __commonJS({
   "vendor/svg2vectordrawable/svgo-config.js"(exports2, module2) {
     module2.exports = function(floatPrecision = 2) {
-      const svgoConfig = {
-        info: {
-          input: "string"
-        },
+      return {
         plugins: [
           {
-            name: "removeDoctype"
-          },
-          {
-            name: "removeXMLProcInst"
-          },
-          {
-            name: "removeComments"
-          },
-          {
-            name: "removeMetadata"
-          },
-          {
-            name: "removeEditorsNSData"
-          },
-          {
-            name: "cleanupAttrs"
-          },
-          {
-            name: "mergeStyles"
-          },
-          {
-            name: "inlineStyles",
-            params: { onlyMatchedOnce: false }
-          },
-          {
-            name: "minifyStyles"
-          },
-          {
-            name: "cleanupIDs",
-            active: false
-          },
-          {
-            name: "removeUselessDefs"
-          },
-          {
-            name: "cleanupNumericValues",
-            params: { floatPrecision, leadingZero: false }
-          },
-          {
-            name: "convertColors",
-            params: { shorthex: false, shortname: false }
-          },
-          {
-            name: "removeUnknownsAndDefaults",
-            params: { unknownContent: false, unknownAttrs: false }
-          },
-          {
-            name: "removeNonInheritableGroupAttrs"
-          },
-          {
-            name: "removeUselessStrokeAndFill"
-          },
-          {
-            name: "removeViewBox",
-            active: false
-          },
-          {
-            name: "cleanupEnableBackground"
-          },
-          {
-            name: "removeHiddenElems"
-          },
-          {
-            name: "removeEmptyText"
-          },
-          {
-            name: "convertShapeToPath",
-            params: { convertArcs: true, floatPrecision }
-          },
-          {
-            name: "convertEllipseToCircle"
-          },
-          {
-            name: "moveElemsAttrsToGroup",
-            active: false
-          },
-          {
-            name: "moveGroupAttrsToElems"
-          },
-          {
-            name: "collapseGroups"
-          },
-          {
-            name: "convertPathData",
-            params: { floatPrecision, transformPrecision: floatPrecision, leadingZero: false, makeArcs: false, noSpaceAfterFlags: false, collapseRepeated: false }
-          },
-          {
-            name: "convertTransform"
-          },
-          {
-            name: "removeEmptyAttrs"
-          },
-          {
-            name: "removeEmptyContainers"
-          },
-          {
-            name: "mergePaths",
-            active: false
-          },
-          {
-            name: "removeUnusedNS"
-          },
-          {
-            name: "sortDefsChildren"
-          },
-          {
-            name: "removeTitle"
-          },
-          {
-            name: "removeDesc"
-          },
-          {
-            name: "removeXMLNS",
-            active: false
+            name: "preset-default",
+            params: {
+              overrides: {
+                // Disable things that were active: false
+                cleanupIds: false,
+                mergePaths: false,
+                // active: false in legacy
+                // Parameter overrides
+                convertPathData: {
+                  floatPrecision,
+                  transformPrecision: floatPrecision,
+                  leadingZero: false,
+                  makeArcs: false,
+                  noSpaceAfterFlags: false,
+                  collapseRepeated: false
+                },
+                cleanupNumericValues: {
+                  floatPrecision,
+                  leadingZero: false
+                },
+                convertShapeToPath: {
+                  convertArcs: true,
+                  floatPrecision
+                }
+                // convertColors: { shorthex: false, shortname: false } // Legacy params
+              }
+            }
           },
+          // Additional plugins explicitly enabled in legacy
           {
             name: "removeRasterImages"
           },
           {
-            name: "cleanupListOfValues",
-            params: { floatPrecision, leadingZero: false }
-          },
-          {
-            name: "sortAttrs",
-            active: false
-          },
-          {
-            name: "convertStyleToAttrs",
-            active: false
-          },
-          {
-            name: "prefixIds",
-            active: false
-          },
-          {
-            name: "removeDimensions",
-            active: false
-          },
-          {
-            name: "removeAttrs",
-            active: false
-          },
-          {
-            name: "removeAttributesBySelector",
-            active: false
-          },
-          {
-            name: "removeElementsByAttr",
-            active: false
-          },
-          {
-            name: "addClassesToSVGElement",
-            active: false
-          },
-          {
-            name: "removeStyleElement",
-            active: false
-          },
-          {
-            name: "removeScriptElement",
-            active: false
-          },
-          {
-            name: "addAttributesToSVGElement",
-            active: false
-          },
-          {
-            name: "removeOffCanvasPaths",
-            active: false
-          },
-          {
-            name: "reusePaths",
-            active: false
+            name: "convertColors",
+            params: {
+              shorthex: false,
+              shortname: false
+            }
           }
         ]
       };
-      return svgoConfig;
     };
   }
 });
@@ -1245,42 +1255,21 @@ var require_logcatTool = __commonJS({
     var z = require("zod/v4");
     var execFileAsync = promisify(execFile);
     var logcatToolInstructions2 = [
-      "Use read-adb-logcat to tail device logs for a package, pid, or tag; default tail=200 lines.",
-      "Use get-pid-by-package to resolve pid quickly via adb shell pidof -s.",
-      "Use get-current-activity to inspect current focus (Activity/Window) via dumpsys window.",
-      "Use fetch-crash-stacktrace to pull the latest crash buffer (-b crash) optionally filtered by pid.",
-      "Use check-anr-state to inspect ActivityManager ANR logs and /data/anr/traces.txt (best-effort).",
-      "Use clear-logcat-buffer to reset logcat (-c) before running new scenarios."
+      "Use manage-logcat to read logs, fetch crash stacktraces, check ANR state, or clear logcat buffers.",
+      "Use get-current-activity to inspect current focus (Activity/Window) via dumpsys window."
     ].join("\n");
-    var logcatInputSchema = z.object({
+    var manageLogcatSchema = z.object({
+      action: z.enum(["read", "crash", "anr", "clear"]).default("read").describe("Action to perform: read logs, get crash buffer, check ANR, or clear buffer."),
       packageName: z.string().min(1).describe("Android package name; resolves pid via adb shell pidof").optional(),
       pid: z.string().min(1).describe("Explicit process id for logcat --pid").optional(),
       tag: z.string().min(1).describe("Logcat tag to include (uses -s tag)").optional(),
-      priority: z.enum(["V", "D", "I", "W", "E", "F", "S"]).default("V").describe("Minimum priority when tag is provided (e.g., D for debug)"),
-      maxLines: z.number().int().min(1).max(2e3).default(200).describe("Tail line count via logcat -t"),
-      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
-    }).refine((data) => data.packageName || data.pid || data.tag, {
-      message: "Provide packageName, pid, or tag to avoid unfiltered logs"
-    });
-    var pidInputSchema = z.object({
-      packageName: z.string().min(1).describe("Android package name to resolve pid via adb shell pidof -s"),
+      priority: z.enum(["V", "D", "I", "W", "E", "F", "S"]).default("V").describe("Minimum priority (e.g. D for debug)."),
+      maxLines: z.number().int().min(1).max(2e3).default(200).describe("Tail line count (logcat -t)."),
       timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
     });
     var currentActivityInputSchema = z.object({
       timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
     });
-    var crashStackInputSchema = z.object({
-      packageName: z.string().min(1).describe("Optional package to resolve pid; filters crash buffer with --pid").optional(),
-      maxLines: z.number().int().min(50).max(2e3).default(400).describe("Tail line count from crash buffer (-b crash -t)"),
-      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
-    });
-    var anrStateInputSchema = z.object({
-      maxLines: z.number().int().min(50).max(2e3).default(400).describe("Tail line count from ActivityManager:E"),
-      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
-    });
-    var clearLogcatInputSchema = z.object({
-      timeoutMs: z.number().int().min(1e3).max(15e3).default(5e3).describe("Timeout per adb call in milliseconds")
-    });
     async function runAdbCommand(args, timeoutMs) {
       try {
         const { stdout } = await execFileAsync("adb", args, {
@@ -1298,158 +1287,76 @@ var require_logcatTool = __commonJS({
       }
     }
     async function resolvePid(packageName, timeoutMs) {
-      const output = await runAdbCommand(["shell", "pidof", "-s", packageName], timeoutMs);
-      const pid = output.split(/\s+/).find(Boolean);
-      if (!pid) {
-        throw new Error(`Could not resolve pid for package ${packageName}`);
-      }
-      return pid;
-    }
-    function buildLogcatArgs(params, pid) {
-      const args = ["logcat", "-d", "-t", String(params.maxLines)];
-      if (pid) {
-        args.push(`--pid=${pid}`);
-      }
-      if (params.tag) {
-        const filterSpec = `${params.tag}:${params.priority}`;
-        args.push("-s", filterSpec);
+      try {
+        const output = await runAdbCommand(["shell", "pidof", "-s", packageName], timeoutMs);
+        const pid = output.split(/\s+/).find(Boolean);
+        return pid || null;
+      } catch (e) {
+        return null;
       }
-      return args;
     }
     function registerLogcatTool2(server2) {
       server2.registerTool(
-        "read-adb-logcat",
+        "manage-logcat",
         {
-          title: "Read adb logcat",
-          description: "Dump recent adb logcat output scoped by package, pid, or tag with tail and timeout controls.",
-          inputSchema: logcatInputSchema
+          title: "Manage ADB Logcat",
+          description: "Unified tool to read logs, capture crashes, check ANRs, and clear buffers.",
+          inputSchema: manageLogcatSchema
         },
-        async (params, extra) => {
-          const timeoutMs = params.timeoutMs;
-          const pid = params.pid || (params.packageName ? await resolvePid(params.packageName, timeoutMs) : null);
-          const args = buildLogcatArgs(params, pid);
-          const startTime = process.hrtime.bigint();
-          const output = await runAdbCommand(args, timeoutMs);
-          const elapsedMs = Number(process.hrtime.bigint() - startTime) / 1e6;
-          if (extra && typeof extra.sessionId === "string") {
-            server2.sendLoggingMessage(
-              {
-                level: "info",
-                data: `Read logcat (${params.maxLines} lines` + (pid ? `, pid=${pid}` : "") + (params.tag ? `, tag=${params.tag}:${params.priority}` : "") + `) in ${elapsedMs.toFixed(2)}ms`
-              },
-              extra.sessionId
-            ).catch(() => {
-            });
+        async (params) => {
+          const { action, timeoutMs } = params;
+          if (action === "clear") {
+            await runAdbCommand(["logcat", "-c"], timeoutMs);
+            return { content: [{ type: "text", text: "Cleared logcat buffers." }] };
           }
-          if (!output) {
-            return { content: [{ type: "text", text: "Logcat returned no lines." }] };
+          let pid = params.pid;
+          if (!pid && params.packageName) {
+            pid = await resolvePid(params.packageName, timeoutMs);
           }
-          return { content: [{ type: "text", text: output }] };
-        }
-      );
-      server2.registerTool(
-        "get-pid-by-package",
-        {
-          title: "Get pid by package",
-          description: "Resolve process id for a package via adb shell pidof -s.",
-          inputSchema: pidInputSchema
-        },
-        async (params) => {
-          const pid = await resolvePid(params.packageName, params.timeoutMs);
-          return { content: [{ type: "text", text: pid }] };
+          if (action === "anr") {
+            const sections = [];
+            try {
+              const logArgs = ["logcat", "-d", "-t", String(params.maxLines), "ActivityManager:E", "*:S"];
+              const amLogs = await runAdbCommand(logArgs, timeoutMs);
+              sections.push("ActivityManager (recent):\n" + (amLogs || "No entries."));
+            } catch (e) {
+              sections.push("ActivityManager error: " + e.message);
+            }
+            try {
+              const tail = await runAdbCommand(["shell", "tail", "-n", "200", "/data/anr/traces.txt"], timeoutMs);
+              sections.push("traces.txt tail (200 lines):\n" + (tail || "Empty."));
+            } catch (e) {
+              sections.push("traces.txt error: " + e.message);
+            }
+            return { content: [{ type: "text", text: sections.join("\n\n") }] };
+          }
+          if (action === "crash") {
+            const args2 = ["logcat", "-b", "crash", "-d", "-t", String(params.maxLines)];
+            if (pid) args2.push(`--pid=${pid}`);
+            const output2 = await runAdbCommand(args2, timeoutMs);
+            return { content: [{ type: "text", text: output2 || "No crash entries found." }] };
+          }
+          const args = ["logcat", "-d", "-t", String(params.maxLines)];
+          if (pid) args.push(`--pid=${pid}`);
+          if (params.tag) {
+            args.push("-s", `${params.tag}:${params.priority}`);
+          }
+          const output = await runAdbCommand(args, timeoutMs);
+          return { content: [{ type: "text", text: output || "Logcat returned no lines." }] };
         }
       );
       server2.registerTool(
         "get-current-activity",
         {
           title: "Get current activity/window focus",
-          description: "Inspect current focused app/window via dumpsys window (mCurrentFocus/mFocusedApp). Useful even in single-activity apps to verify top window.",
+          description: "Inspect current focused app/window via dumpsys window.",
           inputSchema: currentActivityInputSchema
         },
         async (params) => {
           const dump = await runAdbCommand(["shell", "dumpsys", "window"], params.timeoutMs);
           const lines = dump.split("\n").filter((line) => line.includes("mCurrentFocus") || line.includes("mFocusedApp"));
           const trimmed = lines.slice(0, 8).join("\n").trim();
-          if (!trimmed) {
-            return { content: [{ type: "text", text: "No focus info found in dumpsys window." }] };
-          }
-          return { content: [{ type: "text", text: trimmed }] };
-        }
-      );
-      server2.registerTool(
-        "fetch-crash-stacktrace",
-        {
-          title: "Fetch crash stacktrace (crash buffer)",
-          description: "Pull recent crash buffer (-b crash -d -t) optionally filtered by pid resolved from package.",
-          inputSchema: crashStackInputSchema
-        },
-        async (params) => {
-          const pid = params.packageName ? await resolvePid(params.packageName, params.timeoutMs) : null;
-          const args = ["logcat", "-b", "crash", "-d", "-t", String(params.maxLines)];
-          if (pid) {
-            args.push(`--pid=${pid}`);
-          }
-          const output = await runAdbCommand(args, params.timeoutMs);
-          if (!output) {
-            return { content: [{ type: "text", text: "No crash entries found." }] };
-          }
-          return { content: [{ type: "text", text: output }] };
-        }
-      );
-      server2.registerTool(
-        "check-anr-state",
-        {
-          title: "Check ANR state (ActivityManager + traces)",
-          description: "Check recent ActivityManager ANR logs and tail /data/anr/traces.txt when accessible (best-effort, may require root/debuggable).",
-          inputSchema: anrStateInputSchema
-        },
-        async (params) => {
-          const sections = [];
-          try {
-            const amLogs = await runAdbCommand(
-              ["logcat", "-d", "-t", String(params.maxLines), "ActivityManager:E", "*:S"],
-              params.timeoutMs
-            );
-            if (amLogs) {
-              sections.push("ActivityManager (recent):\n" + amLogs);
-            } else {
-              sections.push("ActivityManager (recent): no entries.");
-            }
-          } catch (error) {
-            sections.push(`ActivityManager: ${error.message}`);
-          }
-          try {
-            const stat = await runAdbCommand(["shell", "ls", "-l", "/data/anr/traces.txt"], params.timeoutMs);
-            sections.push("traces.txt stat:\n" + stat);
-          } catch (error) {
-            sections.push(`traces.txt stat: ${error.message}`);
-          }
-          try {
-            const tail = await runAdbCommand(
-              ["shell", "tail", "-n", "200", "/data/anr/traces.txt"],
-              params.timeoutMs
-            );
-            if (tail) {
-              sections.push("traces.txt tail (200 lines):\n" + tail);
-            } else {
-              sections.push("traces.txt tail: empty.");
-            }
-          } catch (error) {
-            sections.push(`traces.txt tail: ${error.message}`);
-          }
-          return { content: [{ type: "text", text: sections.join("\n\n") }] };
-        }
-      );
-      server2.registerTool(
-        "clear-logcat-buffer",
-        {
-          title: "Clear logcat buffer",
-          description: "Run adb logcat -c to clear buffers before a new scenario.",
-          inputSchema: clearLogcatInputSchema
-        },
-        async (params) => {
-          await runAdbCommand(["logcat", "-c"], params.timeoutMs);
-          return { content: [{ type: "text", text: "Cleared logcat buffers." }] };
+          return { content: [{ type: "text", text: trimmed || "No focus info found." }] };
         }
       );
     }
@@ -1511,17 +1418,205 @@ var require_textLengthTool = __commonJS({
   }
 });
 
+// src/tools/deviceTool.js
+var require_deviceTool = __commonJS({
+  "src/tools/deviceTool.js"(exports2, module2) {
+    var { execFile } = require("child_process");
+    var { promisify } = require("util");
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var z = require("zod/v4");
+    var execFileAsync = promisify(execFile);
+    var deviceToolInstructions2 = [
+      "Use dump-ui-hierarchy to capture the current screen structure (XML) via uiautomator.",
+      "Use take-screenshot to capture the device screen to a local file (PNG).",
+      "Use inject-input to send interactions like tap, text, swipe, or key events to the device."
+    ].join("\n");
+    var dumpUiSchema = z.object({
+      timeoutMs: z.number().int().min(1e3).max(2e4).default(1e4).describe("Timeout in milliseconds")
+    });
+    var screenshotSchema = z.object({
+      outputPath: z.string().min(1).describe("Local path to save the screenshot (e.g. screenshot.png)"),
+      timeoutMs: z.number().int().min(1e3).max(2e4).default(1e4).describe("Timeout in milliseconds")
+    });
+    var injectInputSchema = z.object({
+      command: z.enum(["tap", "text", "swipe", "keyevent", "back", "home"]).describe("Input command type"),
+      args: z.array(z.string().or(z.number())).optional().describe('Arguments for the command (e.g. [x, y] for tap, ["text"] for text). Optional if elementId/elementText provided.'),
+      elementId: z.string().optional().describe('Find element by resource-id and tap its center (e.g. "com.example:id/button")'),
+      elementText: z.string().optional().describe('Find element by text content and tap its center (e.g. "Login")'),
+      timeoutMs: z.number().int().min(1e3).max(2e4).default(1e4).describe("Timeout in milliseconds")
+    });
+    function getCenterFromBounds(bounds) {
+      const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+      if (!match) return null;
+      const x1 = parseInt(match[1], 10);
+      const y1 = parseInt(match[2], 10);
+      const x2 = parseInt(match[3], 10);
+      const y2 = parseInt(match[4], 10);
+      return {
+        x: Math.round((x1 + x2) / 2),
+        y: Math.round((y1 + y2) / 2)
+      };
+    }
+    async function runAdbCommand(args, timeoutMs, options = {}) {
+      try {
+        const { stdout } = await execFileAsync("adb", args, {
+          timeout: timeoutMs,
+          maxBuffer: 10 * 1024 * 1024,
+          ...options
+        });
+        return stdout;
+      } catch (error) {
+        const stderr = error && typeof error.stderr === "string" ? error.stderr.trim() : "";
+        const message = [`adb ${args.join(" ")} failed`, error.message].filter(Boolean).join(": ");
+        if (stderr) {
+          throw new Error(`${message} | stderr: ${stderr}`);
+        }
+        throw new Error(message);
+      }
+    }
+    async function runAdbCommandBinary(args, timeoutMs) {
+      try {
+        const { stdout } = await execFileAsync("adb", args, {
+          timeout: timeoutMs,
+          encoding: "buffer",
+          maxBuffer: 20 * 1024 * 1024
+        });
+        return stdout;
+      } catch (error) {
+        throw new Error(`adb ${args.join(" ")} failed: ${error.message}`);
+      }
+    }
+    function registerDeviceTool2(server2) {
+      server2.registerTool(
+        "dump-ui-hierarchy",
+        {
+          title: "Dump UI Hierarchy (XML)",
+          description: "Capture the current UI hierarchy as XML using uiautomator.",
+          inputSchema: dumpUiSchema
+        },
+        async (params) => {
+          const devicePath = "/data/local/tmp/mcp_window_dump.xml";
+          await runAdbCommand(["shell", "uiautomator", "dump", devicePath], params.timeoutMs);
+          const content = await runAdbCommand(["shell", "cat", devicePath], params.timeoutMs);
+          return { content: [{ type: "text", text: content.trim() }] };
+        }
+      );
+      server2.registerTool(
+        "take-screenshot",
+        {
+          title: "Take User Screenshot",
+          description: "Capture device screenshot and save to a local file.",
+          inputSchema: screenshotSchema
+        },
+        async (params) => {
+          const buffer = await runAdbCommandBinary(["exec-out", "screencap", "-p"], params.timeoutMs);
+          const absPath = path.resolve(params.outputPath);
+          fs.writeFileSync(absPath, buffer);
+          return { content: [{ type: "text", text: `Screenshot saved to ${absPath}` }] };
+        }
+      );
+      server2.registerTool(
+        "inject-input",
+        {
+          title: "Inject Input Events",
+          description: "Simulate user input interactions (tap, text, swipe, keyevents) or click by UI element.",
+          inputSchema: injectInputSchema
+        },
+        async (params) => {
+          let { command, args } = params;
+          const { elementId, elementText, timeoutMs } = params;
+          args = args || [];
+          if (elementId || elementText) {
+            if (command !== "tap") {
+              throw new Error('elementId/elementText can only be used with command="tap".');
+            }
+            const devicePath = "/data/local/tmp/mcp_input_dump.xml";
+            await runAdbCommand(["shell", "uiautomator", "dump", devicePath], timeoutMs);
+            const xmlContent = await runAdbCommand(["shell", "cat", devicePath], timeoutMs);
+            let targetBounds = null;
+            const nodes = xmlContent.split("<node ");
+            for (const nodeStr of nodes) {
+              let matches = false;
+              if (elementId && nodeStr.includes(`resource-id="${elementId}"`)) matches = true;
+              if (elementText && nodeStr.includes(`text="${elementText}"`)) matches = true;
+              if (matches) {
+                const boundsMatch = nodeStr.match(/bounds="(\[\d+,\d+\]\[\d+,\d+\])"/);
+                if (boundsMatch) {
+                  targetBounds = boundsMatch[1];
+                  break;
+                }
+              }
+            }
+            if (!targetBounds) {
+              throw new Error(`Could not find element with id="${elementId}" or text="${elementText}" in current UI.`);
+            }
+            const center = getCenterFromBounds(targetBounds);
+            if (!center) {
+              throw new Error(`Invalid bounds found: ${targetBounds}`);
+            }
+            args = [String(center.x), String(center.y)];
+          }
+          let adbArgs = ["shell", "input"];
+          switch (command) {
+            case "tap":
+              if (args.length !== 2) throw new Error("tap requires x and y coordinates (or use elementId/elementText)");
+              adbArgs.push("tap", args[0], args[1]);
+              break;
+            case "text":
+              if (args.length !== 1) throw new Error("text requires a single string argument");
+              let safeText = String(args[0]).replace(/\s/g, "%s");
+              adbArgs.push("text", safeText);
+              break;
+            case "swipe":
+              if (args.length < 4) throw new Error("swipe requires at least x1, y1, x2, y2");
+              adbArgs.push("swipe", ...args);
+              break;
+            case "keyevent":
+            case "back":
+            case "home":
+              if (command === "back") {
+                adbArgs.push("keyevent", "4");
+              } else if (command === "home") {
+                adbArgs.push("keyevent", "3");
+              } else {
+                if (args.length < 1) throw new Error("keyevent requires keycode");
+                adbArgs.push("keyevent", ...args);
+              }
+              break;
+            default:
+              throw new Error(`Unknown command: ${command}`);
+          }
+          await runAdbCommand(adbArgs, timeoutMs);
+          return { content: [{ type: "text", text: `Executed input ${command} ${JSON.stringify(args)}` }] };
+        }
+      );
+    }
+    module2.exports = {
+      registerDeviceTool: registerDeviceTool2,
+      deviceToolInstructions: deviceToolInstructions2
+    };
+  }
+});
+
 // src/index.js
 var { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
 var { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
 var { registerSvgTool, svgToolInstructions } = require_svgTool();
 var { registerLogcatTool, logcatToolInstructions } = require_logcatTool();
 var { registerTextLengthTool, textLengthToolInstructions } = require_textLengthTool();
-var serverInstructions = [svgToolInstructions, logcatToolInstructions, textLengthToolInstructions].join("\n");
+var { registerDeviceTool, deviceToolInstructions } = require_deviceTool();
+var serverInstructions = [
+  svgToolInstructions,
+  logcatToolInstructions,
+  textLengthToolInstructions,
+  deviceToolInstructions
+].join("\n");
 var server = new McpServer(
   {
-    name: "svg-to-android-drawable",
-    version: "1.2.0"
+    name: "android-mcp-toolkit",
+    version: "1.3.0"
   },
   {
     capabilities: { logging: {} },
@@ -1531,6 +1626,7 @@ var server = new McpServer(
 registerSvgTool(server);
 registerLogcatTool(server);
 registerTextLengthTool(server);
+registerDeviceTool(server);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "android-mcp-toolkit",
-  "version": "1.2.0",
-  "description": "MCP server that converts SVG into Android VectorDrawable XML with a fast path and caching.",
+  "version": "1.3.0",
+  "description": "MCP server with useful Android development tools: SVG conversion, Logcat management, and Device automation (dump UI, screenshot, input).",
   "main": "dist/index.js",
   "scripts": {
     "start": "node dist/index.js",
@@ -24,11 +24,11 @@
   "license": "MIT",
   "type": "commonjs",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.24.3",
+    "@modelcontextprotocol/sdk": "^1.25.1",
     "svg-path-bounds": "^1.0.1",
-    "svgo": "^2.8.0",
+    "svgo": "^4.0.0",
     "svgpath": "^2.5.0",
-    "zod": "^4.1.13"
+    "zod": "^4.2.1"
   },
   "devDependencies": {
     "tsup": "^8.3.0",