Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
ADB_PATHNoPath to ADB binary (ignored in on-device mode)Auto-detect
DA_LOCALNoForce on-device mode (true/false). Auto-detects via /system/build.propAuto-detect
DA_DEVICENoDefault device serial (auto-selects if single device)(auto)
DA_TIMEOUTNoDefault command timeout in milliseconds30000
DA_WS_PORTNoSet to a port number to enable WebSocket transport mode (requires npm install ws)(disabled)
DA_SECURITYNoEnable security middleware (command filtering, rate limiting)false
DA_TEMP_DIRNoTemp directory for screenshots, pulled files, bug reports, test sessions, snapshotsOS temp
DA_AUDIT_LOGNoLog all executed commands for audit trail (set to false to disable)true
DA_CACHE_TTLNoDevice list cache TTL in milliseconds (0 = disabled)5000
DA_HTTP_HOSTNoBind address for HTTP/SSE, WebSocket, and GraphQL servers127.0.0.1
DA_HTTP_PORTNoSet to a port number to enable HTTP/SSE transport mode(disabled)
DA_LOG_LEVELNoLog level: debug, info, warn, errorinfo
DA_AUTH_TOKENNoBearer token for network transports. When set, all HTTP/SSE/WS/GraphQL requests require Authorization: Bearer <token> header. Health endpoints exempt.(none — open)
DA_MAX_LOGCATNoMax logcat lines per snapshot500
DA_MAX_OUTPUTNoMax output characters before truncation50000
DA_PLUGIN_DIRNoDirectory to scan for plugin .js modules at startup{tempDir}/plugins
DA_RATE_LIMITNoMax commands per minute (0 = unlimited)0
DA_RETRY_COUNTNoNumber of retries for transient ADB failures1
DA_RETRY_DELAYNoBase retry delay in ms (doubles each attempt)500
DA_GRAPHQL_PORTNoSet to a port number to enable the GraphQL API endpoint (requires npm install graphql)(disabled)
DA_REGISTRY_URLNoURL of the community plugin registry JSON manifestGitHub default
DA_WS_CORS_ORIGINNoAllowed CORS origin for WebSocket health endpoint(none — deny)
DA_ALLOWED_COMMANDSNoComma-separated allowlist (if set, only matching commands run)(none)
DA_BLOCKED_COMMANDSNoComma-separated list of blocked shell command substrings(none)
DA_HTTP_CORS_ORIGINNoAllowed CORS origin for HTTP/SSE(none — deny)
DA_GRAPHQL_CORS_ORIGINNoAllowed CORS origin for GraphQL API(none — deny)
DA_WORKFLOW_REGISTRY_URLNoURL of the workflow marketplace JSON manifest(derived from DA_REGISTRY_URL)

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
prompts
{
  "listChanged": true
}
resources
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
adb_devicesA

List all connected Android devices with their state, model, and product info

adb_device_infoB

Get detailed properties for a connected device (model, OS version, build, etc.)

adb_getpropA

Get a specific Android system property, or all properties if no key given

adb_shellC

Execute a shell command on the Android device. Returns stdout and stderr.

adb_root_shellB

Execute a command as root via su. Requires rooted device.

adb_installB

Install an APK on the device. Provide the full local path to the APK file.

adb_uninstallC

Uninstall a package from the device

adb_list_packagesC

List installed packages. Supports filtering by name.

adb_package_infoB

Get detailed info about an installed package (version, permissions, paths)

adb_clear_dataA

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: <packageName> to proceed.

adb_grant_permissionC

Grant a runtime permission to a package

adb_revoke_permissionA

Revoke a runtime permission from a package. Useful for resetting permission state to test first-run flows or denial handling.

adb_list_permissionsA

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.

adb_force_stopB

Force-stop an app immediately. The most common debugging action.

adb_start_appA

Launch an app by package name (resolves and starts the default launcher activity)

adb_restart_appB

Force-stop then re-launch an app. The most frequent debugging workflow in a single call.

adb_resolve_intentsB

Discover all activities, services, and receivers registered by a package with their intent filters

adb_pushB

Push a local file to the device filesystem. Pre-flight checks: hard-blocked kernel paths, filesystem type warnings, symlink resolution, and destination storage availability.

adb_pullC

Pull a file from the device to local filesystem

adb_lsC

List files and directories on the device

adb_catC

Read a text file from the device

adb_file_writeA

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.

adb_findA

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.

adb_file_statA

Get detailed file metadata: size, permissions, ownership, timestamps (access/modify/change), SELinux security context, and file type. Read-only operation.

adb_file_checksumA

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.

adb_mkdirC

Create a directory on the device. Supports -p flag for creating parent directories.

adb_rmA

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.

adb_file_moveA

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.

adb_file_copyB

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.

adb_file_chmodA

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.

adb_file_touchA

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.

adb_file_fsinfoA

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.

adb_file_chownA

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.

adb_grepA

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.

adb_file_replaceB

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.

adb_logcatB

Capture a logcat snapshot. Supports tag filtering, priority levels, and grep patterns.

adb_logcat_clearB

Clear all logcat buffers on the device

adb_logcat_crashC

Get recent crash logs from the crash buffer

adb_dumpsysB

Run dumpsys for a specific service. Use 'list' as the service to see all available services.

adb_telephonyC

Get telephony state including cell info, signal strength, and network registration.

adb_batteryB

Get battery status, level, temperature, and charging info

adb_networkB

Get network connectivity info including WiFi, cellular, and active connections

adb_topC

Get current CPU and memory usage snapshot

adb_perf_snapshotB

Capture a performance snapshot for a package: memory usage, frame stats, and CPU info in one call.

adb_bugreportA

Capture a full bug report zip (device state, logs, dumpsys, system info). Returns the local file path.

adb_crash_logsA

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.

adb_heap_dumpA

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.

adb_screencapB

Take a screenshot and save to local filesystem. Returns the file path.

adb_current_activityB

Get the currently focused activity and window stack

adb_inputC

Send input events to the device (tap, swipe, text, keyevent)

adb_start_activityC

Start an activity or app by intent or component name

adb_ui_dumpA

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.

adb_ui_findA

Search the UI hierarchy for elements matching text, resource-id, or content-description. Returns matching elements with coordinates for precise adb_input targeting.

adb_screencap_annotatedA

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.

adb_screen_stateA

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.

adb_gradleC

Run a Gradle task in an Android project directory

adb_build_and_installB

Build a debug APK and install it on the connected device (convenience wrapper)

adb_health_checkA

Run a comprehensive health check of the ADB toolchain. Validates: ADB binary, server, device connection, authorization, and root access.

adb_runtime_auditB

Run a unified, read-only DeepADB readiness audit covering transport, authorization, Android state, root, SELinux, storage, common binaries, UI/network support, SQLite, chipset/modem nodes, and Wear prerequisites. Makes no device changes.

adb_pairA

Pair with a device over WiFi using the pairing code from Developer Options → Wireless debugging → Pair device

adb_connectA

Connect to a device over WiFi/TCP. Device must be paired first or have TCP/IP enabled.

adb_disconnectA

Disconnect from a wireless device, or all wireless devices if no host specified

adb_tcpipA

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.

adb_airplane_modeB

Toggle airplane mode on/off. Useful for resetting cellular registration during radio testing.

adb_wifiC

Enable or disable WiFi

adb_mobile_dataC

Enable or disable mobile data

adb_locationC

Enable or disable location services

adb_screenA

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.

adb_airplane_cycleA

Cycle airplane mode on then off after a delay. Forces cellular re-registration — useful for radio diagnostics and network testing.

adb_settings_getB

Read an Android settings value from any namespace (system, secure, global)

adb_settings_putC

Write an Android settings value to any namespace (system, secure, global)

adb_rebootB

Reboot the device. Supports normal, recovery, and bootloader modes.

adb_logcat_startA

Start a background logcat watcher. Lines accumulate in a ring buffer. Use adb_logcat_poll to retrieve new entries.

adb_logcat_pollA

Retrieve new logcat lines since the last poll from a running watcher session.

adb_logcat_stopC

Stop a running logcat watcher session

adb_logcat_sessionsB

List all active logcat watcher sessions

adb_forwardB

Forward a local port to a port on the device (host → device). Use for connecting to services running on the device.

adb_reverseA

Reverse-forward a device port to a port on the host (device → host). Use for letting device apps reach services on your machine.

adb_forward_listB

List all active port forwards and reverse forwards

adb_forward_removeA

Remove a port forward (host → device), or all forwards. Use after testing to clean up.

adb_reverse_removeB

Remove a reverse forward (device → host), or all reverse forwards. Use after testing to clean up.

adb_tunnel_openA

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.

adb_tunnel_listA

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.

adb_tunnel_closeA

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.

adb_screenrecord_startA

Start recording the device screen. Recording runs on-device. Use adb_screenrecord_stop to finish and pull the video file.

adb_screenrecord_stopA

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.

adb_avd_listB

List all available Android Virtual Devices (AVDs) that can be started.

adb_emulator_startB

Launch an Android Virtual Device (AVD) emulator. Returns once the emulator process has started.

adb_emulator_stopB

Stop a running emulator. Uses 'adb emu kill' for graceful shutdown.

adb_qemu_setupA

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.

adb_qemu_imagesB

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.

adb_qemu_startA

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.

adb_qemu_stopA

Stop a running QEMU virtual machine. Sends SIGTERM for graceful shutdown, with force kill option.

adb_qemu_statusA

Show status of QEMU virtual machines — running VMs with resource usage and port mappings, plus KVM and QEMU availability.

adb_qemu_connectA

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.

adb_qemu_disconnectA

Disconnect from a QEMU VM's ADB service. Removes the guest from the device list.

adb_qemu_guest_shellA

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.

adb_test_session_startA

Start a structured test session. Creates a named directory for organizing numbered screenshots and logcat captures.

adb_test_stepA

Capture a numbered test step: takes a screenshot and captures logcat since the last step. Saves both to the session directory.

adb_test_session_endA

End the active test session. Writes a summary manifest and returns the session directory path.

adb_multi_shellA

Execute a shell command on multiple (or all) connected devices in parallel. Returns results grouped by device.

adb_multi_installB

Install an APK on multiple (or all) connected devices in parallel.

adb_multi_compareB

Run a command on all devices and compare outputs side by side. Highlights differences across devices.

adb_multi_testA

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.

adb_snapshot_captureB

Capture a comprehensive device state snapshot: installed packages, key settings, and system properties. Saves to a JSON file.

adb_snapshot_compareA

Compare current device state against a saved snapshot. Shows added/removed packages, changed settings, and property differences.

adb_snapshot_restore_settingsA

Restore settings from a saved snapshot to the current device. Only restores global and secure settings — does not install/uninstall packages.

adb_tcpdump_startA

Start a packet capture on the device using tcpdump. Requires root or tcpdump binary on device. Capture runs in background.

adb_tcpdump_stopA

Stop an active packet capture and pull the pcap file locally for analysis.

adb_network_connectionsB

Show active network connections on the device (TCP/UDP). Similar to netstat — shows established connections, listening ports, and connection states.

adb_ci_wait_bootB

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.

adb_ci_device_readyA

Comprehensive CI readiness check. Verifies: device online, booted, package manager ready, screen unlocked, network available. Returns structured pass/fail results.

adb_ci_run_testsA

Run Android instrumented tests (androidTest) via am instrument and capture results. Returns structured pass/fail output.

adb_plugin_listA

List all loaded plugins and the plugin directory path.

adb_plugin_infoA

Show information about the plugin system: directory, how to create plugins, and loaded plugin count.

adb_baseband_infoC

Get comprehensive modem/baseband identification: firmware version, RIL implementation, chipset, IMEI, SIM state, and radio capabilities.

adb_cell_identityB

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.

adb_signal_detailB

Get detailed signal strength measurements: RSRP, RSRQ, SINR, RSSI, timing advance, and signal bars. Provides raw radio measurements for signal analysis and anomaly detection.

adb_neighboring_cellsB

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.

adb_carrier_configB

Dump carrier configuration values. Useful for verifying carrier settings, detecting configuration anomalies, and inspecting APN configurations.

adb_modem_logsB

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.

adb_a11y_auditA

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.

adb_a11y_touch_targetsB

List all interactive elements with their touch target dimensions in dp. Highlights elements below the 48dp minimum. Useful for quickly identifying cramped UI layouts.

adb_a11y_treeA

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.

adb_regression_baselineA

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.

adb_regression_checkB

Compare current performance against a saved baseline. Flags regressions in memory (>20% increase), CPU (>50% increase), and jank rate (>25% increase). Thresholds are configurable.

adb_regression_historyB

List all saved regression baselines, optionally filtered by package name. Shows trends over time.

adb_farm_runB

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.

adb_farm_resultsA

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.

adb_farm_matrixA

List available device models and API levels on Firebase Test Lab. Use to plan test matrices.

adb_registry_searchA

Search the community plugin registry for available plugins. Shows name, description, version, and author. Fetches the latest manifest from the configured registry URL.

adb_registry_installA

Install a plugin from the community registry by name. Downloads the plugin JavaScript file into the plugins directory. Restart DeepADB to load it.

adb_registry_installedA

List all locally installed plugins with their versions and metadata. Shows which plugins have updates available in the registry.

adb_shannon_sessionA

Preflight a Samsung Shannon/Exynos modem session by checking the chipset, root access, known AT ports, and a benign AT handshake together. Optionally sends ATI for identification after a successful handshake. Makes no modem configuration changes.

adb_at_detectA

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.

adb_at_sendA

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.

adb_at_batchB

Send multiple AT commands sequentially and capture all responses. Useful for running a diagnostic sequence. Requires root.

adb_at_probeA

Run a standard AT diagnostic probe: modem identification, signal quality, network registration, SIM status, and supported bands. Requires root.

adb_at_cross_validateA

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.

adb_screenshot_baselineA

Capture a named screenshot baseline for later comparison. Saves the screenshot and metadata to the baselines directory.

adb_screenshot_diffA

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.

adb_screenshot_historyB

List all saved screenshot baselines with their metadata (timestamp, dimensions, device, file size).

adb_workflow_runB

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.

adb_workflow_validateA

Validate a workflow JSON definition without executing it. Reports structural errors and shows the execution plan.

adb_workflow_listB

List saved workflow files in the workflows directory.

adb_install_bundleB

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).

adb_list_splitsA

List all APK split paths installed for a package. Shows the base APK and any configuration splits (language, screen density, ABI).

adb_extract_apksB

Pull all APK splits for a package from the device to a local directory. Useful for analysis, backup, or transfer to another device.

adb_apex_listA

List installed APEX modules on the device. APEX (Android Pony EXpress) modules deliver updatable system components. Shows module name, version, and active/staged status.

adb_mirror_startB

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.

adb_mirror_stopA

Stop an active scrcpy mirroring session for a device.

adb_mirror_statusA

Check scrcpy availability and list active mirroring sessions.

adb_test_gen_from_uiA

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.

adb_test_gen_from_intentsA

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.

adb_test_gen_saveB

Save a generated workflow JSON to the workflows directory for later execution with adb_workflow_run.

adb_ota_fingerprintA

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.

adb_ota_checkB

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.

adb_ota_historyA

List all saved system fingerprints for a device, showing version progression over time. Highlights changes between consecutive snapshots.

adb_ril_startC

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.

adb_ril_pollB

Retrieve captured RIL messages since the last poll. Optionally filter by category (registration, cell_info, signal, network, security, handover, data, radio_state, nas).

adb_ril_stopB

Stop a RIL capture session. Shows a summary of captured message categories.

adb_profile_detectA

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.

adb_profile_saveA

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.

adb_profile_listB

List all device profiles: built-in library entries and user-saved profiles.

adb_firmware_probeA

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.

adb_firmware_diffA

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.

adb_firmware_historyB

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.

adb_market_searchB

Search the workflow marketplace for community-shared workflow definitions. Shows name, description, tags, author, and step count. Indicates which workflows are already installed locally.

adb_market_installB

Download and install a workflow from the marketplace. Saves to the workflows directory for immediate use with adb_workflow_run.

adb_market_exportA

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.

adb_selinux_statusA

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.

adb_selinux_denialsB

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.

adb_permission_auditB

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.

adb_thermal_snapshotA

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.

adb_thermal_compareA

Compare current thermal/power state against a saved baseline. Reports temperature changes per zone, CPU frequency shifts, and battery drain rate differences.

adb_battery_drainA

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.

adb_network_scanA

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.

adb_network_device_ipA

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.

adb_network_auto_connectA

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.

adb_app_route_contextA

Show the effective Android routing context for one installed app by correlating its UID with ip rules, route tables, network policy, VPN, and default-network state. Read-only; does not alter routes or app policy.

adb_sqlite_inspectA

Safely inspect a Room or SQLite database inside an installed app. Lists package databases, shows schema, or executes one validated read-only query. Requires a debuggable app (run-as) or root; queries a bounded private snapshot with device sqlite3 or an isolated host SQLite process.

adb_wear_datalayer_preflightA

Run a read-only Wear OS Data Layer preflight across a connected phone and watch. Checks device roles, Google Play services, Bluetooth, optional app packages, companion association presence, and Data Layer service signals without exposing pairing identifiers.

adb_sensor_readA

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.

adb_iio_readA

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.

adb_wifi_firmwareC

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).

adb_bluetooth_firmwareA

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).

adb_nfc_firmwareB

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.

adb_gps_firmwareB

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.

adb_input_dragA

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.

adb_input_flingA

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.

adb_input_long_pressA

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.

adb_input_double_tapA

Double tap at a point on screen. Triggers zoom, text selection, or double-tap gestures. Two rapid taps with a configurable interval.

adb_input_textA

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.

adb_open_urlA

Open a URL on the device in the default browser or handling app. Uses Android's VIEW intent action.

adb_orientationB

Get or set screen orientation. Can lock to portrait, landscape, reverse portrait, reverse landscape, or restore auto-rotate.

adb_clipboardA

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+.

adb_tap_elementA

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.

adb_wait_elementA

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.

adb_wait_stableA

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.

adb_scroll_untilB

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.

adb_screenshot_compressedA

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.)

adb_batch_actionsB

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.

adb_screen_sizeA

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.

adb_device_stateA

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.

adb_notificationsB

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.

adb_input_pinchA

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.

adb_result_listA

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://<tool>/<name>) 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_getA

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://<tool>/<name> as an MCP Resource instead.

adb_result_dropA

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.

Prompts

Interactive templates invoked by user choice

NameDescription
debug-crashGuided workflow: Capture crash information for debugging. Clears logcat, waits for reproduction, then captures crash buffer and device state.
deploy-and-testGuided workflow: Build, install, launch, and start monitoring an app in one sequence.
telephony-snapshotGuided workflow: Capture comprehensive telephony and cellular state for radio diagnostics.
airplane-cycle-testGuided workflow: Test cellular re-registration by cycling airplane mode while monitoring logs.

Resources

Contextual data attached and managed by the client

NameDescription
devices-listList of all connected Android devices

TDQS

B3.1/5.0

Scored across 209 tools

Disambiguation2/5

Many tools overlap in purpose: adb_screencap, adb_screencap_annotated, adb_screenshot_compressed, adb_screenshot_baseline, adb_screen_state, adb_device_state, and adb_current_activity all partially overlap on screenshots/state. Likewise adb_input vs. adb_input_tap/swipe/text/drag/fling/long_press/double_tap/pinch/batch_actions, and adb_health_check vs. adb_runtime_audit vs. adb_ci_device_ready create real selection ambiguity. Descriptions help, but an agent can easily pick a plausible-but-suboptimal tool.

Naming Consistency4/5

Nearly all tools use the adb_ prefix with snake_case and mostly action-oriented names, which is predictable. Minor deviations exist in ordering and abstraction level (adb_file_chmod vs. adb_chmod-style naming, adb_screen vs. adb_screencap, and mixed resource/action ordering), but the convention is still readable.

Tool Count1/5

209 tools is far beyond what is appropriate even for a broad ADB automation platform, and many tools are narrow wrappers or convenience combinations. The surface is large enough to overwhelm tool selection and materially increases the chance of misselection.

Completeness4/5

Coverage is unusually broad: device management, file operations, UI automation, input, networking, telephony/radio, firmware, QEMU, testing, workflows, and plugins are all represented. There are minor lifecycle gaps such as deletion/cleanup for saved profiles, baselines, or workflows, but core workflows are well covered.

Maintenance

ActivityMaintained
ResponsivenessLimited data