# brickproof-adb (npm · brickproof-adb)

Maintain your own Android devices and TV boxes over ADB with dry runs, guards and rollback

- Trust score: 73/100 (medium)
- Change this week: +7
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `brickproof-adb`: 73/100 (this document), [markdown](https://verifymcp.io/servers/st412m-brickproof-adb/brickproof-adb.md), [page](https://verifymcp.io/servers/st412m-brickproof-adb/brickproof-adb)

## Channel facts

- Registry: `npm`
- Package: `brickproof-adb`
- Version: `1.0.0`
- 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-11-05.

- **Supply Chain Security**: 94/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 2 of 2 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 14 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 67/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3906 tokens (~217/item across 18 items; 18 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 50/100
  - Stability observed for 15 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.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 18 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

## Install

### How do I install the brickproof-adb MCP server?

brickproof-adb runs locally as an npm package, launched with npx -y brickproof-adb. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add st412m-brickproof-adb -- npx -y brickproof-adb
```

### Cursor

```json
{
  "mcpServers": {
    "st412m-brickproof-adb": {
      "command": "npx",
      "args": [
        "-y",
        "brickproof-adb"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "st412m-brickproof-adb": {
      "command": "npx",
      "args": [
        "-y",
        "brickproof-adb"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add st412m-brickproof-adb -- npx -y brickproof-adb
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "st412m-brickproof-adb": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "brickproof-adb"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add st412m-brickproof-adb --command npx --arg -y --arg brickproof-adb
```

### Hermes

```yaml
mcp_servers:
  st412m-brickproof-adb:
    command: "npx"
    args: ["-y", "brickproof-adb"]
```

### Netclaw

```json
{
  "McpServers": {
    "st412m-brickproof-adb": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "brickproof-adb"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add st412m-brickproof-adb -t stdio -c npx -a -y brickproof-adb
```

### Other

```json
{
  "mcpServers": {
    "st412m-brickproof-adb": {
      "command": "npx",
      "args": [
        "-y",
        "brickproof-adb"
      ]
    }
  }
}
```

## 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-11-04 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-02 (score 72, +6)

- [functional improvement] Stability: unverified → 0.40

### 2026-10-22 (score 66, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-21 (score 51)

First indexed and scored.

## MCP tools (18)

### `adb_devices` (~132 tokens)

List devices

List connected Android devices with serial, state and description (adb devices -l), and remembered addresses that are not connected now. Start here: the other tools take serial from this list. If the device the user means is not in the list, call again with discover=true: it searches the local network for devices to connect (mDNS and port 5555), any time and as often as needed, and connects none of them.

Input parameters:

- `discover` (boolean): Search the local network (about 10 s) for devices with network or Wireless debugging on; returns candidates and the next step for each. Default false.

### `adb_connect` (~107 tokens)

Connect device

Connect to a device over network ADB. host is ip or ip:port (default port 5555). An Android 11+ phone with Wireless debugging is paired once with adb_pair first; after that adb_connect is enough. The reverse is adb_disconnect.

Input parameters:

- `host` (string, required): Device address: ip (port 5555 implied) or ip:port, e.g. 192.0.2.50 or 192.0.2.50:5555.

### `adb_pair` (~131 tokens)

Pair device

Pair with an Android 11+ device over Wireless Debugging, once per device and computer; afterwards adb_connect alone reconnects. On the device: Developer options -> Wireless debugging -> "Pair device with pairing code" shows ip:port and a 6-digit code. The pairing port is random and differs from the connect port; after pairing succeeds, call adb_connect with the ip:port shown on the main Wireless debugging screen.

Input parameters:

- `code` (string, required): 6-digit pairing code from the dialog
- `host` (string, required): ip:port from the pairing dialog (random port, NOT 5555)

### `adb_disconnect` (~83 tokens)

Disconnect device

Disconnect a network ADB device, the reverse of adb_connect. Omit host to disconnect every network device. adb_disconnect then adb_connect recovers a device that adb_devices lists as offline. With host the address is also forgotten and not reconnected at start.

Input parameters:

- `host` (string): ip:port as listed by adb_devices. Omit to disconnect all network devices.

### `adb_shell` (~171 tokens)

Run shell command

Run a shell command on the device (settings, pm, am, dumpsys, getprop, wm, cmd, svc...) and return stdout. It bypasses every guard rail, so it works only while the server option allow_shell is on. For package changes use adb_app instead: dry runs, a protected set, a network guard and a rollback snapshot.

Input parameters:

- `command` (string, required): Command line for the device shell, e.g. "getprop ro.build.version.release". Logged verbatim with log_requests: type secrets with adb_text instead.
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.
- `timeout_sec` (number): Time limit in seconds, default 30, at most 120. Past it the call fails with "timed out".

### `adb_screenshot` (~197 tokens)

Take screenshot

Take a screenshot of the device screen. Returns a JPEG image, then a text line with the logical screen size, the image size and the scale between them, e.g. "screen 1080x2340 -> image 473x1024 · scale 2.283/2.285". Pass coords="screenshot" to adb_tap/adb_swipe to tap coordinates read off that image. A near-uniformly dark frame is a warning after the image, not a refusal. To read labels and exact tap points, adb_ui_dump is cheaper and precise; the screenshot shows what the dump cannot (images, video, games).

Input parameters:

- `max_px` (number): Max dimension 320-1920, default 1024
- `quality` (number): JPEG quality 30-95, default 70
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.

### `adb_ui_dump` (~111 tokens)

Dump UI hierarchy

Dump the current UI hierarchy (uiautomator) as a compact list of interactive/labeled elements with tap coordinates @(x,y). Password fields are marked [PASSWORD] and listed even with no visible text. Use together with adb_tap. Prefer it over adb_screenshot for labels and tap targets; use adb_screenshot for content the dump does not see (images, video, some WebViews and games).

Input parameters:

- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.

### `adb_tap` (~284 tokens)

Tap

Tap at (x, y). coords="screen" (default): coordinates from adb_ui_dump, the logical space input tap uses. coords="screenshot": coordinates off the last adb_screenshot for the SAME serial, rescaled; missing or older than 120s is refused. Rotation between screenshot and tap is not checked. verify="activity"|"ui" reports whether the tap changed anything; a failed verify never turns a performed tap into an error. To activate an element by its label, adb_find_and_tap does it in one call and also works on TV boxes without a touchscreen.

Input parameters:

- `coords` (string): Coordinate space, default "screen". "screenshot" = pixels read off the last adb_screenshot image for this serial, rescaled automatically; refused if that screenshot is missing or older than 120s.
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.
- `verify` (string): Default "none". "activity" compares the resumed activity before/after. "ui" also hashes the UI dump (~2-4s); a clock or timer ticking on its own can make it report "changed". "unchanged" is reliable.
- `x` (number, required): X in pixels, in the space chosen by coords.
- `y` (number, required): Y in pixels, same space.

### `adb_swipe` (~274 tokens)

Swipe

Swipe from (x1,y1) to (x2,y2) over duration_ms (default 300). The same point at both ends with duration_ms >= 800 is a long-press. coords and verify work as in adb_tap and both endpoints share one coordinate space; with verify="ui", an "unchanged" result on a swipe usually means the end of a scrollable list. On a TV box without a touchscreen, move the focus with adb_key DPAD_* instead.

Input parameters:

- `coords` (string): Coordinate space for BOTH endpoints, default "screen". See adb_tap for the "screenshot" semantics and its 120s TTL.
- `duration_ms` (number): Duration in ms, default 300.
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.
- `verify` (string): See adb_tap. For a swipe, "ui" reporting "unchanged" usually means you hit the end of a scrollable list rather than that nothing happened.
- `x1` (number, required): Start X in pixels, in the space chosen by coords.
- `x2` (number, required): End X in pixels.
- `y1` (number, required): Start Y in pixels.
- `y2` (number, required): End Y in pixels.

### `adb_text` (~189 tokens)

Type text

Type text into the focused input field. Focus the field first; on a TV box, DPAD_CENTER on the field opens the keyboard. For single keys (ENTER, BACK) use adb_key. ASCII goes through input text; non-ASCII (Cyrillic, emoji, CJK) is sent via the ADBKeyBoard IME, which must be installed on the device (github.com/senzhk/ADBKeyBoard): the current keyboard is switched to it and restored afterwards. The response reports only the character count, never the text itself. Never retry a wrong password or PIN: repeated failures can lock the account or device. Stop and ask the user.

Input parameters:

- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.
- `text` (string, required): Text to type into the focused field. Only its length appears in the response and the log.

### `adb_key` (~176 tokens)

Send key

Send a keyevent. Accepts names (HOME, BACK, ENTER, DPAD_UP, POWER, VOLUME_UP, MENU, TAB...) or numeric codes. On TV boxes DPAD_UP/DOWN/LEFT/RIGHT move the focus and DPAD_CENTER presses it. verify="activity"|"ui" reports whether the key changed anything; see adb_tap for the same parameter. For text use adb_text; for a labelled element, adb_find_and_tap.

Input parameters:

- `key` (string, required): Key name (HOME, BACK, ENTER, DPAD_CENTER, WAKEUP...; the KEYCODE_ prefix is optional) or a numeric keycode.
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.
- `verify` (string): Default "none". See adb_tap.

### `adb_find_and_tap` (~325 tokens)

Find and tap element

Find an on-screen element by text, resource-id or content-desc and activate it.
The method is derived from the device: with a touchscreen the element centre is tapped; on leanback without one the focus is walked there with DPAD keys, since a coordinate tap activates whatever has focus.
If the focus stalls, cycles, or the target is not reached in max_steps or the time budget, nothing is pressed and the tool reports where it stopped.
Prefer it over adb_ui_dump plus adb_tap when the label is known; use adb_tap for a point that has no label.

Input parameters:

- `desc` (string): content-desc to match
- `exact` (boolean): Require an exact match instead of substring. Default false.
- `index` (number): Which match to use when several elements match. Without it, several matches are an error listing the candidates.
- `max_steps` (number): Max DPAD steps on leanback devices, default 12, max 40. Each step re-dumps the UI (~1.5-2s) and the walk also stops after an internal ~25s budget, returning a report instead of timing out.
- `resource_id` (string): resource-id; the part after "/" is enough
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.
- `text` (string): Visible label to match, checked against both the text attribute and content-desc (substring by default, case-insensitive). Some TV launchers put every label in content-desc and leave text empty.

### `adb_install` (~414 tokens)

Install app

Installs only with dry_run=false; by default it reports what would be installed and installs nothing.
Installs an APK from the server's file roots (file_roots). apk_path takes a single .apk, an array of split-APK paths, or one .apks/.xapk/.apkm bundle.
Without apk_path it installs nothing and lists the installable files in file_roots, newest first, with the full path to pass as apk_path: start there when the user says "install what I downloaded".
Bundle splits are chosen from the device ABI list, density and locale. No matching ABI split is a refusal; a density mismatch is not.
Flags -r, -t and -g are applied by default. The reverse is adb_uninstall, or adb_app for a removal with a backup and a rollback.

Input parameters:

- `abi` (string): Bundle only: force an ABI instead of the device default (e.g. armeabi-v7a)
- `apk_path` (string|array): Single APK path, array of split-APK paths, or one .apks/.xapk/.apkm bundle. Without it: a list of the installable files in file_roots, newest first; nothing is installed.
- `density` (number): Bundle only: force a screen density in dpi instead of the device value
- `dir` (string): Only without apk_path: the list shows the top level and one level of subfolders; for a deeper folder pass it here, listed the same way. Ignored when apk_path is given.
- `dry_run` (boolean): Default true: report the files, the command and the device (for a bundle, also the chosen splits) and install nothing. Only false installs.
- `locales` (string|array): Bundle only: extra language splits to include alongside the device language (e.g. ["ru"] on an en-US device)
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.

### `adb_uninstall` (~115 tokens)

Uninstall app

Uninstall an app by package name, at once and without a backup. keep_data=true keeps app data (-k). The reverse is adb_install. For system packages, reversible bulk operations and backups, use adb_app.

Input parameters:

- `keep_data` (boolean): Keep the app data and cache (-k). Default false.
- `package` (string, required): Package name, e.g. com.example.app (adb_app action=list lists them).
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.

### `adb_push` (~120 tokens)

Push file to device

Copy a file from the server's file roots (file_roots) to the device, overwriting a file of the same name there. To install an APK use adb_install instead. The reverse is adb_pull.

Input parameters:

- `device_path` (string, required): Destination on the device, e.g. /sdcard/Download/file.apk or /data/local/tmp/.
- `host_path` (string, required): Absolute path of the file on the server, inside file_roots.
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.

### `adb_pull` (~106 tokens)

Pull file from device

Copy a file from the device into the server's file roots (file_roots), overwriting a file of the same name and creating missing directories. The reverse is adb_push.

Input parameters:

- `device_path` (string, required): File on the device, e.g. /sdcard/Download/report.pdf.
- `host_path` (string, required): Absolute destination path on the server, inside file_roots.
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.

### `adb_logcat` (~197 tokens)

Read logcat

Read recent logcat lines without waiting for new ones, e.g. to see why an app crashed; unlike adb_shell it works with allow_shell off. filter: either a logcat filterspec like "ActivityManager:I *:S" (contains ":" or "*"; *:S is auto-appended if missing so unmatched tags are silenced) or a plain substring grepped case-insensitively across the whole line. lines limits the result (default 200). Filtering runs on the device.

Input parameters:

- `filter` (string): A filterspec such as "ActivityManager:I *:S" (has ":" or "*"), or a plain substring matched case-insensitively. Omit for the last lines unfiltered.
- `lines` (number): How many lines to return, default 200, at most 2000.
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.

### `adb_app` (~774 tokens)

Manage packages

Package operations with guard rails: inspect, launch, stop, clear, disable, uninstall, back up and restore packages. Use it rather than adb_shell or adb_uninstall for package changes.
Every action that changes packages defaults to dry_run=true. A protected set derived from the device (launcher, active IME, installer, WebView provider, role holders, account packages) aborts the whole call on any overlap, and has no override.
A network guard refuses disable, uninstall, stop and clear while the package is serving an off-device client, naming the port and the peer. Only force_network=true lifts it; force covers a failed APK backup and nothing else.
An account canary between batches rolls a batch back and stops on a drop. Everything applied goes into a snapshot, so action=restore undoes it. mode=uninstall also needs the server option allow_uninstall and a successful APK backup.
action=launch also accepts uri and/or intent_action for an intent or deep link; CALL, CALL_PRIVILEGED and CALL_EMERGENCY are refused while allow_shell is false.

Input parameters:

- `action` (string, required): list/info/protected/state only read. launch/stop/clear act at once (clear defaults to dry_run), stop/clear under the network guard. disable/uninstall/enable/restore default to dry_run.
- `backup` (boolean): Pull APKs before removing. Default true for uninstall, false for disable.
- `batch_size` (number): Packages per batch between canary checks, default 5, max 25
- `canary` (boolean): Check the account count and the launcher between batches, default true. Turning it off removes the only automatic check for a latent breakage.
- `dry_run` (boolean): Default true for state-changing actions. Set false to actually apply.
- `extras` (object|string): action=launch only: intent extras. string -> --es, boolean -> --ez, int32 integer -> --ei, larger integer -> --el; anything else is refused by key name. A JSON-stringified object is accepted too.
- `filter` (string): action=list only, default user
- `force` (boolean): Proceed even if the APK backup failed. Off by default. It does not affect the network guard; see force_network.
- `force_network` (boolean): Override the network guard for disable, uninstall, stop and clear: act on a package that is currently serving an off-device client. It does NOT override the protected set. Off by default.
- `intent_action` (string): action=launch only: intent action, default android.intent.action.VIEW when uri is set. Must match [A-Za-z0-9_.]+. See the CALL refusal note above.
- `mode` (string): How to remove: disable (default) is undone by action=enable or restore; uninstall needs allow_uninstall.
- `packages` (string|array): Package name or array of package names. For action=launch with uri/intent_action, at most one package is accepted (used as -p to narrow the resolver); it is otherwise optional there.
- `q` (string): action=list only: case-insensitive substring filter
- `scope` (string): action=backup only: what to back up when packages is omitted (default user)
- `serial` (string): Device serial from adb_devices. Optional when exactly one device is connected.
- `store` (string): Where snapshots and APK backups live: by default the snapshot store (setting store). Another path must be inside file_roots.
- `uri` (string): action=launch only: deep-link / intent data URI (am start -d). Its presence, together with intent_action, selects the intent-based launch instead of resolving the package's main activity.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/st412m-brickproof-adb/brickproof-adb#diagnostics

## Score history

- 2026-11-05: 73
- 2026-11-04: 73
- 2026-11-03: 72
- 2026-11-02: 72
- 2026-11-01: 66
- 2026-10-31: 66
- 2026-10-30: 66
- 2026-10-29: 66
- 2026-10-28: 66
- 2026-10-27: 66
- 2026-10-26: 66
- 2026-10-25: 66
- 2026-10-24: 66
- 2026-10-23: 66
- 2026-10-22: 66
- 2026-10-21: 51

## Common questions

### What is the brickproof-adb MCP server?

brickproof-adb is an MCP server listed in the public MCP registry as io.github.st412m/brickproof-adb. Maintain your own Android devices and TV boxes over ADB with dry runs, guards and rollback. This page covers its npm package (brickproof-adb).

### Is the brickproof-adb MCP server safe to use?

brickproof-adb scores 73 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the brickproof-adb MCP server expose?

brickproof-adb exposes 18 tools: adb_devices, adb_connect, adb_pair, adb_disconnect, adb_shell, and 13 more. Their descriptions and schemas cost roughly 3,906 tokens of context every time the server is loaded.

### Is the brickproof-adb MCP server still maintained?

brickproof-adb is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the brickproof-adb MCP server under?

brickproof-adb declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/brickproof-adb
- Socket report: https://socket.dev/npm/package/brickproof-adb
- Repository: https://github.com/st412m/brickproof-adb
- Changelog RSS feed: https://verifymcp.io/servers/st412m-brickproof-adb/brickproof-adb.xml
- Changelog JSON feed: https://verifymcp.io/servers/st412m-brickproof-adb/brickproof-adb.json
- HTML version of this page: https://verifymcp.io/servers/st412m-brickproof-adb/brickproof-adb