adb Skill

Run ADB commands in the SLICC shell. The bundled client speaks the ADB wire protocol directly over WebUSB; inspect it when debugging authentication or transfer errors.

Usage

adb devices                    List granted USB devices exposing an ADB interface
adb connect                    Authenticate and print the device banner
adb shell <command...>         Run a shell command, print its output
adb screencap <out.png>        Capture the framebuffer to a VFS path
adb pull <remote> <local>      Copy a file off the device (binary-safe)

sprinkle open phone-view       Live screen viewer with tap and key input

Flags — --serial <s> to pick a device, --key <path> for the signing key, --json for machine-readable output, --timeout <ms> per transfer, --no-reset to skip the USB reset on connect.

Flags must precede the subcommand, as with real adb (adb --serial X shell …). Everything after the subcommand is passed through untouched, so adb shell pm list packages --user 10 sends --user 10 to the device rather than parsing it here.

adb shell reports the device-side exit status as its own and keeps stderr separate from stdout; --json returns {command, stdout, stderr, exitCode}.

Live screen viewer

sprinkle open phone-view opens a panel that mirrors the device and lets you drive it — click the canvas to tap, plus Home / Back / Recents buttons. Input travels over the same ADB connection as the video. Connect stays disabled while connecting or disconnecting; after Stop or the end of the stream, it becomes available once interface release and device close finish.

A still screen produces almost no frames. Check the frame and byte counts while changing the phone's screen before treating an idle stream as broken.

Requires SLICC 6.135.0+ — sprinkles could not perform USB transfers before that, only list/request/open/close.

Setup

1. Grant the device. usb request needs a real user gesture — run it from the shell yourself and pick the phone in Chrome's chooser. adb devices confirms it afterwards.
2. Enable USB debugging on the phone (Settings → System → Developer options). Developer options first has to be unlocked by tapping Build number seven times under About phone.

3. Provide a signing key at /workspace/.adb/adbkey, PKCS#8 PEM. Two options:

   • Copy the host's ~/.android/adbkey to inherit its existing authorization — the device already trusts it, so no on-device prompt appears.
   • A key the device does not already trust will not work. Enrolling one needs the AUTH RSAPUBLICKEY frame, which this client does not send, so no on-device approval prompt appears — retrying cannot help (see Limitations).

   Override the path with --key, or persist one via skill config (keyPath).

4. Verify authentication. Run adb connect in SLICC and expect a device banner. If the interface is busy, stop the host adb server as described under Limitations. If the key is unauthorized, use a key the device already trusts.

Capture and retrieve an image

After setup, run these commands in the SLICC shell with the viewer stopped. For multiple devices, put --serial <serial from adb devices> before each subcommand.

adb devices
adb connect
adb shell getprop ro.product.model
adb screencap /shared/phone-screen.png
adb shell screencap -p /sdcard/Download/slicc-capture.png
adb pull /sdcard/Download/slicc-capture.png /shared/phone-pulled.png

The first capture writes directly to the VFS; the second creates a file on the phone and demonstrates pulling it back. Confirm both /shared images open and show the phone's screen. Stop and report a failed command before continuing.

How auth works

The device answers CNXN with an AUTH challenge carrying a 20-byte token. ADB signs that token as though it were a SHA-1 digest: raw PKCS#1 v1.5 with the SHA-1 DigestInfo prefix and no further hashing. Web Crypto cannot sign a pre-computed digest, so the script parses the PKCS#8 key to {n, d} and does the modular exponentiation with BigInt directly.

Security

The signing key is an ADB identity: anything holding it can drive any device that has authorized it. Putting ~/.android/adbkey in the VFS copies that identity into SLICC's IndexedDB, where any scoop with read access to /workspace can read it. Prefer a dedicated key you can revoke on the device independently. The script never prints key material.

adb shell and adb pull interpolate into a real device-side shell. pull single-quote-escapes its path; shell passes the command through verbatim by design, so treat it exactly like a local shell — never hand it unvalidated input.

Limitations

• No AUTH RSAPUBLICKEY enrollment — an unauthorized key fails with an actionable error rather than raising the on-device prompt. Adding it needs ADB's custom public-key encoding (n0inv and rr Montgomery parameters).
• No push, no install, no logcat -f — those need the sync: protocol or long-lived streams. pull uses cat over shell-v2 instead of sync:: binary-safe, far simpler, and the shell-v2 exit frame is what makes a failed read detectable, so a missing path errors instead of writing the error text over your local file. Devices that do not advertise shell_v2 (pre-Android 7) therefore cannot use pull, and shell on them reports no exit status.
• Output is buffered, not streamed — .jsh stdout is delivered on completion, so long-running commands print nothing until they finish.
• Chromium only. WebUSB is unavailable in the cloud / hosted-leader float.
• The viewer renders in SLICC, not at a URL. Frames are decoded in the browser that holds the USB grant, so there is nothing to hand to someone else. Sharing a link would need a host-side bridge that re-serves the stream.
• The viewer holds the interface for as long as it streams, so adb shell and friends cannot run at the same time from the realm. Use the viewer's own buttons, which share its connection.
• Stop the host adb server first (adb kill-server). It claims the ADB interface exclusively. The USB reset on connect does free it, but the host server re-claims it the moment the device re-enumerates, so leaving it running makes calls fail intermittently with a busy interface. With --no-reset it blocks the claim outright.