android-mcp-toolkit 1.1.0 → 1.3.0

package/README.md

@@ -1,8 +1,9 @@
 # Android MCP Toolkit for AI Agents
 
-Small MCP server with two tools:
+Small MCP server with three tools:
 - Fast SVG → Android VectorDrawable conversion (cached, file or inline).
 - adb logcat reader with package/pid/tag filters for quick crash triage.
+- Translation length difference estimator to flag risky length deltas before layout breaks.
 
 ## Why this exists
 **The Mission: Bringing Native Android to the AI Agent Era**
@@ -72,6 +73,10 @@ While the AI ecosystem flourishes with web-first tools, Android development ofte
   - Inputs: `timeoutMs` (default `5000`, max `15000`).
   - Behavior: Runs `adb logcat -c` to clear buffers before a new scenario.
 
+- `estimate-text-length-difference`
+  - Inputs: `sourceText` (original), `translatedText` (to compare), `tolerancePercent` (default `30`, max `500`).
+  - Behavior: Measures grapheme length of both strings, computes percent change, and reports whether it exceeds the tolerance (useful to catch translation length blowups that could break layouts).
+
 ## Roadmap (planned)
 - Additional MCP tools for Android assets (e.g., batch conversions, validations, optimizers).
 - Optional resource prompts for common Android drawables/templates.
@@ -83,15 +88,11 @@ While the AI ecosystem flourishes with web-first tools, Android development ofte
 
 ## Quick start
 - `npm install`
-- `npm start` (keeps running on stdio; point your MCP client at `node src/index.js`)
+- `npm run build`
+- `node dist/index.js` (stdio MCP server)
 
 ## Run via npx
-- From repo root: `npx .` (uses `svg-to-drawable-mcp` bin; runs on stdio)
-
-## Run with Docker
-- Build: `docker build -t svg-to-drawable-mcp .`
-- Run: `docker run --rm -it svg-to-drawable-mcp`
-- The container prints to stdio; point your MCP client at `docker run --rm -i svg-to-drawable-mcp`.
+- Global: `npx android-mcp-toolkit`
 
 ## Use in Cursor (MCP config)
 Add to your Cursor settings JSON:
@@ -101,17 +102,20 @@ Add to your Cursor settings JSON:
     "figma-desktop": {
       "url": "http://127.0.0.1:3845/mcp"
     },
-    "svg-to-android-drawable": {
+    "android-mcp-toolkit": {
       "command": "npx",
       "args": [
         "-y",
-        "/Users/admin/code/android_util_mcp_server"
+        "android-mcp-toolkit"
       ]
     }
   }
 }
 ```
-Adjust the local path if your repo lives elsewhere.
+The npx call downloads the published package; no local path required.
+
+Quick install via Cursor deep link:
+- `cursor://anysphere.cursor-deeplink/mcp/install?name=android-mcp-toolkit&config=eyJjb21tYW5kIjoibnB4IC15IGFuZHJvaWQtbWNwLXRvb2xraXQifQ%3D%3D`
 
 ## Examples
 - Input SVG: `sample_svg.svg`

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,164 +1287,315 @@ 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 }] };
+          return { content: [{ type: "text", text: trimmed || "No focus info found." }] };
+        }
+      );
+    }
+    module2.exports = {
+      registerLogcatTool: registerLogcatTool2,
+      logcatToolInstructions: logcatToolInstructions2
+    };
+  }
+});
+
+// src/tools/textLengthTool.js
+var require_textLengthTool = __commonJS({
+  "src/tools/textLengthTool.js"(exports2, module2) {
+    var z = require("zod/v4");
+    var textLengthToolInstructions2 = [
+      "Use estimate-text-length-difference to compare original vs translated text lengths and flag large deltas.",
+      "Configure tolerancePercent to set the allowed absolute percentage difference (default 30%).",
+      "The tool reports both lengths, percent change, and whether the change exceeds tolerance."
+    ].join("\n");
+    var lengthDiffInputSchema = z.object({
+      sourceText: z.string().min(1).describe("Original text before translation"),
+      translatedText: z.string().min(1).describe("Translated text to compare against the original"),
+      tolerancePercent: z.number().min(1).max(500).default(30).describe("Allowed absolute percent difference between lengths before flagging risk")
+    });
+    function measureLength(text) {
+      return Array.from(text).length;
+    }
+    function registerTextLengthTool2(server2) {
+      server2.registerTool(
+        "estimate-text-length-difference",
+        {
+          title: "Estimate text length difference",
+          description: "Compare original and translated text lengths to detect layout risk; configurable tolerancePercent (default 30%).",
+          inputSchema: lengthDiffInputSchema
+        },
+        async (params) => {
+          const sourceLength = measureLength(params.sourceText);
+          const translatedLength = measureLength(params.translatedText);
+          const delta = translatedLength - sourceLength;
+          const percentChange = sourceLength === 0 ? null : delta / sourceLength * 100;
+          const exceeds = percentChange === null ? translatedLength > 0 : Math.abs(percentChange) > params.tolerancePercent;
+          const direction = delta === 0 ? "no change" : delta > 0 ? "longer" : "shorter";
+          const verdict = percentChange === null && translatedLength === 0 ? "\u2705 Both texts are empty; no length risk." : percentChange === null ? "\u26A0\uFE0F Source length is 0; percent change undefined and translated text is present." : exceeds ? "\u26A0\uFE0F Length difference exceeds tolerance (layout risk likely)." : "\u2705 Length difference within tolerance.";
+          const summary = [
+            verdict,
+            `Source length: ${sourceLength}`,
+            `Translated length: ${translatedLength}`,
+            percentChange === null ? `Change: N/A (source length is 0; direction: ${direction})` : `Change: ${percentChange.toFixed(2)}% (${direction})`,
+            `Tolerance: \xB1${params.tolerancePercent}%`
+          ].join("\n");
+          return { content: [{ type: "text", text: summary }] };
         }
       );
+    }
+    module2.exports = {
+      registerTextLengthTool: registerTextLengthTool2,
+      textLengthToolInstructions: textLengthToolInstructions2
+    };
+  }
+});
+
+// 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(
-        "fetch-crash-stacktrace",
+        "dump-ui-hierarchy",
         {
-          title: "Fetch crash stacktrace (crash buffer)",
-          description: "Pull recent crash buffer (-b crash -d -t) optionally filtered by pid resolved from package.",
-          inputSchema: crashStackInputSchema
+          title: "Dump UI Hierarchy (XML)",
+          description: "Capture the current UI hierarchy as XML using uiautomator.",
+          inputSchema: dumpUiSchema
         },
         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 }] };
+          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(
-        "check-anr-state",
+        "take-screenshot",
         {
-          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
+          title: "Take User Screenshot",
+          description: "Capture device screenshot and save to a local file.",
+          inputSchema: screenshotSchema
         },
         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") }] };
+          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(
-        "clear-logcat-buffer",
+        "inject-input",
         {
-          title: "Clear logcat buffer",
-          description: "Run adb logcat -c to clear buffers before a new scenario.",
-          inputSchema: clearLogcatInputSchema
+          title: "Inject Input Events",
+          description: "Simulate user input interactions (tap, text, swipe, keyevents) or click by UI element.",
+          inputSchema: injectInputSchema
         },
         async (params) => {
-          await runAdbCommand(["logcat", "-c"], params.timeoutMs);
-          return { content: [{ type: "text", text: "Cleared logcat buffers." }] };
+          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 = {
-      registerLogcatTool: registerLogcatTool2,
-      logcatToolInstructions: logcatToolInstructions2
+      registerDeviceTool: registerDeviceTool2,
+      deviceToolInstructions: deviceToolInstructions2
     };
   }
 });
@@ -1465,11 +1605,18 @@ 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 serverInstructions = [svgToolInstructions, logcatToolInstructions].join("\n");
+var { registerTextLengthTool, textLengthToolInstructions } = require_textLengthTool();
+var { registerDeviceTool, deviceToolInstructions } = require_deviceTool();
+var serverInstructions = [
+  svgToolInstructions,
+  logcatToolInstructions,
+  textLengthToolInstructions,
+  deviceToolInstructions
+].join("\n");
 var server = new McpServer(
   {
-    name: "svg-to-android-drawable",
-    version: "1.1.0"
+    name: "android-mcp-toolkit",
+    version: "1.3.0"
   },
   {
     capabilities: { logging: {} },
@@ -1478,6 +1625,8 @@ 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.1.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",