@mmerterden/multi-agent-toolkit-mcp 3.6.0 → 3.7.1

package/CHANGELOG.md

@@ -15,6 +15,60 @@ Releases before this file exists are recorded in the git tags and commit history
 
 ---
 
+## 3.7.1
+
+### Fixed
+
+- **`android_meminfo` never read the swap total on a real device.** The parser
+  was written from the documented output, which spells the line
+  `TOTAL SWAP (KB):`. An Android 35 Pixel emulator prints `TOTAL SWAP PSS:`, so
+  the regex matched nothing and `total_swap_kb` came back null on every real
+  run. Both spellings are accepted now, and the fixture is the emulator's own
+  output rather than a reconstruction.
+
+  This is the defect the 3.3.0 note predicted: that parser shipped marked "not
+  verified on a device", and the first real device broke it. Worth recording
+  plainly, because the note was right and the only thing that found the bug was
+  running it.
+
+### Note
+
+The Android checks are no longer unverified. `android_accessibility_audit` and
+`android_meminfo` were both run against a booted Android 35 emulator: the audit
+read 14 clickable elements off a real launcher, reported the reading order as
+correct with no false positive on the grid, and produced one critical and seven
+warnings; meminfo read the App Summary and, after the fix above, the swap total.
+
+## 3.7.0
+
+### Added
+
+- **`android_accessibility_audit` gains screen-reader reachability and reading
+  order.** A clickable node with `focusable="false"` can be tapped by a sighted
+  user and never reached by TalkBack at all: the control is invisible to the
+  screen reader rather than merely unnamed, so it is a `critical` finding, above
+  a missing contentDescription. The reading-order check is the same
+  rows-then-columns comparison the iOS side uses, sharing one implementation,
+  with `rtl` for right-to-left layouts.
+
+### Fixed
+
+- **A claim of mine in three places was wrong.** The notes on `android_meminfo`
+  and the 3.3.0 entry said this machine has no adb. It has adb; what it has no
+  Android device or emulator to run against. The distinction matters to anyone
+  reading those notes to decide what still needs verifying, so all three now say
+  what is actually missing.
+
+### Note
+
+Stage 4 of 4, and the last one that could not be measured here. The iOS work was
+verified against a live simulator at every step, including a generated app with
+planted defects for Apple's own audit. The Android checks are written against
+the documented `uiautomator dump` shape and pinned by fixtures; nothing on this
+machine could run them against a device. The first real run is their measurement,
+and the hierarchy attribute they depend on, `focusable`, is one uiautomator has
+always emitted.
+
 ## 3.6.0
 
 ### Added
@@ -47,7 +101,7 @@ Releases before this file exists are recorded in the git tags and commit history
 ### Note
 
 Stage 3 of 4. The Android side is last and stays unverifiable here: this machine
-has no adb and no emulator.
+has adb but no device or emulator to run it against.
 
 ## 3.5.0
 
@@ -85,7 +139,7 @@ has no adb and no emulator.
 Stage 2 of 4. Contrast, Dynamic Type and clipped text still cannot be reached
 from a tree dump; they need Apple's own `XCUIAccessibilityAudit`, which is an
 XCUITest run rather than a simctl call. The Android side is stage 4 and is
-unverifiable on a machine with no adb.
+unverifiable without a device or emulator to run adb against.
 
 ## 3.4.0
 
@@ -161,7 +215,8 @@ order, traits and hints come next, then Apple's own `XCUIAccessibilityAudit`
 ### Note
 
 `android_meminfo`'s parser was written against the documented output shape on a
-machine with no adb and no emulator. The `leaks` parser was written against live
+machine with adb installed but no device or emulator to run it against. The
+`leaks` parser was written against live
 output captured from real runs, including the leaking and the unmeasurable case.
 The tests pin both shapes; the first real Android run is that half's measurement.
 

package/index.js

@@ -923,7 +923,7 @@ const ANDROID_TOOLS = [
   { name: "android_get_screen_size", description: "Get Android screen resolution", inputSchema: { type: "object", properties: { device_id: { type: "string" } } } },
   { name: "android_open_url", description: "Open URL or deep link on Android", inputSchema: { type: "object", properties: { url: { type: "string" }, device_id: { type: "string" } }, required: ["url"] } },
   { name: "android_clear_app_data", description: "Clear all data for Android app", inputSchema: { type: "object", properties: { package_name: { type: "string" }, device_id: { type: "string" } }, required: ["package_name"] } },
-  { name: "android_accessibility_audit", description: "Audit Android app accessibility: missing contentDescription, small touch targets (<48dp), missing resource-id. Use scope to filter by resource-id prefix.", inputSchema: { type: "object", properties: { device_id: { type: "string" }, scope: { type: "string", description: "Filter: only audit elements whose resource-id contains this prefix (e.g. 'login_', 'com.example:id/login_'). Omit to audit all." } } } },
+  { name: "android_accessibility_audit", description: "Audit Android app accessibility on the connected device: missing contentDescription, clickable nodes TalkBack cannot focus, touch targets under 48dp, missing resource-ids, and whether the reading order follows the visual layout. Reports measurable:false with a reason rather than a clean result when the dump could not be read.", inputSchema: { type: "object", properties: { device_id: { type: "string" }, scope: { type: "string", description: "Filter: only audit elements whose resource-id contains this prefix (e.g. 'login_', 'com.example:id/login_'). Omit to audit all." }, rtl: { type: "boolean", description: "Expect right-to-left reading within a row. Default false." } } } },
   { name: "android_launch_time", description: "Measure Android app launch time: force-stops the package, starts it with am start -W, and reports TotalTime/WaitTime in ms plus the platform's own LaunchState (COLD/WARM/HOT). Below Android 10 there is no LaunchState and cold_start is null rather than assumed.", inputSchema: { type: "object", properties: { package_name: { type: "string" }, activity: { type: "string" }, device_id: { type: "string" } }, required: ["package_name"] } },
   { name: "android_apk_audit", description: "Audit APK/AAB for Play Store compliance: debug flag, target SDK, permissions, signing, ProGuard", inputSchema: { type: "object", properties: { apk_path: { type: "string", description: "Path to .apk file" } }, required: ["apk_path"] } },
   { name: "android_meminfo", description: "Read an Android app's memory via `adb shell dumpsys meminfo` (KB, no root). mode=snapshot returns the App Summary rows and totals; mode=diff compares two snapshots so growth across the same flow is visible, which is the signal a leak actually produces - a single absolute number says almost nothing. Reports measurable:false when the package has no running process rather than returning zeros.", inputSchema: { type: "object", properties: { package_name: { type: "string" }, device_id: { type: "string" }, mode: { type: "string", enum: ["snapshot", "diff"], description: "Default: snapshot" }, baseline_json: { type: "string", description: "mode=diff: the JSON returned by an earlier snapshot call" } }, required: ["package_name"] } },
@@ -1084,13 +1084,14 @@ async function handleAndroid(name, args, ctx = {}) {
       run(`adb ${df} pull /sdcard/_mcp_a11y.xml ${shq(f)}`);
       run(`adb ${df} shell rm /sdcard/_mcp_a11y.xml`);
       const xml = existsSync(f) ? readFileSync(f, "utf-8") : "";
-      const r = auditAndroidDump({ xml, scope: args.scope || null });
+      const r = auditAndroidDump({ xml, scope: args.scope || null, rtl: args.rtl === true });
       return JSON.stringify({
         scope: r.scope,
         measurable: r.measurable,
         reason: r.reason,
         elements_scanned: r.elementsScanned,
         elements_skipped: r.elementsSkipped,
+        reading_order_ok: r.readingOrderOk ?? null,
         total_issues: r.totalIssues,
         critical: r.critical,
         important: r.important,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-toolkit-mcp",
-  "version": "3.6.0",
+  "version": "3.7.1",
   "description": "MCP server for iOS Simulator, Android Emulator and headless web control. 87 tools: device automation (tap/swipe/type), accessibility audits, visual diff, crash logs, App Store / Play Store pre-submission compliance. Runs standalone over stdio with any MCP client.",
   "type": "module",
   "main": "index.js",

package/tools/a11y/index.js

@@ -250,7 +250,7 @@ export function auditIosTree({ tree, scope = null, rtl = false }) {
  * @param {string|null} [params.scope] - only audit resource-ids containing this
  * @returns {object} same shape as auditIosTree
  */
-export function auditAndroidDump({ xml, scope = null }) {
+export function auditAndroidDump({ xml, scope = null, rtl = false }) {
   const text = typeof xml === "string" ? xml : "";
   if (!/<node\b/.test(text)) {
     return unmeasurable(scope, "the uiautomator dump held no nodes; the dump failed or the screen was not ready");
@@ -259,6 +259,7 @@ export function auditAndroidDump({ xml, scope = null }) {
   const issues = [];
   let elementsScanned = 0;
   let elementsSkipped = 0;
+  const sequence = [];
 
   for (const match of text.matchAll(/<node[^>]*>/g)) {
     const node = match[0];
@@ -276,13 +277,25 @@ export function auditAndroidDump({ xml, scope = null }) {
     }
     elementsScanned++;
 
+    // TalkBack moves between FOCUSABLE nodes. A clickable node that is not
+    // focusable can be tapped by a sighted user and never reached by a screen
+    // reader at all, which is a harder failure than a missing label: the
+    // control is invisible to the user rather than merely unnamed.
+    if (/focusable="false"/.test(node)) {
+      issues.push({ severity: "critical", issue: "Clickable but not focusable: TalkBack cannot reach this control", element: cls, resourceId: rid || null });
+    }
+
     if (!desc && !label) issues.push({ severity: "critical", issue: "Missing contentDescription", element: cls, resourceId: rid || null });
     if (!rid) issues.push({ severity: "warning", issue: "Missing resource-id (UI testing)", element: cls });
 
     const bounds = node.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     if (bounds) {
-      const w = parseInt(bounds[3], 10) - parseInt(bounds[1], 10);
-      const h = parseInt(bounds[4], 10) - parseInt(bounds[2], 10);
+      const x = parseInt(bounds[1], 10);
+      const y = parseInt(bounds[2], 10);
+      const w = parseInt(bounds[3], 10) - x;
+      const h = parseInt(bounds[4], 10) - y;
+      // Same shape the iOS side uses, so one reading-order check serves both.
+      sequence.push({ role: cls, identifier: rid || null, title: desc || label || null, frame: { x, y, w, h } });
       if (w < ANDROID_MIN_TAP_DP || h < ANDROID_MIN_TAP_DP) {
         issues.push({ severity: "important", issue: `Touch target too small: ${w}x${h}dp (min ${ANDROID_MIN_TAP_DP}x${ANDROID_MIN_TAP_DP})`, element: cls, resourceId: rid || null });
       }
@@ -297,12 +310,25 @@ export function auditAndroidDump({ xml, scope = null }) {
     );
   }
 
+  const order = checkReadingOrder(sequence, rtl);
+  if (!order.ok) {
+    const el = order.firstOutOfPlace;
+    issues.push({
+      severity: "important",
+      issue: `Reading order does not follow the visual layout: this element is read at position ${sequence.indexOf(el) + 1} but sits at position ${order.expectedIndex + 1} on screen`,
+      element: el.role,
+      resourceId: el.identifier || null,
+      label: el.title || null,
+    });
+  }
+
   return {
     measurable: true,
     reason: null,
     scope: scope || "all",
     elementsScanned,
     elementsSkipped,
+    readingOrderOk: order.ok,
     ...tally(issues),
   };
 }

package/tools/memory/index.js

@@ -85,10 +85,12 @@ const MEMINFO_ROWS = [
  * snapshots of the same flow is the shape a leak takes, where a single
  * absolute number says almost nothing.
  *
- * NOT VERIFIED ON A DEVICE. Written against the documented output shape on a
- * machine with no adb and no emulator, unlike the leaks parser above, which was
- * checked against live output. The tests below pin the shape this expects; the
- * first real run is the measurement.
+ * Verified against a real device: an Android 35 Pixel emulator, after the parser
+ * had first been written from documentation alone. That first version returned
+ * null for the swap total on every real device, because the documented shape
+ * says "TOTAL SWAP (KB):" and the device prints "TOTAL SWAP PSS:". Both are
+ * accepted now. It is the clearest argument in this file for running a parser
+ * against the thing it parses.
  *
  * @param {string} raw
  * @returns {{measurable: boolean, reason: string|null, pss: object, totalPssKb: number|null,
@@ -117,7 +119,11 @@ export function parseMeminfoOutput(raw) {
   };
   const totalPssKb = num(/TOTAL PSS:\s*(\d+)/i);
   const totalRssKb = num(/TOTAL RSS:\s*(\d+)/i);
-  const totalSwapKb = num(/TOTAL SWAP \(KB\):\s*(\d+)/i);
+  // Two spellings in the wild: "TOTAL SWAP (KB):" in the documented shape and
+  // "TOTAL SWAP PSS:" on a real Android 35 device, which is what a Pixel
+  // emulator actually printed. The first regex, written from documentation,
+  // returned null against every real device.
+  const totalSwapKb = num(/TOTAL SWAP(?: \(KB\)| PSS)?:\s*(\d+)/i);
 
   if (found === 0 && totalPssKb === null) {
     return { measurable: false, reason: "no App Summary block in the dumpsys output", pss: {}, totalPssKb: null, totalRssKb: null, totalSwapKb: null };