Your agent's phone, over plain HTTP.

# the key you received with early access
export ERIUS_KEY="<your api key>"
export ERIUS_API="https://api.eriusphone.com"

# 1. which devices does this key control?
curl -s -H "X-API-Key: $ERIUS_KEY" $ERIUS_API/whoami
# → {"tenant": "your-team", "keyId": "k1", "devices": ["dev_7f3a"]}

# 2. take a screenshot (full-size PNG; add ?format=jpeg&scale=0.5 for a small, fast one)
curl -s -H "X-API-Key: $ERIUS_KEY" -o step_01.png $ERIUS_API/device/dev_7f3a/screenshot

# 3. tap a coordinate you picked from the screenshot
curl -s -H "X-API-Key: $ERIUS_KEY" -H 'Content-Type: application/json' \
  -d '{"x": 360, "y": 640}' $ERIUS_API/device/dev_7f3a/tap
# → {"ok": true}

# 4. or open an app, read the screen as a tree and tap by label instead
curl -s -H "X-API-Key: $ERIUS_KEY" -H 'Content-Type: application/json' \
  -d '{"package": "com.android.settings"}' $ERIUS_API/device/dev_7f3a/stop
curl -s -H "X-API-Key: $ERIUS_KEY" -H 'Content-Type: application/json' \
  -d '{"package": "com.android.settings"}' $ERIUS_API/device/dev_7f3a/launch
curl -s -H "X-API-Key: $ERIUS_KEY" "$ERIUS_API/device/dev_7f3a/snapshot?format=text"
# → … - Group [ref=4]  - Text "Network & internet" …
curl -s -H "X-API-Key: $ERIUS_KEY" -H 'Content-Type: application/json' \
  -d '{"text": "Network & internet"}' $ERIUS_API/device/dev_7f3a/tap
# → {"ok": true}

# 5. screenshot again to see the result
curl -s -H "X-API-Key: $ERIUS_KEY" -o step_02.png $ERIUS_API/device/dev_7f3a/screenshot

claude mcp add erius-phone \
  -e ERIUS_PHONE_API_KEY=your-api-key \
  -e ERIUS_PHONE_DEFAULT_DEVICE=your-device-id \
  -- uvx erius-phone-mcp

{
  "mcpServers": {
    "erius-phone": {
      "command": "uvx",
      "args": ["erius-phone-mcp"],
      "env": {
        "ERIUS_PHONE_API_KEY": "your-api-key",
        "ERIUS_PHONE_DEFAULT_DEVICE": "your-device-id"
      }
    }
  }
}

Install build/app-release.apk on my ERIUS PHONE device and launch it.
Go through the sign-up screen with the test account from .env.test, then
open the profile tab. After each step take a snapshot and tell me what
you see. Stop and report if the app crashes; include the crash log.

#!/usr/bin/env python3
"""Smoke-test an Android build on an ERIUS PHONE device. Standard library only.

Installs the APK, launches it, reads the screen, checks for a crash and saves a screenshot.
Exits 0 when the app is in the foreground with no crash, 1 otherwise, so it can gate a CI job.

    export ERIUS_PHONE_API_KEY=...        # the key you received with early access
    python3 apk_smoke_test.py app-release.apk [device-id]
"""
import json
import os
import sys
import urllib.error
import urllib.request

API = os.environ.get("ERIUS_PHONE_API_URL", "https://api.eriusphone.com")
KEY = os.environ["ERIUS_PHONE_API_KEY"]


def call(method, path, body=None, raw=None, timeout=300):
    """One API call. Returns (status, parsed JSON or raw bytes)."""
    headers = {"X-API-Key": KEY}
    data = raw
    if body is not None:
        data = json.dumps(body).encode()
        headers["Content-Type"] = "application/json"
    elif raw is not None:
        headers["Content-Type"] = "application/vnd.android.package-archive"
    req = urllib.request.Request(API + path, data=data, method=method, headers=headers)
    try:
        with urllib.request.urlopen(req, timeout=timeout) as r:
            status, payload, ctype = r.status, r.read(), r.headers.get("Content-Type", "")
    except urllib.error.HTTPError as e:
        status, payload, ctype = e.code, e.read(), e.headers.get("Content-Type", "")
    return status, (json.loads(payload) if "json" in ctype else payload)


def main():
    apk = sys.argv[1]
    status, me = call("GET", "/whoami")
    if status != 200:
        sys.exit(f"auth failed: {status} {me}")
    device = sys.argv[2] if len(sys.argv) > 2 else me["devices"][0]
    dev = f"/device/{device}"

    # 1. install the build (the raw APK is the request body)
    with open(apk, "rb") as f:
        status, inst = call("POST", f"{dev}/install", raw=f.read())
    if status != 200 or not inst.get("ok"):
        sys.exit(f"install failed: {status} {inst.get('error') or inst}")
    package = inst["package"]
    print(f"installed {package} {inst.get('versionName')} in {inst.get('ms')} ms")

    # 2. launch it; the response says what is in the foreground afterwards
    status, launched = call("POST", f"{dev}/launch", {"package": package})
    if status != 200:
        sys.exit(f"launch failed: {status} {launched}")

    # 3. look at the screen: the accessibility tree plus a list of elements, no image
    status, seen = call("GET", f"{dev}/observe?image=0")
    fg = seen["foreground"]
    interactive = [e for e in seen["elements"] if e.get("clickable") or e.get("editable")]
    print(f"foreground: {fg['package']} | {len(interactive)} interactive elements | tree coverage: {seen['treeCoverage']}")

    # 4. keep a small screenshot as the build artifact
    status, shot = call("GET", f"{dev}/screenshot?format=jpeg&quality=70&scale=0.5")
    with open("smoke.jpg", "wb") as f:
        f.write(shot)
    print(f"saved smoke.jpg ({len(shot) // 1024} KB)")

    # 5. verdict: a crash dialog, or another app in front (a permission prompt counts as ours)
    crashed = fg.get("crashDialog") and fg.get("crashedPackage") == package
    in_front = fg.get("package") in (package, "com.android.permissioncontroller",
                                     "com.google.android.permissioncontroller")
    if crashed or not in_front:
        _, log = call("GET", f"{dev}/crashes?lines=40")
        print("\n".join(l for l in log.get("lines", []) if package in l or "FATAL" in l)[-2000:])
        sys.exit(1)
    print("PASS")


if __name__ == "__main__":
    main()

// Run the same UI flow on several ERIUS PHONE devices at the same time. Node 18+, no dependencies.
//
//   export ERIUS_PHONE_API_KEY=...
//   node fleet_flow.mjs                 # every device this key controls
//   node fleet_flow.mjs dev_a dev_b     # or only the ones you name
//
// Each device takes one action at a time; different devices run in parallel.
const API = process.env.ERIUS_PHONE_API_URL || 'https://api.eriusphone.com';
const KEY = process.env.ERIUS_PHONE_API_KEY;

async function api(method, path, body) {
  for (let attempt = 0; ; attempt++) {
    const r = await fetch(API + path, {
      method,
      headers: { 'X-API-Key': KEY, ...(body ? { 'Content-Type': 'application/json' } : {}) },
      body: body ? JSON.stringify(body) : undefined,
    });
    // 429 = over the rate limit, or the phone's queue is full: back off and retry
    if (r.status === 429 && attempt < 5) { await new Promise((s) => setTimeout(s, 250 * (attempt + 1))); continue; }
    const json = (r.headers.get('content-type') || '').includes('json');
    return { status: r.status, data: json ? await r.json() : Buffer.from(await r.arrayBuffer()) };
  }
}

// The flow: open Settings, find a row by its visible text, open it, confirm the next screen.
async function flow(device) {
  const dev = `/device/${device}`;
  const t0 = Date.now();
  const step = async (name, method, path, body) => {
    const r = await api(method, dev + path, body);
    if (r.status !== 200) throw new Error(`${name}: ${r.status} ${r.data.error || ''} ${r.data.message || ''}`);
    return r.data;
  };
  try {
    await step('stop', 'POST', '/stop', { package: 'com.android.settings' });
    await step('launch', 'POST', '/launch', { package: 'com.android.settings' });
    await step('wait', 'POST', '/wait', { text: 'Network & internet', timeout: 10000 });
    await step('tap', 'POST', '/tap', { text: 'Network & internet' });
    await step('wait', 'POST', '/wait', { text: 'Internet', timeout: 10000 });
    const fg = await step('foreground', 'GET', '/foreground');
    return { device, ok: true, ms: Date.now() - t0, foreground: fg.package };
  } catch (e) {
    return { device, ok: false, ms: Date.now() - t0, error: e.message };
  } finally {
    await api('POST', dev + '/press', { key: 'home' });
    await api('POST', dev + '/stop', { package: 'com.android.settings' });
  }
}

const me = (await api('GET', '/whoami')).data;
const devices = process.argv.length > 2 ? process.argv.slice(2) : me.devices;
const t0 = Date.now();
const results = await Promise.all(devices.map(flow));
for (const r of results) console.log(r.ok ? 'PASS' : 'FAIL', r.device, `${r.ms} ms`, r.ok ? r.foreground : r.error);
console.log(`${devices.length} device(s), ${Date.now() - t0} ms wall clock`);
process.exit(results.every((r) => r.ok) ? 0 : 1);

HTTP/1.1 403 Forbidden
{
  "ok": false,
  "error": "forbidden",
  "message": "device not found or not accessible with this key",
  "requestId": "3c3eb4a4f9151d4d"
}