@mmerterden/multi-agent-toolkit-mcp 3.2.0 → 3.4.0

package/CHANGELOG.md

@@ -15,6 +15,84 @@ Releases before this file exists are recorded in the git tags and commit history
 
 ---
 
+## 3.4.0
+
+### Fixed
+
+- **The accessibility audits reported a clean screen they had never read.** On a
+  tree that came back empty they returned `elements_scanned: 0, total_issues: 0,
+  critical: 0, important: 0, warning: 0` - a full clean bill of health,
+  indistinguishable from an accessible screen, and the first reading is the one
+  anyone believes. Both audits now carry `measurable` and a `reason`, and an
+  unmeasurable run reports `total_issues: null`, never 0. A count of zero is a
+  measurement; none was taken.
+
+- **The iOS tree was empty until the Simulator window had been activated.**
+  Measured on a live simulator: 1 node before activation, 28 after, and it stays
+  populated once the window is backgrounded again. The dumper now activates the
+  window itself. It also says what to do when Simulator.app is not running at
+  all, because booting a device with `simctl` is not enough - the accessibility
+  bridge lives in the UI app.
+
+- **The iOS audit scored Simulator.app's own chrome as app findings.** The
+  dumped window carries the hardware buttons, the toolbar and the title text
+  beside the device screen, so Apple's 17x65pt Volume Up button was reported as
+  an app tap-target violation. The audit now scopes to the device screen, the
+  largest AXGroup child of the window. On a live Home screen this took the
+  result from 23 findings over 23 elements to 1 finding over 13: 22 of the 23
+  were the simulator's own interface.
+
+- The scoring moved to `tools/a11y/` with a suite covering the degenerate tree,
+  the chrome exclusion, a scope that matches nothing, and the rule that an
+  element with no identifier is audited whatever the scope - you cannot scope
+  what you cannot identify, and skipping it would hide the finding that says so.
+
+### Note
+
+This is the first of four stages. It buys nothing new for a blind user yet; it
+makes the existing checks honest so the next stages can be trusted. Reading
+order, traits and hints come next, then Apple's own `XCUIAccessibilityAudit`
+(contrast, Dynamic Type, clipped text), then the Android side.
+
+## 3.3.0
+
+### Added
+
+- `ios_leaks` and `android_meminfo`: the server had 84 tools and not one of them
+  looked at memory.
+
+  `ios_leaks` runs `/usr/bin/leaks` against a simulator or host process, by pid
+  or by bundle id. Simulator processes are ordinary host processes, so no
+  `simctl spawn` is needed; this was checked against a live simulator rather than
+  assumed. `mode: "diff"` reports only what is new since a memory graph saved by
+  an earlier call, which is the shape a regression gate wants, where a single
+  absolute count says little.
+
+  `android_meminfo` reads `dumpsys meminfo` (KB, no root) and `mode: "diff"`
+  compares two snapshots, because growth across the same flow is the signal a
+  leak produces.
+
+  Both report `measurable: false` with a reason instead of a clean result when
+  they could not look: an iOS target without `get-task-allow`, an Android package
+  with no running process. `leaks` exits 0 in the unmeasurable case, exactly as
+  it does for a clean run, so anything keying off the exit status calls an
+  uninspected process leak-free.
+
+### Fixed
+
+- `run()` turned every non-zero exit into an `ERROR` string with the command's
+  output discarded. `leaks` exits 1 when it FINDS leaks, so the new tool would
+  have reported its most important result as "could not measure". `runCapture()`
+  returns what the command printed and lets the caller decide what the status
+  means. Existing callers are untouched.
+
+### 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
+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.
+
 ## 3.2.0
 
 ### Added

package/README.md

@@ -7,7 +7,7 @@
 
 🇹🇷 Türkçe: [README.tr.md](./README.tr.md)
 
-**84 tools** for iOS Simulator, Android Emulator, and headless web control. MCP server that lets your AI coding assistant see, interact with, and audit your mobile apps - plus drive browsers, run an 18-rule App Store compliance audit, and orchestrate multi-step batch flows.
+**86 tools** for iOS Simulator, Android Emulator, and headless web control. MCP server that lets your AI coding assistant see, interact with, and audit your mobile apps - plus drive browsers, run an 18-rule App Store compliance audit, and orchestrate multi-step batch flows.
 
 Distributed on the **public npm registry** - `npx @mmerterden/multi-agent-toolkit-mcp` resolves with no auth, no token, no `~/.npmrc` setup.
 
@@ -17,6 +17,7 @@ That distinction is worth keeping straight. This line once called five hosts "th
 
 **7 categories:**
 - **Device Control** (59 tools) - screenshot, tap, swipe, type, navigate, dark mode, locale, orientation, location, permissions, push notifications, real start/stop screen recording
+- **Memory** (2 tools) - `ios_leaks` runs /usr/bin/leaks against a simulator or host process, snapshot or diff against a saved memory graph; `android_meminfo` reads dumpsys meminfo, snapshot or diff. Both report `measurable:false` rather than a clean result when they could not look
 - **Crash Diagnostics** (2 tools) - `ios_list_crashes` reads the host's DiagnosticReports, `android_list_crashes` dumps the adb crash buffer, both tail-bounded
 - **Accessibility Audit** (2 tools) - auto-detect missing labels, small tap targets, missing identifiers (scope filtering supported)
 - **Store Compliance** (5 tools) - App Store / Play Store readiness; **18-rule deep `ios_app_store_audit`** cross-references Apple ITMS error codes + App Store Review Guidelines (privacy manifest, required-reason API, Info.plist, code signing, entitlements, embedded SDK, IPv6, debug-tool leak, ...)
@@ -189,7 +190,7 @@ Run a scripted login flow in one MCP call:
 
 Returns per-step status so the agent can self-correct on failure.
 
-### iOS Tools (38)
+### iOS Tools (39)
 
 | Tool | Description |
 |------|-------------|
@@ -232,7 +233,7 @@ Returns per-step status so the agent can self-correct on failure.
 | `ios_visual_diff` | Compare two PNG screenshots (pixelmatch). Returns diff_pct, pass/fail vs threshold, optional diff PNG. Useful for snapshot regressions across light/dark, locale, dynamic type |
 | `ios_list_crashes` | List recent crash reports from the host's DiagnosticReports - filter by process name, bound by age and count |
 
-### Android Tools (30)
+### Android Tools (31)
 
 | Tool | Description |
 |------|-------------|

package/README.tr.md

@@ -7,7 +7,7 @@
 
 🇬🇧 English: [README.md](./README.md)
 
-iOS Simulator, Android Emulator ve headless web kontrolü için **84 araç**. AI kodlama asistanının mobil uygulamalarını görmesini, onlarla etkileşime girmesini ve denetlemesini sağlayan bir MCP sunucusu - ayrıca tarayıcıları sürer, 18-kurallık bir App Store uyumluluk denetimi çalıştırır ve çok-adımlı batch akışlarını orkestre eder.
+iOS Simulator, Android Emulator ve headless web kontrolü için **86 araç**. AI kodlama asistanının mobil uygulamalarını görmesini, onlarla etkileşime girmesini ve denetlemesini sağlayan bir MCP sunucusu - ayrıca tarayıcıları sürer, 18-kurallık bir App Store uyumluluk denetimi çalıştırır ve çok-adımlı batch akışlarını orkestre eder.
 
 **Public npm registry** üzerinden dağıtılır - `npx @mmerterden/multi-agent-toolkit-mcp`, auth'suz, token'sız, `~/.npmrc` ayarı gerekmeden çözülür.
 
@@ -189,7 +189,7 @@ Tek bir MCP çağrısında scriptlenmiş bir login akışı çalıştır:
 
 Agent'ın hata durumunda kendini düzeltebilmesi için adım-başına durum döner.
 
-### iOS Araçları (38)
+### iOS Araçları (39)
 
 | Araç | Açıklama |
 |------|-------------|
@@ -232,7 +232,7 @@ Agent'ın hata durumunda kendini düzeltebilmesi için adım-başına durum dön
 | `ios_visual_diff` | İki PNG screenshot'ı karşılaştır (pixelmatch). diff_pct, threshold'a karşı pass/fail, opsiyonel diff PNG döner. Açık/koyu mod, locale, dynamic type genelinde snapshot regresyonları için kullanışlı |
 | `ios_list_crashes` | Host'un DiagnosticReports dizinindeki güncel crash raporlarını listele - süreç adına göre filtrele, yaş ve sayı ile sınırla |
 
-### Android Araçları (30)
+### Android Araçları (31)
 
 | Araç | Açıklama |
 |------|-------------|

package/index.js

@@ -29,6 +29,8 @@ import {
 } from "./tools/ios-testflight/index.js";
 import { DESIGN_TOOLS, handleDesign } from "./tools/design-check/index.js";
 import { parseLaunchOutput } from "./tools/launch-time/index.js";
+import { parseLeaksOutput, parseMeminfoOutput, diffMeminfo } from "./tools/memory/index.js";
+import { auditIosTree, auditAndroidDump } from "./tools/a11y/index.js";
 import { interactiveElements } from "./tools/ui-inspect/index.js";
 import { selectCrashReports } from "./tools/crash-logs/index.js";
 import {
@@ -78,6 +80,25 @@ function run(cmd, opts = {}) {
   }
 }
 
+/**
+ * Run a command whose non-zero exit is a RESULT, not a failure.
+ *
+ * `leaks` exits 1 when it finds leaks. Through run() that becomes an ERROR
+ * string with the report discarded, and a parser reading it sees no summary
+ * line and concludes the target could not be measured - which turns "leaks
+ * found" into "nothing measured", the exact inversion the tool exists to avoid.
+ * Here the command's own output is returned whatever the status, and the
+ * caller decides what it means.
+ */
+function runCapture(cmd, opts = {}) {
+  try {
+    return execSync(cmd, { encoding: "utf-8", timeout: 30000, ...opts }).trim();
+  } catch (e) {
+    const printed = `${e.stdout || ""}${e.stderr || ""}`.trim();
+    return printed || `${ERROR_PREFIX}${truncateError(e.message)}`;
+  }
+}
+
 // Async twin of run() for tools that hold the child for minutes: execSync would
 // block the event loop, leaving the server unable to answer any other request
 // (or a cancellation) for the whole build. Same contract: trimmed stdout on
@@ -339,6 +360,7 @@ const IOS_TOOLS = [
   { name: "ios_xcodebuild", description: "Build / test / clean an Xcode project with progressive disclosure. Returns one-line summary plus xcresult ID; drill in via ios_xcresult. Token-efficient - full log stays out of context unless requested.", inputSchema: { type: "object", properties: { project: { type: "string", description: "Path to .xcodeproj (mutually exclusive with workspace)" }, workspace: { type: "string", description: "Path to .xcworkspace (mutually exclusive with project)" }, scheme: { type: "string" }, configuration: { type: "string", description: "Debug / Release (default: Release)" }, destination: { type: "string", description: "Xcode destination string. Default: generic iOS Simulator" }, action: { type: "string", enum: ["build", "test", "clean", "archive", "clean-build"], description: "Default: build" }, derived_data_path: { type: "string" }, extra_args: { type: "string", description: "Additional raw xcodebuild args appended verbatim" }, timeout_sec: { type: "number", description: "Build timeout in seconds (default 600)" } }, required: ["scheme"] } },
   { name: "ios_xcresult", description: "Drill into a previous ios_xcodebuild result by xcresult ID. Modes: summary (counts), errors (file:line + message), warnings, log (last N lines), tests (failed), metrics (XCTMetric performance results as JSON). Use this instead of dumping the whole build log into context.", inputSchema: { type: "object", properties: { id: { type: "string", description: "xcresult ID returned by ios_xcodebuild" }, mode: { type: "string", enum: ["summary", "errors", "warnings", "log", "tests", "metrics"], description: "Default: summary" }, log_lines: { type: "number", description: "Lines of raw log to return when mode=log (default 200)" }, test_id: { type: "string", description: "mode=metrics only: scope to one test case or suite instead of every measured test" } }, required: ["id"] } },
   { name: "ios_visual_diff", description: "Compare two PNG screenshots. Returns JSON with diff_pct, pass/fail vs threshold, and an optional diff image. Use for snapshot regression checks across light/dark, locale, dynamic type variants.", inputSchema: { type: "object", properties: { baseline: { type: "string", description: "Path to baseline PNG" }, current: { type: "string", description: "Path to current PNG" }, threshold: { type: "number", description: "Per-pixel color threshold 0..1 (default 0.1, lower = stricter)" }, max_diff_pct: { type: "number", description: "Fail if diff exceeds this percent (default 1.0)" }, output: { type: "string", description: "Path to write diff PNG (optional)" } }, required: ["baseline", "current"] } },
+  { name: "ios_leaks", description: "Look for leaked memory in a running simulator (or host) process with /usr/bin/leaks. mode=snapshot reports the current leak count and bytes; mode=diff reports only leaks new since a saved memory graph, which is the shape a regression gate wants. Reports measurable:false when the target lacks get-task-allow rather than reporting it as clean - leaks exits 0 in that case, so an unmeasurable target and a clean one are indistinguishable by exit status. Debug builds are debuggable; Apple-signed apps are not.", inputSchema: { type: "object", properties: { pid: { type: "number", description: "Process id. Either this or bundle_id." }, bundle_id: { type: "string", description: "Bundle id of an app running on the booted simulator; its pid is resolved for you." }, device_id: { type: "string" }, mode: { type: "string", enum: ["snapshot", "diff"], description: "Default: snapshot" }, baseline_graph: { type: "string", description: "mode=diff: path to the memory graph saved by an earlier call" }, output_graph: { type: "string", description: "Save a memory graph here to use as a later baseline" } }, required: [] } },
   { name: "ios_list_crashes", description: "List recent crash reports from the host's ~/Library/Logs/DiagnosticReports - where simulator app crashes land. Filter by process name, bound by age and count.", inputSchema: { type: "object", properties: { app: { type: "string", description: "Only reports whose file name (the crashed process) contains this substring" }, since_min: { type: "number", description: "Only reports newer than this many minutes" }, limit: { type: "number", description: "Max reports returned, newest first (default 20)" } } } },
 ];
 
@@ -479,38 +501,27 @@ async function handleIOS(name, args, ctx = {}) {
       const script = join(__dirname, "ui-tree-dumper.swift");
       if (!existsSync(script)) return "ui-tree-dumper.swift not found";
       const depth = num(args.max_depth ?? 10, "max_depth");
-      const scope = args.scope || null;
-      const treeJson = run(`swift ${shq(script)} ${depth}`, { timeout: 15000 });
+      const treeJson = run(`swift ${shq(script)} ${depth}`, { timeout: 30000 });
+      let tree = null;
       try {
-        const issues = [];
-        let totalScanned = 0, totalSkipped = 0;
-        function auditNode(node, path = "") {
-          const loc = path ? `${path} > ${node.role}` : node.role;
-          const w = node.frame?.w || 0, h = node.frame?.h || 0;
-          const isInteractive = ["AXButton", "AXLink", "AXTextField", "AXTextArea", "AXCheckBox", "AXRadioButton", "AXSlider", "AXSwitch", "AXTab"].includes(node.role);
-          if (isInteractive) {
-            // Scope filter: skip elements outside scope
-            if (scope && node.identifier && !node.identifier.startsWith(scope)) { totalSkipped++; if (node.children) node.children.forEach(c => auditNode(c, loc)); return; }
-            if (scope && !node.identifier) { /* no identifier = can't scope, still audit */ }
-            totalScanned++;
-            if (!node.title && !node.description && !node.value) issues.push({ severity: "critical", issue: "Missing accessibility label", element: loc, identifier: node.identifier, frame: node.frame });
-            if (!node.identifier) issues.push({ severity: "warning", issue: "Missing accessibility identifier (UI testing)", element: loc });
-            if (w > 0 && h > 0 && (w < 44 || h < 44)) issues.push({ severity: "important", issue: `Tap target too small: ${w.toFixed(0)}x${h.toFixed(0)}pt (min 44x44)`, element: loc, identifier: node.identifier, frame: node.frame });
-          }
-          if (node.children) node.children.forEach(c => auditNode(c, loc));
-        }
-        const tree = JSON.parse(treeJson);
-        auditNode(tree);
-        return JSON.stringify({ scope: scope || "all", elements_scanned: totalScanned, elements_skipped: totalSkipped, total_issues: issues.length, critical: issues.filter(i => i.severity === "critical").length, important: issues.filter(i => i.severity === "important").length, warning: issues.filter(i => i.severity === "warning").length, issues }, null, 2);
-      } catch (e) { return `ERROR parsing UI tree: ${e.message}\n\nRaw output:\n${treeJson?.substring(0, 500)}`; }
+        tree = JSON.parse(treeJson);
+      } catch {
+        tree = null;
+      }
+      const r = auditIosTree({ tree, scope: args.scope || null });
+      return JSON.stringify({
+        scope: r.scope,
+        measurable: r.measurable,
+        reason: r.reason,
+        elements_scanned: r.elementsScanned,
+        elements_skipped: r.elementsSkipped,
+        total_issues: r.totalIssues,
+        critical: r.critical,
+        important: r.important,
+        warning: r.warning,
+        issues: r.issues,
+      }, null, 2);
     }
-    // `simctl keychain <device> biometric-enroll` / `biometric-match` do not
-    // exist -  `keychain` supports only add-root-cert/add-cert/reset. The only
-    // available lever is the (undocumented) BiometricKit notification, which is
-    // posted via notifyutil inside the simulator. notifyutil exits 0 even when
-    // it cannot set or post the name, so its output has to be inspected: a
-    // "Failed with code N" line means the notification did not land, and that
-    // must be reported as a failure rather than as a simulated success.
     case "ios_biometric": {
       const d = iosDevice(args.device_id);
       const action = args.match ? "match" : "nomatch";
@@ -789,6 +800,42 @@ async function handleIOS(name, args, ctx = {}) {
       const report = JSON.stringify({ passed, diff_pct: parseFloat(diffPct.toFixed(4)), diff_pixels: diffPixels, total_pixels: total, threshold, max_diff_pct: maxPct, baseline: args.baseline, current: args.current, diff_image: diffImagePath }, null, 2);
       return diffImagePath ? fileResult(report, diffImagePath) : report;
     }
+    case "ios_leaks": {
+      let pid = Number.isInteger(args.pid) ? args.pid : null;
+      if (!pid && args.bundle_id) {
+        const d = iosDevice(args.device_id);
+        const out = run(`xcrun simctl spawn ${d} launchctl list 2>/dev/null | grep ${shq(sanitizeId(args.bundle_id))}`);
+        const m = out && out.match(/^(\d+)\s/m);
+        if (!m) return `ERROR: no running process for ${args.bundle_id} on the booted simulator; launch it first`;
+        pid = parseInt(m[1], 10);
+      }
+      if (!pid) return "ERROR: pass pid or bundle_id";
+
+      const mode = args.mode || "snapshot";
+      const graphOut = args.output_graph ? ` --outputGraph=${shq(args.output_graph)}` : "";
+      if (mode === "diff") {
+        if (!args.baseline_graph) return "ERROR: mode=diff needs baseline_graph, the memory graph saved by an earlier call";
+        if (!existsSync(args.baseline_graph)) return `ERROR: baseline graph not found at ${args.baseline_graph}`;
+      }
+      const diffArg = mode === "diff" ? ` --diffFrom=${shq(args.baseline_graph)}` : "";
+      // leaks exits 1 when it FINDS leaks, so a non-zero status is a result and
+      // not a failure. Everything below is decided from the parsed output.
+      const raw = runCapture(`leaks ${pid}${diffArg}${graphOut} 2>&1`, { timeout: 120000 });
+      const parsed = parseLeaksOutput(raw);
+      return JSON.stringify({
+        pid,
+        mode,
+        measurable: parsed.measurable,
+        reason: parsed.reason,
+        leak_count: parsed.leakCount,
+        leaked_bytes: parsed.leakedBytes,
+        nodes_malloced: parsed.nodesMalloced,
+        malloced_kb: parsed.mallocedKb,
+        root_leaks: parsed.roots.slice(0, 50),
+        root_leaks_truncated: parsed.roots.length > 50 ? parsed.roots.length - 50 : 0,
+        graph_saved_to: args.output_graph || null,
+      }, null, 2);
+    }
     case "ios_list_crashes": {
       const dir = join(homedir(), "Library", "Logs", "DiagnosticReports");
       if (!existsSync(dir)) return JSON.stringify({ dir, count: 0, reports: [] }, null, 2);
@@ -848,6 +895,7 @@ const ANDROID_TOOLS = [
   { 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_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"] } },
   { name: "android_list_crashes", description: "Dump the Android crash log buffer (`adb logcat -b crash -d`), tail-bounded. Empty output means no crashes since the buffer was last cleared.", inputSchema: { type: "object", properties: { lines: { type: "number", description: "Max lines returned, from the end (default 200)" }, device_id: { type: "string" } } } },
   { name: "android_set_orientation", description: "Rotate the Android screen to portrait or landscape. Disables accelerometer rotation and pins user_rotation, so the device stays put until rotation is re-enabled. Accounts for the device's natural orientation (detected via wm size), so landscape-natural tablets rotate correctly too. No iOS counterpart: simctl exposes no rotation lever.", inputSchema: { type: "object", properties: { orientation: { type: "string", enum: ["portrait", "landscape"] }, device_id: { type: "string" } }, required: ["orientation"] } },
 ];
@@ -1004,34 +1052,20 @@ async function handleAndroid(name, args, ctx = {}) {
       const f = join(SCREENSHOT_DIR, `a11y_${Date.now()}.xml`);
       run(`adb ${df} pull /sdcard/_mcp_a11y.xml ${shq(f)}`);
       run(`adb ${df} shell rm /sdcard/_mcp_a11y.xml`);
-      if (!existsSync(f)) return "ERROR: UI dump failed";
-      const xml = readFileSync(f, "utf-8");
-      const scope = args.scope || null;
-      const issues = [];
-      let totalScanned = 0, totalSkipped = 0;
-      const nodeRegex = /<node[^>]*>/g;
-      let match;
-      while ((match = nodeRegex.exec(xml)) !== null) {
-        const node = match[0];
-        const cls = node.match(/class="([^"]*)"/)?.[1] || "";
-        const desc = node.match(/content-desc="([^"]*)"/)?.[1] || "";
-        const rid = node.match(/resource-id="([^"]*)"/)?.[1] || "";
-        const text = node.match(/text="([^"]*)"/)?.[1] || "";
-        const clickable = node.includes('clickable="true"');
-        const bounds = node.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
-        if (clickable) {
-          if (scope && rid && !rid.includes(scope)) { totalSkipped++; continue; }
-          totalScanned++;
-          if (!desc && !text) issues.push({ severity: "critical", issue: "Missing contentDescription", element: cls, resourceId: rid });
-          if (!rid) issues.push({ severity: "warning", issue: "Missing resource-id (UI testing)", element: cls });
-          if (bounds) {
-            const w = parseInt(bounds[3]) - parseInt(bounds[1]);
-            const h = parseInt(bounds[4]) - parseInt(bounds[2]);
-            if (w < 48 || h < 48) issues.push({ severity: "important", issue: `Touch target too small: ${w}x${h}dp (min 48x48)`, element: cls, resourceId: rid });
-          }
-        }
-      }
-      return JSON.stringify({ scope: scope || "all", elements_scanned: totalScanned, elements_skipped: totalSkipped, total_issues: issues.length, critical: issues.filter(i => i.severity === "critical").length, important: issues.filter(i => i.severity === "important").length, warning: issues.filter(i => i.severity === "warning").length, issues }, null, 2);
+      const xml = existsSync(f) ? readFileSync(f, "utf-8") : "";
+      const r = auditAndroidDump({ xml, scope: args.scope || null });
+      return JSON.stringify({
+        scope: r.scope,
+        measurable: r.measurable,
+        reason: r.reason,
+        elements_scanned: r.elementsScanned,
+        elements_skipped: r.elementsSkipped,
+        total_issues: r.totalIssues,
+        critical: r.critical,
+        important: r.important,
+        warning: r.warning,
+        issues: r.issues,
+      }, null, 2);
     }
     case "android_launch_time": {
       run(`adb ${df} shell am force-stop ${sanitizeId(args.package_name)}`);
@@ -1097,6 +1131,33 @@ async function handleAndroid(name, args, ctx = {}) {
       const warnings = findings.filter(f => f.status === "warning").length;
       return JSON.stringify({ apk: p, summary: { critical, warnings, passed: findings.filter(f => f.status === "pass").length, total_checks: findings.length }, verdict: critical > 0 ? "FAIL - critical issues must be fixed" : warnings > 0 ? "WARN - review warnings" : "PASS - ready for Play Store", findings }, null, 2);
     }
+    case "android_meminfo": {
+      const pkg = sanitizeId(args.package_name);
+      const raw = runCapture(`adb ${df} shell dumpsys meminfo ${pkg} 2>&1`, { timeout: 30000 });
+      const snapshot = parseMeminfoOutput(raw);
+      const mode = args.mode || "snapshot";
+      if (mode === "diff") {
+        if (!args.baseline_json) return "ERROR: mode=diff needs baseline_json, the JSON returned by an earlier snapshot call";
+        let before;
+        try {
+          before = JSON.parse(args.baseline_json);
+        } catch {
+          return "ERROR: baseline_json is not valid JSON";
+        }
+        const d = diffMeminfo(before, snapshot);
+        return JSON.stringify({ package: args.package_name, mode, comparable: d.comparable, reason: d.reason, delta_kb: d.deltaKb, total_pss_delta_kb: d.totalPssDeltaKb, after: snapshot }, null, 2);
+      }
+      return JSON.stringify({
+        package: args.package_name,
+        mode,
+        measurable: snapshot.measurable,
+        reason: snapshot.reason,
+        pss_kb: snapshot.pss,
+        total_pss_kb: snapshot.totalPssKb,
+        total_rss_kb: snapshot.totalRssKb,
+        total_swap_kb: snapshot.totalSwapKb,
+      }, null, 2);
+    }
     case "android_list_crashes": {
       const lines = args.lines !== undefined ? num(args.lines, "lines") : 200;
       const out = run(`adb ${df} logcat -b crash -d | tail -${lines}`);
@@ -1472,17 +1533,23 @@ const ISSUE_LIST = {
   },
 };
 
+// The counts are nullable on purpose. An audit that could not read the tree
+// reports null, never 0: a count of zero is a measurement, and none was taken.
+// `measurable` is the field to branch on; the counts are only meaningful when
+// it is true.
 const ACCESSIBILITY_AUDIT_SCHEMA = {
   type: "object",
-  required: ["total_issues", "critical", "important", "warning", "issues"],
+  required: ["measurable", "total_issues", "critical", "important", "warning", "issues"],
   properties: {
     scope: { type: "string" },
+    measurable: { type: "boolean" },
+    reason: { type: ["string", "null"] },
     elements_scanned: { type: "integer" },
     elements_skipped: { type: "integer" },
-    total_issues: { type: "integer" },
-    critical: { type: "integer" },
-    important: { type: "integer" },
-    warning: { type: "integer" },
+    total_issues: { type: ["integer", "null"] },
+    critical: { type: ["integer", "null"] },
+    important: { type: ["integer", "null"] },
+    warning: { type: ["integer", "null"] },
     issues: ISSUE_LIST,
   },
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mmerterden/multi-agent-toolkit-mcp",
-  "version": "3.2.0",
-  "description": "MCP server for iOS Simulator, Android Emulator and headless web control. 84 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.",
+  "version": "3.4.0",
+  "description": "MCP server for iOS Simulator, Android Emulator and headless web control. 86 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",
   "bin": {
@@ -10,7 +10,7 @@
   },
   "scripts": {
     "start": "node index.js",
-    "test": "node --test tools/design-check/__tests__/design-check.test.mjs tools/design-check/__tests__/plan-determinism.test.mjs tools/ios-app-store-audit/__tests__/app-store-audit.test.mjs tools/ios-testflight/__tests__/testflight.test.mjs tools/ui-inspect/__tests__/ui-inspect.test.mjs tools/crash-logs/__tests__/crash-logs.test.mjs tools/launch-time/__tests__/launch-time.test.mjs tools/offload/__tests__/offload.test.mjs __tests__/server-tools.test.mjs __tests__/injection.test.mjs",
+    "test": "node --test tools/design-check/__tests__/design-check.test.mjs tools/design-check/__tests__/plan-determinism.test.mjs tools/ios-app-store-audit/__tests__/app-store-audit.test.mjs tools/ios-testflight/__tests__/testflight.test.mjs tools/ui-inspect/__tests__/ui-inspect.test.mjs tools/crash-logs/__tests__/crash-logs.test.mjs tools/a11y/__tests__/a11y.test.mjs tools/launch-time/__tests__/launch-time.test.mjs tools/memory/__tests__/memory.test.mjs tools/offload/__tests__/offload.test.mjs __tests__/server-tools.test.mjs __tests__/injection.test.mjs",
     "gates": "bash scripts/gates.sh"
   },
   "keywords": [

package/tools/a11y/index.js

@@ -0,0 +1,236 @@
+/**
+ * a11y - accessibility audit scoring, split out of index.js so it can be tested.
+ *
+ * The audits used to return a full clean table for a tree they never read:
+ * `elements_scanned: 0, total_issues: 0, critical: 0, important: 0, warning: 0`.
+ * On iOS the tree comes from Simulator.app's host accessibility bridge, and that
+ * bridge stays empty until the Simulator window has been activated at least
+ * once, verified on a live simulator: 1 node before activation, 28 after. So
+ * "no issues" and "never looked" were the same answer, and the first is the one
+ * a reader believes.
+ *
+ * Every result therefore carries `measurable` and, when false, a `reason`. A
+ * result that could not be measured reports `totalIssues: null`, never 0.
+ */
+
+const IOS_INTERACTIVE_ROLES = new Set([
+  "AXButton",
+  "AXLink",
+  "AXTextField",
+  "AXTextArea",
+  "AXCheckBox",
+  "AXRadioButton",
+  "AXSlider",
+  "AXPopUpButton",
+  "AXMenuButton",
+  "AXSwitch",
+]);
+
+const IOS_MIN_TAP_PT = 44;
+const ANDROID_MIN_TAP_DP = 48;
+
+/**
+ * An accessibility tree with no children is not a screen without controls, it
+ * is a tree that was never populated. Callers must not score it.
+ *
+ * @param {object|null} tree - parsed ui-tree-dumper output
+ * @returns {boolean}
+ */
+export function isDegenerateTree(tree) {
+  if (!tree || typeof tree !== "object") return true;
+  if (tree.error) return true;
+  const kids = Array.isArray(tree.children) ? tree.children : [];
+  return kids.length === 0;
+}
+
+/**
+ * The device screen inside Simulator.app's window.
+ *
+ * The dumped window holds the simulator's own chrome as direct children -
+ * hardware buttons (Action, Volume Up, Sleep/Wake), the toolbar, the title
+ * text - and the iOS app underneath a single large AXGroup. Verified on a live
+ * simulator: seven chrome children beside one 402x873 AXGroup with the app in
+ * it. Auditing the window whole reports Apple's 17x35pt Volume button as an
+ * app tap-target violation, which is a false positive in exactly the place an
+ * accessibility report has to be trusted.
+ *
+ * @param {object} tree
+ * @returns {object|null} the screen subtree, or null when it cannot be found
+ */
+export function deviceScreenSubtree(tree) {
+  if (!tree || tree.role !== "AXWindow") return tree || null;
+  const groups = (tree.children || []).filter((c) => c && c.role === "AXGroup");
+  if (groups.length === 0) return null;
+  const area = (n) => (n.frame?.w || 0) * (n.frame?.h || 0);
+  return groups.reduce((best, c) => (area(c) > area(best) ? c : best), groups[0]);
+}
+
+/**
+ * @param {object} params
+ * @param {object|null} params.tree - parsed ui-tree-dumper output
+ * @param {string|null} [params.scope] - only audit identifiers with this prefix
+ * @returns {{measurable: boolean, reason: string|null, scope: string,
+ *            elementsScanned: number, elementsSkipped: number,
+ *            totalIssues: number|null, critical: number|null,
+ *            important: number|null, warning: number|null, issues: object[]}}
+ */
+export function auditIosTree({ tree, scope = null }) {
+  if (isDegenerateTree(tree)) {
+    return unmeasurable(
+      scope,
+      tree && tree.error
+        ? String(tree.error)
+        : "the accessibility tree came back empty; open Simulator.app and bring its window to the front, then retry - the host bridge does not populate until the window has been activated once",
+    );
+  }
+
+  const screen = deviceScreenSubtree(tree);
+  if (!screen) {
+    return unmeasurable(
+      scope,
+      "the window held no device screen group; the simulator may still be starting up",
+    );
+  }
+
+  const issues = [];
+  let elementsScanned = 0;
+  let elementsSkipped = 0;
+
+  const visit = (node, path = "") => {
+    if (!node || typeof node !== "object") return;
+    const loc = path ? `${path} > ${node.role}` : node.role;
+    const w = node.frame?.w || 0;
+    const h = node.frame?.h || 0;
+
+    if (IOS_INTERACTIVE_ROLES.has(node.role)) {
+      if (scope && node.identifier && !node.identifier.startsWith(scope)) {
+        elementsSkipped++;
+        (node.children || []).forEach((c) => visit(c, loc));
+        return;
+      }
+      elementsScanned++;
+      if (!node.title && !node.description && !node.value) {
+        issues.push({ severity: "critical", issue: "Missing accessibility label", element: loc, identifier: node.identifier || null });
+      }
+      if (!node.identifier) {
+        issues.push({ severity: "warning", issue: "Missing accessibility identifier (UI testing)", element: loc });
+      }
+      if (w > 0 && h > 0 && (w < IOS_MIN_TAP_PT || h < IOS_MIN_TAP_PT)) {
+        issues.push({ severity: "important", issue: `Tap target too small: ${Math.round(w)}x${Math.round(h)}pt (min ${IOS_MIN_TAP_PT}x${IOS_MIN_TAP_PT})`, element: loc, identifier: node.identifier || null });
+      }
+    }
+    (node.children || []).forEach((c) => visit(c, loc));
+  };
+  visit(screen);
+
+  // A populated window whose interactive elements were all filtered out is a
+  // scope that matched nothing, not a clean screen.
+  if (elementsScanned === 0) {
+    return unmeasurable(
+      scope,
+      scope
+        ? `no interactive element matched scope "${scope}"`
+        : "the tree was readable but held no interactive elements to audit",
+      elementsSkipped,
+    );
+  }
+
+  return {
+    measurable: true,
+    reason: null,
+    scope: scope || "all",
+    elementsScanned,
+    elementsSkipped,
+    ...tally(issues),
+  };
+}
+
+/**
+ * @param {object} params
+ * @param {string} params.xml - uiautomator dump output
+ * @param {string|null} [params.scope] - only audit resource-ids containing this
+ * @returns {object} same shape as auditIosTree
+ */
+export function auditAndroidDump({ xml, scope = null }) {
+  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");
+  }
+
+  const issues = [];
+  let elementsScanned = 0;
+  let elementsSkipped = 0;
+
+  for (const match of text.matchAll(/<node[^>]*>/g)) {
+    const node = match[0];
+    const attr = (name) => node.match(new RegExp(`${name}="([^"]*)"`))?.[1] || "";
+    if (!node.includes('clickable="true"')) continue;
+
+    const cls = attr("class");
+    const desc = attr("content-desc");
+    const rid = attr("resource-id");
+    const label = attr("text");
+
+    if (scope && rid && !rid.includes(scope)) {
+      elementsSkipped++;
+      continue;
+    }
+    elementsScanned++;
+
+    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);
+      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 });
+      }
+    }
+  }
+
+  if (elementsScanned === 0) {
+    return unmeasurable(
+      scope,
+      scope ? `no clickable element matched scope "${scope}"` : "the dump was readable but held no clickable elements to audit",
+      elementsSkipped,
+    );
+  }
+
+  return {
+    measurable: true,
+    reason: null,
+    scope: scope || "all",
+    elementsScanned,
+    elementsSkipped,
+    ...tally(issues),
+  };
+}
+
+function tally(issues) {
+  const by = (s) => issues.filter((i) => i.severity === s).length;
+  return {
+    totalIssues: issues.length,
+    critical: by("critical"),
+    important: by("important"),
+    warning: by("warning"),
+    issues,
+  };
+}
+
+function unmeasurable(scope, reason, elementsSkipped = 0) {
+  return {
+    measurable: false,
+    reason,
+    scope: scope || "all",
+    elementsScanned: 0,
+    elementsSkipped,
+    // null rather than 0: a count of zero is a measurement, and none was taken.
+    totalIssues: null,
+    critical: null,
+    important: null,
+    warning: null,
+    issues: [],
+  };
+}

package/tools/memory/index.js

@@ -0,0 +1,152 @@
+/**
+ * memory - parsers for `leaks` (iOS/macOS) and `dumpsys meminfo` (Android).
+ *
+ * Lives here rather than inline in index.js because index.js connects its
+ * transport at import time and cannot be loaded by a test.
+ */
+
+/**
+ * Parse `leaks <pid>` output.
+ *
+ * The exit code alone cannot be trusted, verified against leaks on macOS:
+ *
+ *   no leaks            exit 0, summary "Process N: 0 leaks for 0 total leaked bytes."
+ *   leaks found         exit 1, summary "Process N: 198 leaks for 811008 total leaked bytes."
+ *   target not debuggable  exit 0, a "not debuggable" line, and NO summary at all
+ *
+ * So exit 1 is a finding rather than a failure, and exit 0 is either a clean
+ * run or a run that never measured anything. A wrapper that reads the exit code
+ * reports the third case as clean, which is the worst possible answer: a green
+ * result from a process nothing inspected. `measurable` is therefore derived
+ * from the presence of the summary line, never from the exit status.
+ *
+ * A process is not debuggable when it lacks the get-task-allow entitlement.
+ * Debug builds carry it; Apple's own signed apps do not.
+ *
+ * @param {string} raw - stdout+stderr of `leaks`
+ * @returns {{measurable: boolean, reason: string|null, leakCount: number|null,
+ *            leakedBytes: number|null, nodesMalloced: number|null,
+ *            mallocedKb: number|null, roots: string[]}}
+ */
+export function parseLeaksOutput(raw) {
+  const text = typeof raw === "string" ? raw : "";
+
+  const summary = text.match(/Process\s+\d+:\s+(\d+)\s+leaks?\s+for\s+(\d+)\s+total leaked bytes/);
+  const malloced = text.match(/Process\s+\d+:\s+(\d+)\s+nodes malloced for\s+(\d+)\s+KB/);
+
+  if (!summary) {
+    // Order matters: report the specific reason when leaks named one, so the
+    // caller can tell "I could not look" from "I looked and found nothing".
+    const notDebuggable = /is not debuggable/.test(text);
+    const noSuchProcess = /(No such process|Cannot examine process|does not exist)/i.test(text);
+    return {
+      measurable: false,
+      reason: notDebuggable
+        ? "target is not debuggable (no get-task-allow entitlement); build and run a Debug configuration"
+        : noSuchProcess
+          ? "no such process"
+          : "leaks produced no summary line",
+      leakCount: null,
+      leakedBytes: null,
+      nodesMalloced: malloced ? parseInt(malloced[1], 10) : null,
+      mallocedKb: malloced ? parseInt(malloced[2], 10) : null,
+      roots: [],
+    };
+  }
+
+  const roots = (text.match(/^\s*\d+\s+\([^)]*\)\s+ROOT LEAK:.*$/gm) || []).map((l) => l.trim());
+
+  return {
+    measurable: true,
+    reason: null,
+    leakCount: parseInt(summary[1], 10),
+    leakedBytes: parseInt(summary[2], 10),
+    nodesMalloced: malloced ? parseInt(malloced[1], 10) : null,
+    mallocedKb: malloced ? parseInt(malloced[2], 10) : null,
+    roots,
+  };
+}
+
+const MEMINFO_ROWS = [
+  ["Java Heap", "javaHeapKb"],
+  ["Native Heap", "nativeHeapKb"],
+  ["Code", "codeKb"],
+  ["Stack", "stackKb"],
+  ["Graphics", "graphicsKb"],
+  ["Private Other", "privateOtherKb"],
+  ["System", "systemKb"],
+];
+
+/**
+ * Parse the App Summary block of `adb shell dumpsys meminfo <package>`.
+ *
+ * Every number in meminfo is KB. The App Summary block is the part worth
+ * reading for a leak signal: growth in Java Heap or Native Heap across two
+ * 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.
+ *
+ * @param {string} raw
+ * @returns {{measurable: boolean, reason: string|null, pss: object, totalPssKb: number|null,
+ *            totalRssKb: number|null, totalSwapKb: number|null}}
+ */
+export function parseMeminfoOutput(raw) {
+  const text = typeof raw === "string" ? raw : "";
+
+  if (/No process found for/i.test(text)) {
+    return { measurable: false, reason: "no running process for that package", pss: {}, totalPssKb: null, totalRssKb: null, totalSwapKb: null };
+  }
+
+  const pss = {};
+  let found = 0;
+  for (const [label, key] of MEMINFO_ROWS) {
+    const m = text.match(new RegExp(`^\\s*${label}:\\s+(\\d+)`, "mi"));
+    if (m) {
+      pss[key] = parseInt(m[1], 10);
+      found++;
+    }
+  }
+
+  const num = (re) => {
+    const m = text.match(re);
+    return m ? parseInt(m[1], 10) : null;
+  };
+  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);
+
+  if (found === 0 && totalPssKb === null) {
+    return { measurable: false, reason: "no App Summary block in the dumpsys output", pss: {}, totalPssKb: null, totalRssKb: null, totalSwapKb: null };
+  }
+
+  return { measurable: true, reason: null, pss, totalPssKb, totalRssKb, totalSwapKb };
+}
+
+/**
+ * Difference between two meminfo snapshots, in KB.
+ *
+ * Only keys present in both are compared; a key missing from either side is
+ * absent from the result rather than counted as zero growth.
+ *
+ * @param {object} before - parseMeminfoOutput result
+ * @param {object} after - parseMeminfoOutput result
+ * @returns {{comparable: boolean, reason: string|null, deltaKb: object, totalPssDeltaKb: number|null}}
+ */
+export function diffMeminfo(before, after) {
+  if (!before?.measurable || !after?.measurable) {
+    return { comparable: false, reason: "one of the snapshots was not measurable", deltaKb: {}, totalPssDeltaKb: null };
+  }
+  const deltaKb = {};
+  for (const key of Object.keys(after.pss)) {
+    if (typeof before.pss[key] === "number") deltaKb[key] = after.pss[key] - before.pss[key];
+  }
+  const totalPssDeltaKb =
+    typeof before.totalPssKb === "number" && typeof after.totalPssKb === "number"
+      ? after.totalPssKb - before.totalPssKb
+      : null;
+  return { comparable: true, reason: null, deltaKb, totalPssDeltaKb };
+}

package/ui-tree-dumper.swift

@@ -86,10 +86,22 @@ func dumpElement(_ element: AXUIElement, depth: Int, maxDepth: Int) -> AXNode? {
     )
 }
 
+// The host accessibility bridge does not populate the iOS app's elements until
+// the Simulator window has been activated at least once. Measured on a live
+// simulator: 1 node before activation, 28 after, and it stays populated once
+// the window has been backgrounded again. Without this the tree comes back
+// holding only the window, which reads as a screen with no controls.
+func activateSimulator(_ app: NSRunningApplication) {
+    if app.isActive { return }
+    app.activate(options: [])
+    Thread.sleep(forTimeInterval: 1.2)
+}
+
 func findSimulatorWindow() -> AXUIElement? {
     let apps = NSWorkspace.shared.runningApplications
     for app in apps {
         if app.bundleIdentifier == "com.apple.iphonesimulator" {
+            activateSimulator(app)
             let axApp = AXUIElementCreateApplication(app.processIdentifier)
             var windows: AnyObject?
             AXUIElementCopyAttributeValue(axApp, kAXWindowsAttribute as CFString, &windows)
@@ -105,7 +117,7 @@ func findSimulatorWindow() -> AXUIElement? {
 let maxDepth = CommandLine.arguments.count > 1 ? Int(CommandLine.arguments[1]) ?? 10 : 10
 
 guard let simWindow = findSimulatorWindow() else {
-    let error = ["error": "Simulator not running or no window found"]
+    let error = ["error": "Simulator.app is not running or has no window. Booting a device with simctl is not enough - the accessibility bridge lives in the Simulator UI app. Run: open -a Simulator"]
     let data = try! JSONSerialization.data(withJSONObject: error)
     FileHandle.standardOutput.write(data)
     exit(1)