# io.github.fullread/deepadb (npm · deepadb) Full-featured ADB MCP server — 204 tools across 45 modules, from UI to baseband. - Trust score: 71/100 (medium) - Change this week: +46 - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-08-03 ## Components - npm · `deepadb`: 71/100 (this document), [markdown](https://verifymcp.io/servers/fullread-deepadb/deepadb.md), [page](https://verifymcp.io/servers/fullread-deepadb/deepadb) ## Channel facts - Registry: `npm` - Package: `deepadb` - Version: `1.1.3` - Transport: `stdio` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-08-03. - **Supply Chain Security**: 86/100 - No malware found by supply-chain analysis. - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree. - No install/post-install scripts declared. - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree. - **Provenance & Transparency**: 45/100 - Source repository is publicly reachable at the declared URL. - Provenance check failed: no build-provenance attestation is published. - Clear OSI-approved license (Apache-2.0). - Actively maintained (last published 65 days ago). - Disclosure check failed: no security disclosure policy was found in the source repository. - **Schema Quality & AI Usability**: 84/100 - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name). - AI-judged instruction clarity (good). - Tool/resource definitions use about 19081 tokens (~93/item across 205 items; 204 tools + 1 resources), lean. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 27/100 - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### Claude ```bash claude mcp add fullread-deepadb -- npx -y deepadb ``` ### Codex ```bash codex mcp add fullread-deepadb -- npx -y deepadb ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "fullread-deepadb": { "type": "local", "command": [ "npx", "-y", "deepadb" ], "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add fullread-deepadb --command npx --arg -y --arg deepadb ``` ### Hermes ```yaml mcp_servers: fullread-deepadb: command: "npx" args: ["-y", "deepadb"] ``` ### Other ```json { "mcpServers": { "fullread-deepadb": { "command": "npx", "args": [ "-y", "deepadb" ] } } } ``` ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-08-03 (score 71, +1) No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-08-02 (score 70, +18) - [security regression] Provenance: unverified → fail - [security improvement] Known CVEs: unverified → partial - [security improvement] Install scripts: unverified → pass - [functional improvement] Maintenance: unverified → pass - [functional improvement] Dependency health: unverified → partial - [functional improvement] Stability: unverified → 0.23 - [functional improvement] License: unverified → pass - [functional] Licence: Apache-2.0 ### 2026-07-31 (score 52, +10) - [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server ### 2026-07-30 (score 42, −40) - [security regression] Install scripts: pass → unverified - [security regression] Known CVEs: partial → unverified - [security regression] Malware scan: pass → unverified - [security regression] Provenance: fail → unverified - [functional regression] License: pass → unverified - [functional regression] Dependency health: partial → unverified - [functional regression] Maintenance: pass → unverified - [functional] Licence: Apache-2.0 ### 2026-07-28 (score 82, +57) - [security regression] Provenance: unverified → fail - [security improvement] Install scripts: unverified → pass - [security improvement] Known CVEs: unverified → partial - [functional improvement] Tool coverage: unverified → 100 - [functional improvement] Maintenance: unverified → pass - [functional improvement] Schema quality: unverified → 100 - [functional improvement] License: unverified → pass - [functional] First check of Schema quality: good - [functional] First check of Schema quality: pass - [functional] First check of Tool coverage: 100 - [functional] First check of Schema quality: fail - [functional] Licence: Apache-2.0 ### 2026-07-27 (score 25) First indexed and scored. ## MCP tools (204) ### `adb_devices` (~23 tokens) List all connected Android devices with their state, model, and product info ### `adb_device_info` (~43 tokens) Get detailed properties for a connected device (model, OS version, build, etc.) Input parameters: - `device` (string): Device serial (auto-selects if only one connected) ### `adb_getprop` (~56 tokens) Get a specific Android system property, or all properties if no key given Input parameters: - `device` (string): Device serial - `key` (string): Property key (e.g., 'ro.build.version.sdk'). Omit for all. ### `adb_shell` (~61 tokens) Execute a shell command on the Android device. Returns stdout and stderr. Input parameters: - `command` (string, required): Shell command to execute on the device - `device` (string): Device serial - `timeout` (number): Timeout in milliseconds (1s-10min) ### `adb_root_shell` (~42 tokens) Execute a command as root via su. Requires rooted device. Input parameters: - `command` (string, required): Command to run as root - `device` (string): Device serial ### `adb_install` (~75 tokens) Install an APK on the device. Provide the full local path to the APK file. Input parameters: - `apkPath` (string, required): Local filesystem path to the APK file - `device` (string): Device serial - `downgrade` (boolean): Allow version downgrade (-d flag) - `replace` (boolean): Replace existing app (-r flag) ### `adb_uninstall` (~60 tokens) Uninstall a package from the device Input parameters: - `device` (string): Device serial - `keepData` (boolean): Keep app data and cache (-k flag) - `packageName` (string, required): Package name (e.g., 'com.example.app') ### `adb_list_packages` (~57 tokens) List installed packages. Supports filtering by name. Input parameters: - `device` (string): Device serial - `filter` (string): Filter packages containing this string - `type` (string): Show all, system-only, or third-party-only packages ### `adb_package_info` (~50 tokens) Get detailed info about an installed package (version, permissions, paths) Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name (e.g., 'com.example.app') ### `adb_clear_data` (~123 tokens) Clear all data for a package (equivalent to clearing storage in settings). DESTRUCTIVE — irreversibly wipes all app data, cache, databases, shared preferences, and login state. AP5 fix: requires `confirm: ` to proceed. Input parameters: - `confirm` (string): Must equal packageName to confirm the destructive operation. AP5 fix: prevents accidental data loss from misclicks/mistyped invocations. - `device` (string): Device serial - `packageName` (string, required): Package name (e.g., 'com.example.app') ### `adb_grant_permission` (~65 tokens) Grant a runtime permission to a package Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name (e.g., 'com.example.app') - `permission` (string, required): Full permission string (e.g., 'android.permission.READ_PHONE_STATE') ### `adb_revoke_permission` (~79 tokens) Revoke a runtime permission from a package. Useful for resetting permission state to test first-run flows or denial handling. Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name (e.g., 'com.example.app') - `permission` (string, required): Full permission string (e.g., 'android.permission.CAMERA') ### `adb_list_permissions` (~96 tokens) List permissions declared and granted for a package. Parses the package dump to show install-time and runtime permissions with their current grant state. Useful for auditing permission state before and after grant/revoke operations. Input parameters: - `device` (string): Device serial - `filter` (string): Show all permissions, only granted, or only denied (default: all) - `packageName` (string, required): Package name (e.g., 'com.example.app') ### `adb_force_stop` (~48 tokens) Force-stop an app immediately. The most common debugging action. Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name (e.g., 'com.example.app') ### `adb_start_app` (~52 tokens) Launch an app by package name (resolves and starts the default launcher activity) Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name (e.g., 'com.example.app') ### `adb_restart_app` (~78 tokens) Force-stop then re-launch an app. The most frequent debugging workflow in a single call. Input parameters: - `delayMs` (number): Delay between stop and start in ms (0-10000, default 500) - `device` (string): Device serial - `packageName` (string, required): Package name (e.g., 'com.example.app') ### `adb_resolve_intents` (~49 tokens) Discover all activities, services, and receivers registered by a package with their intent filters Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name to query ### `adb_push` (~74 tokens) Push a local file to the device filesystem. Pre-flight checks: hard-blocked kernel paths, filesystem type warnings, symlink resolution, and destination storage availability. Input parameters: - `device` (string): Device serial - `localPath` (string, required): Local file path to push - `remotePath` (string, required): Destination path on device ### `adb_pull` (~55 tokens) Pull a file from the device to local filesystem Input parameters: - `device` (string): Device serial - `localPath` (string): Local destination (defaults to temp dir) - `remotePath` (string, required): File path on the device ### `adb_ls` (~50 tokens) List files and directories on the device Input parameters: - `details` (boolean): Show detailed listing (ls -la) - `device` (string): Device serial - `path` (string): Directory path on device ### `adb_cat` (~53 tokens) Read a text file from the device Input parameters: - `device` (string): Device serial - `maxLines` (number): Maximum lines to return (1-10000) - `path` (string, required): File path on device ### `adb_file_write` (~123 tokens) Create or overwrite a text file on the device. Content is delivered via shell heredoc — suitable for config files, scripts, test fixtures, and small data files. For large or binary files, use adb_push instead. Shell buffer limits content to approximately 128KB. Input parameters: - `append` (boolean): Append to existing file instead of overwriting - `content` (string, required): File content to write - `device` (string): Device serial - `path` (string, required): Destination file path on device - `root` (boolean): Use root shell for protected paths ### `adb_find` (~281 tokens) Search for files on the device by name or pattern. Uses the find command with glob matching. Results are capped at maxResults to prevent unbounded output. Reports whether results were truncated. Input parameters: - `device` (string): Device serial - `maxDepth` (number): Maximum directory depth to search (1-50, default 10) - `maxResults` (number): Maximum results to return (1-10000, default 500) - `name` (string, required): Filename pattern (glob: *.apk, config.*, *test*) - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. - `root` (boolean): Use root shell for system paths - `searchPath` (string): Starting directory for search - `type` (string): Filter by type: file, directory, or any ### `adb_file_stat` (~75 tokens) Get detailed file metadata: size, permissions, ownership, timestamps (access/modify/change), SELinux security context, and file type. Read-only operation. Input parameters: - `device` (string): Device serial - `path` (string, required): File or directory path on device - `root` (boolean): Use root shell for protected paths ### `adb_file_checksum` (~95 tokens) Compute SHA-256 hash of a file on the device. Critical for firmware integrity verification, tamper detection, and comparing files across devices. Read-only operation. Reports file size alongside the hash. Input parameters: - `algorithm` (string): Hash algorithm (default: sha256) - `device` (string): Device serial - `path` (string, required): File path on device - `root` (boolean): Use root shell for protected paths ### `adb_mkdir` (~76 tokens) Create a directory on the device. Supports -p flag for creating parent directories. Input parameters: - `device` (string): Device serial - `parents` (boolean): Create parent directories as needed (-p flag, default true) - `path` (string, required): Directory path to create - `root` (boolean): Use root shell for protected paths ### `adb_rm` (~140 tokens) Delete a file or directory on the device. Recursive deletion uses depth-based protection: refuses at depth ≤ 2 from root (blocks rm -rf /system or /sdcard but allows /sdcard/project/build/). Symlinks are resolved before depth checks to prevent traversal bypasses. Hard-blocks /dev, /proc, /sys. For recursive deletes, reports a pre-flight file count. Input parameters: - `device` (string): Device serial - `path` (string, required): File or directory path to delete - `recursive` (boolean): Delete directory recursively (-rf). Depth-protected. - `root` (boolean): Use root shell for protected paths ### `adb_file_move` (~122 tokens) Move or rename a file/directory on the device. Moving FROM a system path is destructive — source depth protection refuses if source is at depth ≤ 1 from root. Symlinks resolved before checks. Cross-filesystem moves (e.g., /data → /sdcard) do a copy+delete internally and can be slow for large files. Input parameters: - `destination` (string, required): Destination path - `device` (string): Device serial - `root` (boolean): Use root shell for protected paths - `source` (string, required): Source file or directory path ### `adb_file_copy` (~103 tokens) Copy a file or directory on the device. Pre-flight checks source size against destination available space. Post-verifies the copy by comparing file sizes. For recursive directory copies, use -r flag. Input parameters: - `destination` (string, required): Destination path - `device` (string): Device serial - `recursive` (boolean): Copy directories recursively (-r) - `root` (boolean): Use root shell for protected paths - `source` (string, required): Source file or directory path ### `adb_file_chmod` (~155 tokens) Change file permissions on the device. Mode must be a valid octal string (e.g., '755', '644', '600'). Recursive mode uses depth-based protection: refuses at depth ≤ 2 from root. Note: sdcardfs/FUSE ignores Unix permissions — file access on /sdcard is controlled by Android's package ownership model. Input parameters: - `device` (string): Device serial - `mode` (string, required): Octal permission mode (e.g., '755', '644', '0600') - `path` (string, required): File or directory path - `recursive` (boolean): Apply recursively to directory contents. Depth-protected. - `root` (boolean): Use root shell (typically required for chmod) ### `adb_file_touch` (~122 tokens) Create an empty file or update timestamps. Three modes: create (touch non-existent path), update (set atime/mtime to now), or set explicit timestamp. On FAT32, timestamps have 2-second resolution. On tmpfs, timestamps are volatile. Input parameters: - `device` (string): Device serial - `path` (string, required): File path on device - `root` (boolean): Use root shell for protected paths - `timestamp` (string): Explicit timestamp in 'YYYY-MM-DD HH:MM:SS' format. Omit to use current time. ### `adb_file_fsinfo` (~102 tokens) Report filesystem details for any path: filesystem type, mount point, mount options, capacity, usage, read-only status, permission support, symlink support, max file size, timestamp resolution, encryption status, and SELinux context. Essential for understanding what operations are possible before attempting them. Input parameters: - `device` (string): Device serial - `path` (string, required): File or directory path to inspect - `root` (boolean): Use root shell for system paths ### `adb_file_chown` (~148 tokens) Change file ownership on the device. Requires root. Supports both numeric UID:GID (e.g., '10150:10150') and symbolic user:group (e.g., 'system:system'). Recursive mode uses depth-based protection: refuses at depth ≤ 2 from root. Note: sdcardfs/FAT32 ignore ownership changes. Input parameters: - `device` (string): Device serial - `owner` (string, required): Owner in user:group format (e.g., '0:0', 'system:system', '10150:10150') - `path` (string, required): File or directory path - `recursive` (boolean): Apply recursively to directory contents. Depth-protected. ### `adb_grep` (~336 tokens) Search file contents on the device by text pattern. Uses fixed-string matching by default (no regex injection risk). Supports recursive directory search with depth control and result capping. For filename searches, use adb_find instead. Input parameters: - `device` (string): Device serial - `filesWithMatches` (boolean): Show only filenames that contain matches, not the matching lines - `fixedString` (boolean): Use fixed-string matching (default: true, safer). Set false for regex. - `ignoreCase` (boolean): Case-insensitive search (default: true) - `maxDepth` (number): Maximum directory depth for recursive search (1-50, default 10) - `maxResults` (number): Maximum matching lines to return (1-10000, default 500) - `path` (string, required): File or directory path to search - `pattern` (string, required): Text pattern to search for - `recursive` (boolean): Search directories recursively - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. - `root` (boolean): Use root shell for protected paths ### `adb_file_replace` (~163 tokens) Find and replace text in a file on the device. Uses sed internally with proper escaping — exposes a safe interface without requiring sed syntax knowledge. Supports global replacement, line-targeted edits, and optional backup creation. Reports match count. Input parameters: - `backup` (boolean): Create a .bak backup before modifying - `device` (string): Device serial - `find` (string, required): Text to find (literal string, not regex) - `global` (boolean): Replace all occurrences (default: true). Set false for first-only. - `lineNumber` (number): Restrict replacement to a specific line number - `path` (string, required): File path on device - `replace` (string, required): Replacement text - `root` (boolean): Use root shell for protected paths ### `adb_logcat` (~267 tokens) Capture a logcat snapshot. Supports tag filtering, priority levels, and grep patterns. Input parameters: - `buffer` (string): Logcat buffer to read from - `device` (string): Device serial - `grep` (string): Grep filter applied to output (literal string match, case-insensitive) - `lines` (number): Number of recent lines to capture (1-10000) - `priority` (string): Minimum priority: V(erbose), D(ebug), I(nfo), W(arn), E(rror), F(atal) - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. - `tag` (string): Filter by tag (e.g., 'ActivityManager' or 'MyApp') ### `adb_logcat_clear` (~28 tokens) Clear all logcat buffers on the device Input parameters: - `device` (string): Device serial ### `adb_logcat_crash` (~44 tokens) Get recent crash logs from the crash buffer Input parameters: - `device` (string): Device serial - `lines` (number): Number of lines (1-10000) ### `adb_dumpsys` (~204 tokens) Run dumpsys for a specific service. Use 'list' as the service to see all available services. Input parameters: - `args` (string): Additional arguments passed to dumpsys - `device` (string): Device serial - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. - `service` (string, required): Service name (e.g., 'battery', 'telephony.registry', 'activity') or 'list' ### `adb_telephony` (~34 tokens) Get telephony state including cell info, signal strength, and network registration. Input parameters: - `device` (string): Device serial ### `adb_battery` (~30 tokens) Get battery status, level, temperature, and charging info Input parameters: - `device` (string): Device serial ### `adb_network` (~31 tokens) Get network connectivity info including WiFi, cellular, and active connections Input parameters: - `device` (string): Device serial ### `adb_top` (~44 tokens) Get current CPU and memory usage snapshot Input parameters: - `count` (number): Number of iterations (1-100, 1 = snapshot) - `device` (string): Device serial ### `adb_perf_snapshot` (~59 tokens) Capture a performance snapshot for a package: memory usage, frame stats, and CPU info in one call. Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name to profile (e.g., 'com.example.app') ### `adb_bugreport` (~42 tokens) Capture a full bug report zip (device state, logs, dumpsys, system info). Returns the local file path. Input parameters: - `device` (string): Device serial ### `adb_crash_logs` (~99 tokens) Read ANR (Application Not Responding) traces and tombstone crash dumps from the device. Requires root access for /data/anr/ and /data/tombstones/. Returns the most recent entries. Input parameters: - `device` (string): Device serial - `maxEntries` (integer): Maximum entries to return per type (1-20, default 5) - `type` (string): Type of crash data to retrieve (default: both) ### `adb_heap_dump` (~98 tokens) Capture a heap dump from a running process for memory analysis. Triggers `am dumpheap` and pulls the resulting .hprof file. Requires the target process PID or package name. Input parameters: - `device` (string): Device serial - `filename` (string): Output filename (default: heap__.hprof) - `target` (string, required): Process PID (number) or package name (e.g., com.example.app) ### `adb_screencap` (~51 tokens) Take a screenshot and save to local filesystem. Returns the file path. Input parameters: - `device` (string): Device serial - `filename` (string): Output filename (default: screenshot_.png) ### `adb_current_activity` (~27 tokens) Get the currently focused activity and window stack Input parameters: - `device` (string): Device serial ### `adb_input` (~123 tokens) Send input events to the device (tap, swipe, text, keyevent) Input parameters: - `args` (string, required): Arguments: tap='x y', swipe='x1 y1 x2 y2 [duration_ms]', text='string', keyevent='KEYCODE_HOME' - `device` (string): Device serial - `type` (string, required): Input type — one of: tap (single touch), swipe (drag between two points), text (literal string entry), keyevent (Android key code like KEYCODE_HOME). The args field documents the expected argument fo… ### `adb_start_activity` (~64 tokens) Start an activity or app by intent or component name Input parameters: - `device` (string): Device serial - `intent` (string, required): Intent or component (e.g., 'com.example/.MainActivity' or '-a android.intent.action.VIEW -d https://example.com') ### `adb_ui_dump` (~122 tokens) Dump the current UI hierarchy. Parses the view tree into structured element data with coordinates, text, resource IDs, and interaction flags. Use format='tsv' for token-efficient compact output, format='xml' for raw uiautomator XML. Input parameters: - `clickableOnly` (boolean): Only show clickable/interactive elements - `device` (string): Device serial - `format` (string): Output format: 'text' (default, human-readable), 'tsv' (tab-separated, token-efficient), 'xml' (raw uiautomator XML) ### `adb_ui_find` (~98 tokens) Search the UI hierarchy for elements matching text, resource-id, or content-description. Returns matching elements with coordinates for precise adb_input targeting. Input parameters: - `contentDesc` (string): Match elements with this content-description (partial, case-insensitive) - `device` (string): Device serial - `resourceId` (string): Match elements with this resource-id (partial match) - `text` (string): Match elements containing this text (case-insensitive) ### `adb_screencap_annotated` (~116 tokens) Take a screenshot with UI element bounding boxes and numbered labels composited directly onto the image. Returns the annotated PNG path plus a text legend mapping each element number to its identity. Ideal for LLM workflows that need to reference specific UI elements by number rather than by coordinates. Input parameters: - `clickableOnly` (boolean): Only annotate clickable/scrollable elements (default true — reduces visual noise) - `device` (string): Device serial - `filename` (string): Output filename (default: annotated_.png) ### `adb_screen_state` (~96 tokens) Get a combined screen state snapshot in one call: foreground activity, screen dimensions and density, orientation, battery level, and a TSV list of interactive UI elements. Replaces 3-4 separate tool calls with a single round-trip. Ideal as a first step in any automation workflow. Input parameters: - `clickableOnly` (boolean): Only include clickable/scrollable elements in TSV output (default true) - `device` (string): Device serial ### `adb_gradle` (~165 tokens) Run a Gradle task in an Android project directory Input parameters: - `args` (array): Additional Gradle arguments as an array of strings (e.g., ['-Pversion=1.0', '--info']). Use an array — not a space-separated string — so arguments containing quoted values are preserved as single tok… - `projectPath` (string, required): Path to the Android project root (containing gradlew) - `task` (string, required): Gradle task (e.g., 'assembleDebug', 'installDebug', 'clean') - `timeout` (integer): Build timeout in milliseconds (30s-30min, default 5min). V5 fix: large multi-module Android projects (60+ modules) routinely exceed the default; raise this for clean builds of bigger projects. ### `adb_build_and_install` (~78 tokens) Build a debug APK and install it on the connected device (convenience wrapper) Input parameters: - `device` (string): Device serial - `projectPath` (string, required): Path to the Android project root - `timeout` (integer): Build+install timeout in milliseconds (30s-30min, default 5min). V5 fix. ### `adb_health_check` (~52 tokens) Run a comprehensive health check of the ADB toolchain. Validates: ADB binary, server, device connection, authorization, and root access. Input parameters: - `device` (string): Device serial to check (optional) ### `adb_pair` (~72 tokens) Pair with a device over WiFi using the pairing code from Developer Options → Wireless debugging → Pair device Input parameters: - `code` (string, required): 6-digit pairing code shown on the device - `host` (string, required): Device IP and pairing port (e.g., '192.168.1.100:37123') ### `adb_connect` (~68 tokens) Connect to a device over WiFi/TCP. Device must be paired first or have TCP/IP enabled. Input parameters: - `host` (string, required): Device IP and port (e.g., '192.168.1.100:5555' or '192.168.1.100:41567') ### `adb_disconnect` (~40 tokens) Disconnect from a wireless device, or all wireless devices if no host specified Input parameters: - `host` (string): Device IP:port to disconnect (omit for all) ### `adb_tcpip` (~76 tokens) Switch a USB-connected device to TCP/IP mode on the specified port (default 5555). After this, you can disconnect USB and use adb_connect. Input parameters: - `device` (string): Device serial (must be USB-connected) - `port` (number): TCP port for ADB (1-65535, default 5555) ### `adb_airplane_mode` (~50 tokens) Toggle airplane mode on/off. Useful for resetting cellular registration during radio testing. Input parameters: - `device` (string): Device serial - `enabled` (boolean, required): true = enable airplane mode, false = disable ### `adb_wifi` (~39 tokens) Enable or disable WiFi Input parameters: - `device` (string): Device serial - `enabled` (boolean, required): true = enable WiFi, false = disable ### `adb_mobile_data` (~40 tokens) Enable or disable mobile data Input parameters: - `device` (string): Device serial - `enabled` (boolean, required): true = enable mobile data, false = disable ### `adb_location` (~50 tokens) Enable or disable location services Input parameters: - `device` (string): Device serial - `mode` (string, required): Location mode: off, sensors (GPS only), battery (network only), high (GPS + network) ### `adb_screen` (~194 tokens) Control screen state: wake, sleep, toggle, lock, or unlock. Lock and unlock verify actual keyguard state via dumpsys window. Unlock uses wm dismiss-keyguard (works for swipe keyguards); supply 'pin' to perform the full PIN entry sequence for PIN-protected devices: wakes screen, dismisses keyguard, swipes up to reveal keypad, types PIN, confirms with ENTER, and verifies the keyguard sleep token was released. Input parameters: - `action` (string, required): Screen action — one of: wake (power on + dismiss keyguard if no PIN), sleep (power off), toggle (flip current state), lock (force keyguard), unlock (dismiss keyguard, with PIN if supplied) - `device` (string): Device serial - `pin` (string): PIN/password to enter when unlock encounters an active keyguard (digits only for PIN, alphanumeric for password). Only used with action='unlock'. ### `adb_airplane_cycle` (~64 tokens) Cycle airplane mode on then off after a delay. Forces cellular re-registration — useful for radio diagnostics and network testing. Input parameters: - `delaySeconds` (number): Seconds to keep airplane mode on (1-60, default 3) - `device` (string): Device serial ### `adb_settings_get` (~69 tokens) Read an Android settings value from any namespace (system, secure, global) Input parameters: - `device` (string): Device serial - `key` (string, required): Setting key (e.g., 'screen_brightness', 'location_mode', 'airplane_mode_on') - `namespace` (string, required): Settings namespace ### `adb_settings_put` (~151 tokens) Write an Android settings value to any namespace (system, secure, global) Input parameters: - `device` (string): Device serial - `key` (string, required): Setting key (e.g., 'screen_brightness' for system namespace, 'wifi_on' or 'airplane_mode_on' for global, 'location_providers_allowed' for secure). Use `adb_shell` with `settings list ` to… - `namespace` (string, required): Settings namespace - `value` (string, required): Value to write. Type depends on the key — typically a string, integer, or 0/1 for booleans. The setting framework accepts everything as a string and parses on read. ### `adb_reboot` (~53 tokens) Reboot the device. Supports normal, recovery, and bootloader modes. Input parameters: - `device` (string): Device serial - `mode` (string): Reboot mode: normal (default), recovery, or bootloader ### `adb_logcat_start` (~117 tokens) Start a background logcat watcher. Lines accumulate in a ring buffer. Use adb_logcat_poll to retrieve new entries. Input parameters: - `bufferSize` (number): Max lines to keep in ring buffer (100-50000, default 2000) - `device` (string): Device serial - `priority` (string): Minimum priority level - `tag` (string): Filter by tag (e.g., 'MyApp'). Must match /^[a-zA-Z0-9_]+$/ — Android tags are identifier-shaped in practice. ### `adb_logcat_poll` (~190 tokens) Retrieve new logcat lines since the last poll from a running watcher session. Input parameters: - `maxLines` (number): Max lines to return per poll (1-10000) - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. - `session` (string, required): Session ID from adb_logcat_start (e.g., 'watch_1') ### `adb_logcat_stop` (~45 tokens) Stop a running logcat watcher session Input parameters: - `session` (string, required): Session ID to stop (e.g., 'watch_1'), or 'all' to stop all ### `adb_logcat_sessions` (~18 tokens) List all active logcat watcher sessions ### `adb_forward` (~108 tokens) Forward a local port to a port on the device (host → device). Use for connecting to services running on the device. Input parameters: - `device` (string): Device serial - `local` (string, required): Local (host) spec, e.g., 'tcp:8080'. AF2 fix: format-validated. - `remote` (string, required): Remote (device) spec, e.g., 'tcp:8080' or 'localabstract:app_socket'. AF2 fix: format-validated. ### `adb_reverse` (~102 tokens) Reverse-forward a device port to a port on the host (device → host). Use for letting device apps reach services on your machine. Input parameters: - `device` (string): Device serial - `local` (string, required): Local (host) spec, e.g., 'tcp:3000'. AF2 fix: format-validated. - `remote` (string, required): Remote (device) spec, e.g., 'tcp:3000'. AF2 fix: format-validated. ### `adb_forward_list` (~32 tokens) List all active port forwards and reverse forwards Input parameters: - `device` (string): Device serial (omit for all devices) ### `adb_forward_remove` (~73 tokens) Remove a port forward (host → device), or all forwards. Use after testing to clean up. Input parameters: - `device` (string): Device serial - `local` (string): Local spec to remove (e.g., 'tcp:8080'). Omit to remove all forwards. AF2 fix: format-validated. ### `adb_reverse_remove` (~75 tokens) Remove a reverse forward (device → host), or all reverse forwards. Use after testing to clean up. Input parameters: - `device` (string): Device serial - `remote` (string): Remote spec to remove (e.g., 'tcp:3000'). Omit to remove all reverse forwards. AF2 fix: format-validated. ### `adb_tunnel_open` (~206 tokens) Open a managed tunnel between host and device. Higher-level convenience wrapper over adb_forward / adb_reverse: auto-picks a free host port when one isn't specified (forward only), returns an opaque tunnel ID for later close, and registers cleanup so the tunnel is removed on server exit. Direction 'forward' = host port forwards TO device service; 'reverse' = device port forwards TO host service. Input parameters: - `device` (string): Device serial - `deviceSpec` (string, required): Device-side spec, e.g., 'tcp:3000' or 'localabstract:app_socket' - `direction` (string, required): 'forward' (host → device) or 'reverse' (device → host) - `hostSpec` (string): Host-side spec, e.g., 'tcp:8080'. For 'forward' direction: omit to auto-pick a free host port. For 'reverse' direction: required (can't auto-pick device-side ports without an extra probe call). ### `adb_tunnel_list` (~89 tokens) List all active managed tunnels (opened via adb_tunnel_open). Shows tunnel ID, device, direction, and both endpoints. Note: this only surfaces tunnels created via adb_tunnel_open — tunnels created via the low-level adb_forward / adb_reverse won't appear here. For those, use adb_forward_list. Input parameters: - `device` (string): Filter to a specific device serial (default: all devices) ### `adb_tunnel_close` (~88 tokens) Close a managed tunnel by ID, or all managed tunnels at once. The corresponding adb forward/reverse entry is removed and the tunnel is dropped from the cleanup registry. Use adb_tunnel_list to see active tunnel IDs. Input parameters: - `id` (string, required): Tunnel ID (tun_XXXXXX) returned by adb_tunnel_open, or the literal string 'all' to close every managed tunnel. ### `adb_screenrecord_start` (~64 tokens) Start recording the device screen. Recording runs on-device. Use adb_screenrecord_stop to finish and pull the video file. Input parameters: - `device` (string): Device serial - `maxDuration` (number): Maximum recording duration in seconds (1-180, default 60) ### `adb_screenrecord_stop` (~48 tokens) Stop an active screen recording and pull the video file locally. If the recording has already finished (hit time limit), this just pulls the file. Input parameters: - `device` (string): Device serial ### `adb_avd_list` (~25 tokens) List all available Android Virtual Devices (AVDs) that can be started. ### `adb_emulator_start` (~89 tokens) Launch an Android Virtual Device (AVD) emulator. Returns once the emulator process has started. Input parameters: - `avdName` (string, required): AVD name (from adb_avd_list) - `coldBoot` (boolean): Force cold boot (-no-snapshot-load) - `gpuMode` (string): GPU acceleration mode - `headless` (boolean): Run without GUI window (-no-window) ### `adb_emulator_stop` (~75 tokens) Stop a running emulator. Uses 'adb emu kill' for graceful shutdown. Input parameters: - `avdName` (string): AVD name to stop. If omitted, lists running emulators. - `device` (string): Emulator device serial (e.g., 'emulator-5554') — alternative to avdName ### `adb_qemu_setup` (~74 tokens) Check and install QEMU for on-device virtualization. Verifies KVM availability, checks if QEMU is installed, reports version info, and can install QEMU via Termux package manager. Only available in on-device mode. Input parameters: - `install` (boolean): If true, install QEMU via pkg if not already present ### `adb_qemu_images` (~138 tokens) Manage QEMU disk images for virtual machines. List available images, create new qcow2/raw disk images, or delete existing ones. Images are stored in the DeepADB image directory. Input parameters: - `action` (string, required): Action to perform - `format` (string): Image format. qcow2 is recommended (sparse, snapshots). raw for maximum I/O performance. - `name` (string): Image name (for create/delete). Alphanumeric, hyphens, underscores only. - `sizeMb` (number): Image size in MB (for create). Default 8192 (8GB). Range: 64-65536. ### `adb_qemu_start` (~288 tokens) Boot a QEMU virtual machine with KVM hardware acceleration. Auto-detects optimal resource allocation: uses total cores minus 1 for the VM (reserving one for the host OS), and up to 65% of physical RAM. Custom values are accepted but capped at safe limits to prevent host starvation. Input parameters: - `adbPort` (number): Host port to forward to guest ADB (port 5555). Default 5556. - `append` (string): Kernel command line arguments (for Android boot). - `cpus` (number): Virtual CPUs. Auto-detected if omitted (total cores minus 1). Capped at safe limit. - `display` (string): Display output. 'none' for headless (default). 'vnc' starts a VNC server on port 5900. - `image` (string, required): Disk image filename (from adb_qemu_images) or absolute path - `initrd` (string): Path to initrd/ramdisk image (for Android boot). - `kernel` (string): Path to kernel image (for Android boot). If omitted, QEMU uses the disk image's bootloader. - `memoryMb` (number): RAM in MB. Auto-detected if omitted (65% of physical RAM). Capped at safe limit. - `name` (string, required): VM name (used to track and stop the VM) ### `adb_qemu_stop` (~67 tokens) Stop a running QEMU virtual machine. Sends SIGTERM for graceful shutdown, with force kill option. Input parameters: - `force` (boolean): Use SIGKILL instead of SIGTERM for immediate termination. - `name` (string): VM name to stop. If omitted, lists running VMs. ### `adb_qemu_status` (~36 tokens) Show status of QEMU virtual machines — running VMs with resource usage and port mappings, plus KVM and QEMU availability. ### `adb_qemu_connect` (~122 tokens) Connect to a running QEMU VM's ADB service, making the guest appear as a device for DeepADB tools. Requires the guest OS to have an ADB daemon running (e.g., Android guest with USB debugging enabled). Requires the 'adb' binary (install with: pkg install android-tools). Connections are restricted to localhost only — no remote host connections allowed. Input parameters: - `name` (string, required): VM name to connect to (must be running) - `timeout` (number): Connection timeout in milliseconds (3s-30s). Default 10s. ### `adb_qemu_disconnect` (~41 tokens) Disconnect from a QEMU VM's ADB service. Removes the guest from the device list. Input parameters: - `name` (string, required): VM name to disconnect from ### `adb_qemu_guest_shell` (~123 tokens) Execute a shell command on a QEMU guest VM via ADB. The VM must be connected first (use adb_qemu_connect). The guest serial is derived internally — no user-supplied host/IP reaches the ADB binary. Subject to the same security middleware checks as adb_shell. Input parameters: - `command` (string, required): Shell command to execute on the guest - `name` (string, required): VM name (must be connected via adb_qemu_connect) - `timeout` (number): Command timeout in milliseconds (1s-60s). Default 15s. ### `adb_test_session_start` (~60 tokens) Start a structured test session. Creates a named directory for organizing numbered screenshots and logcat captures. Input parameters: - `device` (string): Device serial - `name` (string, required): Test session name (e.g., 'login_flow', 'threat_detection') ### `adb_test_step` (~78 tokens) Capture a numbered test step: takes a screenshot and captures logcat since the last step. Saves both to the session directory. Input parameters: - `captureLogcat` (boolean): Capture logcat since last step - `captureScreenshot` (boolean): Take a screenshot for this step - `description` (string, required): Description of what this step tests or verifies ### `adb_test_session_end` (~27 tokens) End the active test session. Writes a summary manifest and returns the session directory path. ### `adb_multi_shell` (~80 tokens) Execute a shell command on multiple (or all) connected devices in parallel. Returns results grouped by device. Input parameters: - `command` (string, required): Shell command to execute on each device - `devices` (array): Device serials to target (omit for all online devices) - `timeout` (number): Timeout per device in milliseconds (1s-10min) ### `adb_multi_install` (~66 tokens) Install an APK on multiple (or all) connected devices in parallel. Input parameters: - `apkPath` (string, required): Local filesystem path to the APK file - `devices` (array): Device serials (omit for all online devices) - `replace` (boolean): Replace existing app (-r) ### `adb_multi_compare` (~56 tokens) Run a command on all devices and compare outputs side by side. Highlights differences across devices. Input parameters: - `command` (string, required): Shell command to compare across devices - `devices` (array): Device serials (omit for all online devices) ### `adb_multi_test` (~199 tokens) Run a comparative test workflow across all connected devices (host + QEMU guests). Executes a predefined diagnostic profile or custom command list on every device in parallel, compares results per-check, and reports matches and differences. Profiles: 'firmware' (baseband, bootloader, kernel, security patch), 'security' (SELinux, verified boot, encryption), 'network' (radio, WiFi, SIM), 'identity' (model, chipset, architecture), 'full' (all profiles). Custom commands also supported. Input parameters: - `commands` (array): Custom checks to run (max 50). Each has a label and command. - `devices` (array): Device serials to target (omit for all online devices) - `profile` (string): Predefined test profile to run. 'full' runs all profiles. - `timeout` (number): Timeout per command per device in ms (1s-60s, default 10s) ### `adb_snapshot_capture` (~56 tokens) Capture a comprehensive device state snapshot: installed packages, key settings, and system properties. Saves to a JSON file. Input parameters: - `device` (string): Device serial - `name` (string): Snapshot name (default: auto-generated timestamp) ### `adb_snapshot_compare` (~55 tokens) Compare current device state against a saved snapshot. Shows added/removed packages, changed settings, and property differences. Input parameters: - `device` (string): Device serial - `snapshotPath` (string, required): Path to the saved snapshot JSON file ### `adb_snapshot_restore_settings` (~71 tokens) Restore settings from a saved snapshot to the current device. Only restores global and secure settings — does not install/uninstall packages. Input parameters: - `device` (string): Device serial - `namespace` (string): Which settings namespace to restore - `snapshotPath` (string, required): Path to the saved snapshot JSON file ### `adb_tcpdump_start` (~114 tokens) Start a packet capture on the device using tcpdump. Requires root or tcpdump binary on device. Capture runs in background. Input parameters: - `device` (string): Device serial - `filter` (string): tcpdump filter expression (e.g., 'port 443', 'host 10.0.0.1') - `interface` (string): Network interface to capture (default: 'any') - `maxPackets` (number): Stop after N packets (1-1000000, omit for continuous until stop) ### `adb_tcpdump_stop` (~34 tokens) Stop an active packet capture and pull the pcap file locally for analysis. Input parameters: - `device` (string): Device serial ### `adb_network_connections` (~56 tokens) Show active network connections on the device (TCP/UDP). Similar to netstat — shows established connections, listening ports, and connection states. Input parameters: - `device` (string): Device serial - `protocol` (string): Filter by protocol ### `adb_ci_wait_boot` (~68 tokens) Wait for a device or emulator to fully boot. Polls sys.boot_completed and waits for the launcher to be ready. Essential for CI pipelines. Input parameters: - `device` (string): Device serial - `timeoutSeconds` (number): Maximum time to wait for boot in seconds (default 120) ### `adb_ci_device_ready` (~50 tokens) Comprehensive CI readiness check. Verifies: device online, booted, package manager ready, screen unlocked, network available. Returns structured pass/fail results. Input parameters: - `device` (string): Device serial ### `adb_ci_run_tests` (~132 tokens) Run Android instrumented tests (androidTest) via `am instrument` and capture results. Returns structured pass/fail output. Input parameters: - `device` (string): Device serial - `runner` (string): Test runner class (default: AndroidX JUnit runner) - `testClass` (string): Specific test class to run (optional) - `testMethod` (string): Specific test method (requires testClass) - `testPackage` (string, required): Test package (e.g., 'com.example.app.test') - `timeout` (number): Timeout in ms (10s-10min, default 5 min) ### `adb_plugin_list` (~19 tokens) List all loaded plugins and the plugin directory path. ### `adb_plugin_info` (~28 tokens) Show information about the plugin system: directory, how to create plugins, and loaded plugin count. ### `adb_baseband_info` (~193 tokens) Get comprehensive modem/baseband identification: firmware version, RIL implementation, chipset, IMEI, SIM state, and radio capabilities. Input parameters: - `device` (string): Device serial - `includeImei` (boolean): Include IMEI in output (sensitive permanent device identifier — opt-in only) - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. ### `adb_cell_identity` (~65 tokens) Extract detailed cell identity information: Cell ID (CID), TAC/LAC, EARFCN/ARFCN, Physical Cell ID (PCI), PLMN, and network type. Parses structured data from dumpsys for cellular network analysis. Input parameters: - `device` (string): Device serial ### `adb_signal_detail` (~56 tokens) Get detailed signal strength measurements: RSRP, RSRQ, SINR, RSSI, timing advance, and signal bars. Provides raw radio measurements for signal analysis and anomaly detection. Input parameters: - `device` (string): Device serial ### `adb_neighboring_cells` (~60 tokens) List all visible cells beyond the serving cell: neighboring LTE/5G/WCDMA/GSM cells with their identities and signal strengths. Useful for cellular network surveys, coverage analysis, and radio environment characterization. Input parameters: - `device` (string): Device serial ### `adb_carrier_config` (~40 tokens) Dump carrier configuration values. Useful for verifying carrier settings, detecting configuration anomalies, and inspecting APN configurations. Input parameters: - `device` (string): Device serial ### `adb_modem_logs` (~106 tokens) Capture modem/baseband-related logs from multiple sources: RIL (Radio Interface Layer) logcat, telephony framework logs, and kernel modem messages via dmesg (root required for dmesg). Useful for radio diagnostics and tracing baseband-framework communication. Input parameters: - `device` (string): Device serial - `grep` (string): Additional grep filter applied to all sources - `lines` (number): Max lines per log source (1-5000, default 200) ### `adb_a11y_audit` (~74 tokens) Run an automated accessibility audit on the current screen. Checks for: missing labels on interactive elements, undersized touch targets (<48dp), images without content-descriptions, clickable elements missing focusability, and duplicate descriptions. Returns a structured report with severity and rule violations. Input parameters: - `device` (string): Device serial ### `adb_a11y_touch_targets` (~68 tokens) List all interactive elements with their touch target dimensions in dp. Highlights elements below the 48dp minimum. Useful for quickly identifying cramped UI layouts. Input parameters: - `belowMinOnly` (boolean): Only show elements below the 48dp minimum - `device` (string): Device serial ### `adb_a11y_tree` (~55 tokens) Dump the accessibility-focused view of the UI hierarchy. Shows only elements relevant to screen readers: their roles, labels, states, and navigation order. Filters out decorative/layout containers. Input parameters: - `device` (string): Device serial ### `adb_regression_baseline` (~96 tokens) Capture a performance baseline for a package: memory, CPU, frame stats, battery, and network state. Saves to a timestamped JSON file for later comparison with adb_regression_check. Input parameters: - `device` (string): Device serial - `label` (string): Label for this baseline (e.g., 'before-refactor', 'v2.5.0') - `packageName` (string, required): Package name to profile ### `adb_regression_check` (~141 tokens) Compare current performance against a saved baseline. Flags regressions in memory (>20% increase), CPU (>50% increase), and jank rate (>25% increase). Thresholds are configurable. Input parameters: - `baselinePath` (string, required): Path to the saved baseline JSON file - `cpuThreshold` (number): CPU regression threshold in percent (0-1000, default 50%) - `device` (string): Device serial - `jankThreshold` (number): Jank rate regression threshold in percent (0-1000, default 25%) - `memoryThreshold` (number): Memory regression threshold in percent (0-1000, default 20%) ### `adb_regression_history` (~40 tokens) List all saved regression baselines, optionally filtered by package name. Shows trends over time. Input parameters: - `packageName` (string): Filter by package name ### `adb_farm_run` (~245 tokens) Run tests on Firebase Test Lab. Uploads an APK and test APK, executes instrumented tests across specified device models and API levels. Requires gcloud CLI authenticated with a Firebase project. Input parameters: - `appApk` (string, required): Path to the app APK file - `devices` (array): Device specs as 'model=DEVICE,version=API' (e.g., 'model=bluejay,version=33'). Omit for default device. - `execTimeoutMs` (integer): Local execFile timeout for the gcloud invocation in ms (1min-60min, default 10min). Y4 fix: bigger device matrices or larger APKs can plausibly exceed the previous hardcoded 10min. - `resultsBucket` (string): GCS bucket for results (omit for default) - `testApk` (string, required): Path to the test/instrumentation APK file - `testTargets` (string): Specific test class or method (e.g., 'class com.example.MyTest') - `timeout` (string): Test timeout passed to gcloud --timeout (e.g., '300s', '10m'). This is the LAB-side timeout. ### `adb_farm_results` (~69 tokens) Retrieve results from the most recent Firebase Test Lab run, or a specific test matrix ID. Shows pass/fail status, device results, and links to logs and artifacts. Input parameters: - `matrixId` (string): Test matrix ID (from adb_farm_run output). Omit to list recent matrices. ### `adb_farm_matrix` (~43 tokens) List available device models and API levels on Firebase Test Lab. Use to plan test matrices. Input parameters: - `type` (string): List available device models or Android API versions ### `adb_registry_search` (~53 tokens) Search the community plugin registry for available plugins. Shows name, description, version, and author. Fetches the latest manifest from the configured registry URL. Input parameters: - `query` (string): Filter plugins by name or description keyword ### `adb_registry_install` (~61 tokens) Install a plugin from the community registry by name. Downloads the plugin JavaScript file into the plugins directory. Restart DeepADB to load it. Input parameters: - `force` (boolean): Overwrite if already installed - `name` (string, required): Plugin name from the registry ### `adb_registry_installed` (~31 tokens) List all locally installed plugins with their versions and metadata. Shows which plugins have updates available in the registry. ### `adb_at_detect` (~62 tokens) Auto-detect the modem AT command device node. Identifies the chipset family (Shannon, Qualcomm, MediaTek, Unisoc) and probes known device node paths. Requires root. Returns the first responding node. Input parameters: - `device` (string): Device serial ### `adb_at_send` (~143 tokens) Send a single AT command to the modem and capture the response. Requires root. Use adb_at_detect to find the correct port, or specify it manually. Input parameters: - `command` (string, required): AT command to send (e.g., 'AT+CSQ', 'ATI', 'AT+COPS?') - `device` (string): Device serial - `force` (boolean): Bypass dangerous command safety check - `port` (string): Modem device node (e.g., '/dev/umts_router0'). If omitted, auto-detects. - `timeout` (number): Response timeout in ms (1000-30000, default 5000) ### `adb_at_batch` (~123 tokens) Send multiple AT commands sequentially and capture all responses. Useful for running a diagnostic sequence. Requires root. Input parameters: - `commands` (array, required): Array of AT commands to send in order (max 50) - `delayMs` (number): Delay between commands in ms (0-10000, default 500) - `device` (string): Device serial - `force` (boolean): Bypass dangerous command safety checks - `port` (string): Modem device node (auto-detects if omitted) - `timeout` (number): Timeout per command in ms ### `adb_at_probe` (~62 tokens) Run a standard AT diagnostic probe: modem identification, signal quality, network registration, SIM status, and supported bands. Requires root. Input parameters: - `device` (string): Device serial - `port` (string): Modem device node (auto-detects if omitted) ### `adb_at_cross_validate` (~140 tokens) Cross-validate baseband firmware by comparing AT command responses (direct modem interrogation) against Android system properties (getprop). Discrepancies may indicate firmware tampering, incomplete OTA updates, or property spoofing. Sends ATI (identification), AT+CGMR (firmware revision), and AT+CGMM (model) to the modem and compares with gsm.version.baseband, ro.hardware.chipname, and related properties. Requires root. Input parameters: - `device` (string): Device serial - `port` (string): Modem device node (auto-detects if omitted) - `timeout` (number): Response timeout per command in ms ### `adb_screenshot_baseline` (~190 tokens) Capture a named screenshot baseline for later comparison. Saves the screenshot and metadata to the baselines directory. Input parameters: - `device` (string): Device serial - `name` (string, required): Baseline name (e.g., 'home_screen', 'login_page', 'threat_alert') - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. ### `adb_screenshot_diff` (~254 tokens) Compare the current screen against a saved screenshot baseline. Decodes PNGs and performs pixel-level comparison (RGB channels), reporting exact pixel difference count, percentage, and the bounding box of the changed region. Supports a tolerance threshold for absorbing minor dynamic elements like clocks or notification badges. Input parameters: - `baseline` (string, required): Baseline name to compare against (from adb_screenshot_baseline) - `device` (string): Device serial - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. - `tolerancePercent` (number): Pixel difference percentage threshold below which the result reports IDENTICAL. 0 = exact match required. 1-2 absorbs clock/status bar changes. ### `adb_screenshot_history` (~153 tokens) List all saved screenshot baselines with their metadata (timestamp, dimensions, device, file size). Input parameters: - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. ### `adb_workflow_run` (~123 tokens) Execute a workflow — a JSON-defined sequence of device operations with variable substitution, conditional steps, and loop support. Supported actions: shell, root_shell, install, screenshot, logcat, getprop, sleep. Pass the workflow as a JSON string or provide a saved workflow name. Input parameters: - `device` (string): Device serial - `dryRun` (boolean): Validate and show execution plan without running - `variables` (object): Override workflow variables (merged with defaults) - `workflow` (string, required): Workflow JSON string, or the name of a saved workflow file ### `adb_workflow_validate` (~40 tokens) Validate a workflow JSON definition without executing it. Reports structural errors and shows the execution plan. Input parameters: - `workflow` (string, required): Workflow JSON string to validate ### `adb_workflow_list` (~19 tokens) List saved workflow files in the workflows directory. ### `adb_install_bundle` (~101 tokens) Install multiple APK splits (app bundle) on the device using `install-multiple`. Provide all split APK files — base APK plus config splits (language, density, ABI). Input parameters: - `allowDowngrade` (boolean): Allow version downgrade (-d) - `apkPaths` (array, required): Array of local paths to split APK files (base + config splits) - `device` (string): Device serial - `replace` (boolean): Replace existing app (-r) ### `adb_list_splits` (~63 tokens) List all APK split paths installed for a package. Shows the base APK and any configuration splits (language, screen density, ABI). Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name (e.g., 'com.example.app') ### `adb_extract_apks` (~74 tokens) Pull all APK splits for a package from the device to a local directory. Useful for analysis, backup, or transfer to another device. Input parameters: - `device` (string): Device serial - `outputDir` (string): Local output directory (default: temp dir) - `packageName` (string, required): Package name to extract ### `adb_apex_list` (~55 tokens) List installed APEX modules on the device. APEX (Android Pony EXpress) modules deliver updatable system components. Shows module name, version, and active/staged status. Input parameters: - `device` (string): Device serial ### `adb_mirror_start` (~214 tokens) Start live screen mirroring for a device using scrcpy. Requires scrcpy installed and on PATH. Supports windowed (visual) and headless (no display) modes. One session per device. Input parameters: - `bitrate` (string): Video bitrate (e.g., '4M', '8M', '2M'). AK2 fix: format-validated at schema layer. - `device` (string): Device serial - `headless` (boolean): No-display mode — useful with recording. Omits the scrcpy window. - `maxFps` (number): Maximum frame rate (1-120, default 30) - `maxSize` (number): Max dimension in pixels (0 = no limit, max 4096) - `record` (string): Record to a local file path (e.g., 'mirror.mp4') - `stayAwake` (boolean): Keep device awake while mirroring - `turnScreenOff` (boolean): Turn device screen off during mirroring (saves battery) ### `adb_mirror_stop` (~44 tokens) Stop an active scrcpy mirroring session for a device. Input parameters: - `device` (string): Device serial (stops that device's session). Omit to stop all. ### `adb_mirror_status` (~21 tokens) Check scrcpy availability and list active mirroring sessions. ### `adb_test_gen_from_ui` (~115 tokens) Analyze the current screen and generate a test workflow that taps each interactive element, takes screenshots, and verifies the app doesn't crash. Produces a workflow JSON compatible with adb_workflow_run. Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name to monitor during test (used for logcat filtering and crash detection) - `returnToStart` (boolean): Press Back after each tap to return to the starting screen - `screenshotAfterEach` (boolean): Take a screenshot after each tap ### `adb_test_gen_from_intents` (~68 tokens) Analyze a package's registered activities and intent filters to generate a test workflow that launches each exported activity and verifies it renders. Produces workflow JSON compatible with adb_workflow_run. Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name to analyze ### `adb_test_gen_save` (~53 tokens) Save a generated workflow JSON to the workflows directory for later execution with adb_workflow_run. Input parameters: - `name` (string, required): Workflow name (used as filename) - `workflow` (string, required): Workflow JSON string to save ### `adb_ota_fingerprint` (~87 tokens) Capture and save the current system fingerprint: build ID, Android version, security patch, bootloader, baseband firmware, kernel version, and A/B partition slot. Saves to a timestamped JSON file for later comparison. Input parameters: - `device` (string): Device serial - `label` (string): Label for this fingerprint (e.g., 'pre-update', 'post-ota') ### `adb_ota_check` (~80 tokens) Compare the current system state against a saved fingerprint. Detects OTA updates by identifying changes in build ID, security patch, baseband firmware, bootloader, or kernel version. Input parameters: - `device` (string): Device serial - `fingerprintPath` (string): Path to saved fingerprint JSON. If omitted, compares against the most recent fingerprint for this device. ### `adb_ota_history` (~51 tokens) List all saved system fingerprints for a device, showing version progression over time. Highlights changes between consecutive snapshots. Input parameters: - `device` (string): Device serial (filters to this device). Omit for all devices. ### `adb_ril_start` (~115 tokens) Start capturing RIL (Radio Interface Layer) messages from the radio logcat buffer. Captures network registration, cell info, signal strength, authentication, handover, and NAS events. Useful for radio diagnostics and cellular network research. Input parameters: - `bufferSize` (number): Max messages to keep in ring buffer (100-50000, default 5000) - `device` (string): Device serial - `includeKernel` (boolean): Also capture from main and kernel logcat buffers for modem framework and kernel-level radio messages ### `adb_ril_poll` (~139 tokens) Retrieve captured RIL messages since the last poll. Optionally filter by category (registration, cell_info, signal, network, security, handover, data, radio_state, nas). Input parameters: - `category` (string): Filter by category: registration, cell_info, signal, network, security, handover, data, radio_state, sms, nas, other - `maxMessages` (number): Max messages to return per poll (1-10000) - `raw` (boolean): Return raw logcat lines instead of parsed messages - `session` (string, required): Session ID from adb_ril_start (e.g., 'ril_1') ### `adb_ril_stop` (~52 tokens) Stop a RIL capture session. Shows a summary of captured message categories. Input parameters: - `session` (string, required): Session ID to stop (e.g., 'ril_1'), or 'all' to stop all ### `adb_profile_detect` (~70 tokens) Auto-detect and build a device profile from the connected device. Captures hardware identification, chipset family, modem info, root status, and matches against the built-in profile library for known quirks. Input parameters: - `device` (string): Device serial - `save` (boolean): Automatically save the detected profile ### `adb_profile_save` (~72 tokens) Save a device profile to the profiles library. Use after adb_profile_detect to persist the profile, or create a manual profile with custom quirks and notes. Input parameters: - `name` (string, required): Profile name (used as filename) - `profile` (string, required): Profile JSON string (from adb_profile_detect output or manually composed) ### `adb_profile_list` (~24 tokens) List all device profiles: built-in library entries and user-saved profiles. ### `adb_firmware_probe` (~83 tokens) Comprehensive firmware identification for the connected device. Reports all firmware components: baseband (parsed by chipset family — Shannon, Qualcomm, MediaTek, Unisoc, HiSilicon, Intel), bootloader, RIL implementation, kernel, security patch, A/B slot, verified boot state, and OTA-updatable partitions. Input parameters: - `device` (string): Device serial ### `adb_firmware_diff` (~276 tokens) Compare all firmware components between two saved OTA fingerprints, or between the current device state and a saved fingerprint. Compares baseband (with chipset-specific parsed component diffs), bootloader, kernel, security patch, build ID, and Android version. Input parameters: - `device` (string): Device serial (used when 'from' or 'to' is 'current', or for auto-selecting fingerprints) - `from` (string): Path to 'from' fingerprint JSON (or 'current' to use live device state). Defaults to the second-most-recent fingerprint. - `result_handle` (string): Optional. If provided, store this tool's result under `result:///` for retrieval after compaction. Name must be 1-32 chars, [a-zA-Z0-9_-]. Existing handles with the same tool+name are ove… - `result_handle_ttl` (integer): Optional. TTL in seconds for the result handle (60 to 604800). Default 43200 (12 hours). Ignored if result_handle is not provided. - `to` (string): Path to 'to' fingerprint JSON (or 'current' to use live device state). Defaults to the most recent fingerprint. ### `adb_firmware_history` (~63 tokens) Show firmware version progression across all saved OTA fingerprints for a device. Tracks baseband, bootloader, kernel, security patch, and build ID changes between consecutive snapshots with parsed component diffs. Input parameters: - `device` (string): Device serial (filters fingerprints to this device) ### `adb_market_search` (~81 tokens) Search the workflow marketplace for community-shared workflow definitions. Shows name, description, tags, author, and step count. Indicates which workflows are already installed locally. Input parameters: - `query` (string): Filter by name, description, or tag keyword - `tag` (string): Filter by exact tag (e.g., 'testing', 'diagnostics', 'security') ### `adb_market_install` (~62 tokens) Download and install a workflow from the marketplace. Saves to the workflows directory for immediate use with adb_workflow_run. Input parameters: - `force` (boolean): Overwrite if a workflow with this name already exists locally - `name` (string, required): Workflow name from the marketplace ### `adb_market_export` (~144 tokens) Export a local workflow with marketplace metadata for sharing. Produces a JSON file with name, description, version, author, and tags suitable for submission to the marketplace registry. Input parameters: - `author` (string): Author name to include in metadata - `tags` (array): Tags for discovery (e.g., ['testing', 'diagnostics']) - `version` (string): Version string (semver-style, e.g., '1.2.3'). Defaults to '1.0.0' if omitted. Increment when publishing an updated workflow so registry consumers can detect changes. - `workflow` (string, required): Name of the local workflow to export (from adb_workflow_list) ### `adb_selinux_status` (~63 tokens) Check SELinux enforcement mode, policy version, and recent denial count. Shows whether the device is in Enforcing, Permissive, or Disabled mode. Root access provides additional policy details from dmesg audit logs. Input parameters: - `device` (string): Device serial ### `adb_selinux_denials` (~100 tokens) List recent SELinux AVC denial messages from logcat and kernel logs. Shows which processes were blocked, what they tried to do, and the SELinux contexts involved. Useful for diagnosing permission issues and understanding security policy enforcement. Input parameters: - `device` (string): Device serial - `lines` (number): Max denial entries to return (1-1000, default 50) - `process` (string): Filter denials by process/source context name ### `adb_permission_audit` (~113 tokens) Audit runtime permission grants for a package. Lists all granted dangerous permissions grouped by category (Camera, Location, Phone, SMS, etc.) and flags potentially over-provisioned permissions. Compares grants against the dangerous permission manifest to identify unnecessary access. Input parameters: - `device` (string): Device serial - `packageName` (string, required): Package name to audit (e.g., 'com.example.app'). AZ7 fix: enforces Java-identifier shape so injection attempts are rejected at the schema layer before reaching validateShellArg. ### `adb_thermal_snapshot` (~83 tokens) Capture a thermal and power snapshot: all thermal zone temperatures, per-CPU frequencies and governors, cooling device states, and battery temperature/current draw. Optionally save as a baseline for later comparison. Input parameters: - `device` (string): Device serial - `label` (string): Label for saved baseline - `save` (boolean): Save snapshot as a baseline JSON file ### `adb_thermal_compare` (~70 tokens) Compare current thermal/power state against a saved baseline. Reports temperature changes per zone, CPU frequency shifts, and battery drain rate differences. Input parameters: - `baselinePath` (string): Path to baseline JSON. If omitted, uses the most recent baseline for the device. - `device` (string): Device serial ### `adb_battery_drain` (~106 tokens) Measure battery drain rate over a specified duration. Takes initial and final readings and calculates mA draw, mW power consumption, and estimated percentage per hour. Useful for profiling power impact of specific operations. Input parameters: - `device` (string): Device serial - `durationMs` (number): Measurement duration in ms (3s-60s, default 10s) - `packageName` (string): If specified, show battery stats for this package (requires root for detailed stats) ### `adb_network_scan` (~183 tokens) Scan the local network for Android devices with ADB enabled over WiFi/TCP. Probes common ADB ports (5555-5558) on hosts from the ARP table and optionally a custom IP range. Discovered devices can be connected with adb_connect. Input parameters: - `device` (string): Device serial (used to determine the local subnet if no ipRange given) - `ipRange` (string): IP range to scan (e.g., '192.168.1.1-254'). If omitted, scans hosts from the ARP table only. - `ports` (array): Custom ports to probe (default: [5555, 5554, 5556, 5557, 5558], max 20) - `timeoutMs` (number): Connection timeout per host in ms (500-10000, default 2000) ### `adb_network_device_ip` (~49 tokens) Get the WiFi IP address of a connected device. Useful for switching from USB to wireless debugging without needing to find the IP manually on the device. Input parameters: - `device` (string): Device serial ### `adb_network_auto_connect` (~153 tokens) Discover and automatically connect to ADB devices on the local network. Combines network scanning with adb connect in one step. Probes a single port (default 5555) on each candidate; if you need to cover the full ADB port range (5555-5558) use adb_network_scan first, then adb_connect with the discovered host:port. Input parameters: - `device` (string): Device serial (used to determine local subnet for ARP-based discovery) - `ipRange` (string): IP range to scan (e.g., '192.168.1.1-254') - `port` (number): ADB port to probe and connect (1-65535, default 5555) ### `adb_sensor_read` (~129 tokens) Read current hardware sensor values from the device. Enumerates all available sensors from sensorservice and returns their last-known readings with timestamps. Sensor availability is device-dependent — the tool reports what's present. No root required. Input parameters: - `category` (string): Filter by sensor category: all, accelerometer, gyroscope, magnetometer, light, barometer, proximity, gravity, linear_accel, rotation, orientation, motion, step, temperature - `device` (string): Device serial - `listOnly` (boolean): If true, list available sensors without reading values (faster, useful for discovery) ### `adb_iio_read` (~142 tokens) Read raw hardware data from the Linux IIO (Industrial I/O) subsystem. Discovers all IIO devices and reads their current values. On Tensor/Exynos devices, this exposes per-rail power monitors (ODPM) showing real-time power consumption per SoC subsystem (CPU clusters, GPU, display, memory, TPU, GPS, etc.) — data not available through the Android sensor HAL. On other devices, may expose raw accelerometer, gyroscope, magnetometer, or ADC channels. Root required. Input parameters: - `device` (string): Device serial - `listOnly` (boolean): If true, list available IIO devices without reading values ### `adb_wifi_firmware` (~143 tokens) WiFi chipset and firmware identification. Reports WiFi driver version, firmware version, chipset/hardware info, supported bands and standards, interface details, and dumpsys excerpts. BH7 fix: dumpsys truncation now configurable via maxLines. connection state. MAC address is opt-in only (permanent hardware identifier). Input parameters: - `device` (string): Device serial - `includeMac` (boolean): Include WiFi MAC address (permanent hardware identifier — opt-in only) - `maxLines` (integer): Lines of dumpsys output to inspect (50-2000, default 200). Raise for verbose vendor builds where firmware info appears late in dumpsys output. ### `adb_bluetooth_firmware` (~123 tokens) Bluetooth firmware and chipset identification. Reports firmware version, BT version (4.x/5.x), chipset model, adapter state, supported profiles, LE capabilities, and bonded device count. MAC address and device name are opt-in only (permanent identifiers). Input parameters: - `device` (string): Device serial - `includeIdentifiers` (boolean): Include Bluetooth MAC address and device name (permanent identifiers — opt-in only) - `maxLines` (integer): Lines of dumpsys output to inspect (50-2000, default 300). Raise for verbose vendor builds. ### `adb_nfc_firmware` (~105 tokens) NFC controller firmware identification. Reports controller type (NXP/Broadcom/Samsung/ST), firmware version, NCI version, supported technologies (NFC-A/B/F/V), secure element availability (eSE/UICC), and HCE (Host Card Emulation) support. Input parameters: - `device` (string): Device serial - `maxLines` (integer): Lines of dumpsys output to inspect (50-2000, default 200). Raise for verbose vendor builds. ### `adb_gps_firmware` (~133 tokens) GNSS/GPS chipset and firmware identification. Reports GNSS hardware model (manufacturer, chip, firmware version), supported constellations (GPS, GLONASS, Galileo, BeiDou, QZSS, NavIC, SBAS), signal types with frequencies, dual-frequency (L1+L5) support, raw measurement capabilities (pseudorange access for spoofing detection), A-GPS modes (MSB/MSA — cellular-routed assisted GPS relevant to IMSI catcher research), carrier phase measurements, navigation message decoding, and SUPL server configuration. Input parameters: - `device` (string): Device serial ### `adb_input_drag` (~120 tokens) Drag from one point to another on screen. Uses Android's draganddrop input command. Useful for drag-and-drop UI elements, sliders, map panning, and reorder operations. Input parameters: - `device` (string): Device serial - `durationMs` (integer): Drag duration in ms (100-10000, default 1000) - `x1` (integer, required): Start X coordinate - `x2` (integer, required): End X coordinate - `y1` (integer, required): Start Y coordinate - `y2` (integer, required): End Y coordinate ### `adb_input_fling` (~139 tokens) Perform a high-velocity fling gesture. Like swipe but with a short duration to create scroll momentum on lists, launchers, and paged views. Useful for fast-scrolling through long lists, dismissing notifications, or triggering velocity-sensitive behaviors. Input parameters: - `device` (string): Device serial - `durationMs` (integer): Fling duration in ms (20-200, default 50). Shorter = more velocity - `x1` (integer, required): Start X coordinate - `x2` (integer, required): End X coordinate - `y1` (integer, required): Start Y coordinate - `y2` (integer, required): End Y coordinate ### `adb_input_long_press` (~97 tokens) Long press at a point on screen. Triggers context menus, selection mode, drag handles, and other long-press behaviors. Implemented as a zero-distance swipe with configurable hold duration. Input parameters: - `device` (string): Device serial - `durationMs` (integer): Hold duration in ms (300-10000, default 1500) - `x` (integer, required): X coordinate - `y` (integer, required): Y coordinate ### `adb_input_double_tap` (~88 tokens) Double tap at a point on screen. Triggers zoom, text selection, or double-tap gestures. Two rapid taps with a configurable interval. Input parameters: - `device` (string): Device serial - `intervalMs` (integer): Interval between taps in ms (20-500, default 80) - `x` (integer, required): X coordinate - `y` (integer, required): Y coordinate ### `adb_input_text` (~67 tokens) Type text on the device. Handles special characters by converting spaces to %s and escaping shell metacharacters. For multi-line or complex text, consider using the clipboard tool instead. Input parameters: - `device` (string): Device serial - `text` (string, required): Text to type on the device ### `adb_open_url` (~57 tokens) Open a URL on the device in the default browser or handling app. Uses Android's VIEW intent action. Input parameters: - `device` (string): Device serial - `url` (string, required): URL to open (must be a valid URL with scheme) ### `adb_orientation` (~103 tokens) Get or set screen orientation. Can lock to portrait, landscape, reverse portrait, reverse landscape, or restore auto-rotate. Input parameters: - `action` (string, required): 'get' to read current orientation, 'set' to change it - `device` (string): Device serial - `orientation` (string): Orientation to set (required when action='set'): auto=sensor, portrait=0°, landscape=90°, reverse_portrait=180°, reverse_landscape=270° ### `adb_clipboard` (~97 tokens) Read or write the device clipboard. Write mode sets the clipboard content; read mode retrieves it. Clipboard access requires Android 10+ and may need the app to be in foreground on Android 12+. Input parameters: - `action` (string, required): 'read' to get clipboard, 'write' to set it - `device` (string): Device serial - `text` (string): Text to write to clipboard (required when action='write') ### `adb_tap_element` (~135 tokens) Find a UI element by text, resource-id, or content-description, then tap its center. Combines UI hierarchy search with input tap in one atomic operation. More reliable than coordinate-based taps for dynamic layouts. Input parameters: - `contentDesc` (string): Match elements with this content-description (partial, case-insensitive) - `device` (string): Device serial - `index` (integer): Which match to tap if multiple found (0 = first match, default) - `resourceId` (string): Match elements with this resource-id (partial match) - `text` (string): Match elements containing this text (case-insensitive) ### `adb_wait_element` (~178 tokens) Wait for a UI element to appear or disappear. Polls the UI hierarchy at regular intervals until the condition is met or timeout expires. Useful for waiting after navigation, animations, or async content loading. Input parameters: - `condition` (string): Wait for element to 'appear' (default) or 'disappear' - `contentDesc` (string): Match elements with this content-description (partial, case-insensitive) - `device` (string): Device serial - `pollMs` (integer): Polling interval in ms (200-5000, default 500) - `resourceId` (string): Match elements with this resource-id (partial match) - `text` (string): Match elements containing this text (case-insensitive) - `timeoutMs` (integer): Maximum wait time in ms (1s-60s, default 10s) ### `adb_wait_stable` (~127 tokens) Wait for the UI to stabilize. Polls the UI hierarchy and waits until consecutive dumps produce the same element count and structure. Useful after screen transitions, animations, or content loading before interacting with elements. Input parameters: - `device` (string): Device serial - `pollMs` (integer): Polling interval in ms (200-5000, default 500) - `stableCount` (integer): Number of consecutive identical dumps required (2-10, default 2) - `timeoutMs` (integer): Maximum wait time in ms (1s-60s, default 10s) ### `adb_scroll_until` (~175 tokens) Scroll the screen repeatedly until a target element is found. Performs a swipe gesture, then checks the UI hierarchy for the target. Repeats until found or max iterations reached. Useful for finding elements in long lists or scrollable content. Input parameters: - `contentDesc` (string): Match elements with this content-description (partial, case-insensitive) - `device` (string): Device serial - `direction` (string): Scroll direction (default 'down' = content moves up, revealing lower items) - `maxScrolls` (integer): Maximum scroll attempts (1-50, default 10) - `resourceId` (string): Match elements with this resource-id (partial match) - `tapWhenFound` (boolean): Automatically tap the element when found - `text` (string): Match elements containing this text (case-insensitive) ### `adb_screenshot_compressed` (~162 tokens) Take a screenshot and pull the full-resolution PNG, plus metadata for client-side compression. Returns local file path, dimensions, file size, and a ready-to-run imagemagick command for converting to a smaller JPEG. (Android doesn't ship imagemagick, so the actual compression is post-processing — this tool sets up everything you need.) Input parameters: - `device` (string): Device serial - `filename` (string): Output filename (default: screenshot_compressed_.jpg) - `quality` (integer): JPEG quality (10-100, default 50). Lower = smaller file, more artifacts - `scale` (number): Scale factor (0.1-1.0, default 0.5). 0.5 = half resolution ### `adb_batch_actions` (~141 tokens) Execute multiple input actions in a single tool call. Reduces ADB round-trips for multi-step UI interactions. Each action runs sequentially with an optional delay between them. Supported action types: tap, swipe, fling, long_press, double_tap, keyevent, text, drag, pinch, back, home, sleep. Input parameters: - `actions` (array, required): Array of actions to execute (1-50) - `delayMs` (integer): Delay between actions in ms (0-5000, default 100) - `device` (string): Device serial - `stopOnError` (boolean): Stop execution if any action fails (default true) ### `adb_screen_size` (~53 tokens) Get the screen resolution and display density. Returns physical width, height (in pixels), and DPI density. Useful for calculating tap/swipe coordinates and understanding the UI layout grid. Input parameters: - `device` (string): Device serial ### `adb_device_state` (~61 tokens) Get a combined device state snapshot in one call: battery level/status, network connectivity, screen on/off, foreground activity, and orientation. Useful as a pre-check before UI automation or as a quick device health summary. Input parameters: - `device` (string): Device serial ### `adb_notifications` (~102 tokens) Read active notifications on the device. Parses the notification manager dump to extract package, title, text, importance, channel, and flags for each notification. Useful for verifying push notification delivery, monitoring notification state, and testing notification-related features. Input parameters: - `device` (string): Device serial - `filter` (string): Filter by package name (partial match, case-insensitive) - `maxResults` (integer): Maximum notifications to return (1-50, default 20) ### `adb_input_pinch` (~295 tokens) Perform a multi-touch pinch (zoom out) or spread (zoom in) gesture. Two fingers move symmetrically toward or away from a center point. Uses parallel swipe injection by default (universal, no root); when root is available, can use raw sendevent for true multi-touch MT protocol injection. The 'auto' method selects the best available approach. Input parameters: - `angle` (number): Angle in degrees for the pinch axis (0=horizontal, 90=vertical, default 90) - `cx` (integer, required): Center X coordinate of the pinch gesture - `cy` (integer, required): Center Y coordinate of the pinch gesture - `device` (string): Device serial - `durationMs` (integer): Gesture duration in ms (100-5000, default 500) - `endRadius` (integer, required): Ending distance (px) from center to each finger. Smaller than startRadius = pinch/zoom-out, larger = spread/zoom-in - `method` (string): Injection method: 'auto' (sendevent if root, else swipe), 'swipe' (parallel swipes, universal), 'sendevent' (raw MT protocol, requires root) - `startRadius` (integer, required): Starting distance (px) from center to each finger - `steps` (integer): Interpolation steps for sendevent method (5-60, default 20). More steps = smoother gesture ### `adb_result_list` (~81 tokens) List all result handles currently stored in this session. Returns metadata for each: tool, name, size, creation/expiry/last-access times. Use the URIs (`result:///`) with adb_result_get or by reading them as MCP Resources to retrieve stored content. Handles are scoped per-auth-token and survive server restart within their TTL. ### `adb_result_get` (~109 tokens) Retrieve the content of a stored result handle by tool name + handle name. Returns the original content blocks as the source tool produced them. Updates the handle's last-accessed time. For URI-based retrieval, read `result:///` as an MCP Resource instead. Input parameters: - `name` (string, required): Handle name supplied at storage time (e.g., 'initial') - `tool` (string, required): Source tool name (the tool that originally stored the handle, e.g., 'bugreport') ### `adb_result_drop` (~125 tokens) Delete a stored result handle, or clear all handles in this session. Either provide both `tool` and `name` to drop one specific handle, or pass `all: true` to drop everything in the current namespace. Useful for freeing up the store cap proactively or removing stale data before a sensitive operation. Input parameters: - `all` (boolean): If true, delete every handle in this namespace. tool/name must be omitted when all=true. - `name` (string): Handle name (required unless all=true) - `tool` (string): Source tool name (required unless all=true) ## Diagnostics Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/fullread-deepadb/deepadb#diagnostics ## Score history - 2026-08-03: 71 - 2026-08-02: 70 - 2026-08-01: 52 - 2026-07-31: 52 - 2026-07-30: 42 - 2026-07-29: 82 - 2026-07-28: 82 - 2026-07-27: 25 ## Links - npm package: https://www.npmjs.com/package/deepadb - Socket report: https://socket.dev/npm/package/deepadb - Repository: https://github.com/fullread/DeepADB - Changelog RSS feed: https://verifymcp.io/servers/fullread-deepadb/deepadb/changelog.xml - Changelog JSON feed: https://verifymcp.io/servers/fullread-deepadb/deepadb/changelog.json - HTML version of this page: https://verifymcp.io/servers/fullread-deepadb/deepadb