@beeos-ai/device-agent 0.9.1 → 0.9.5

package/dist/fleet/adapters/process/node-process-manager.js

@@ -1,23 +1,54 @@
 /**
  * Adapter — `IProcessManager` implementation backed by `child_process.spawn`.
  *
- * Spawns and supervises up to three long-running siblings per bound device:
+ * 0.4.0 SINGLETON MCP TOPOLOGY:
  *
- *   - **mcp**    `device-mcp-server --backend <kind> --adb-serial <serial>
- *                 --host 127.0.0.1 --port <mcpPort>`
+ * Pre-0.4 the manager spawned **one mcp + one daemon per device** (1:1) so
+ * the daemon could pin its `--mcp-url` to a per-device port. With the new
+ * SDK-backed device-mcp-server (which is itself a singleton multi-device
+ * BackendRegistry process), the manager keeps the per-device `IProcessManager`
+ * API the FSM/supervisor expect but internally collapses every `spawnMcp`
+ * call onto a **single shared MCP child**:
+ *
+ *   - The first `spawnMcp` call actually starts `device-mcp-server` on the
+ *     supplied port, runs the `initialize` JSON-RPC readiness handshake,
+ *     and remembers that port as the global MCP port.
+ *   - Subsequent `spawnMcp` calls (for additional devices) skip the spawn,
+ *     immediately emit a synthetic per-device `mcp_started` for the
+ *     existing global port, and add the serial to a refcount set.
+ *   - `killMcp(serial)` removes the serial from the refcount; the actual
+ *     `device-mcp-server` child is only killed when the last device drops
+ *     out (or `stop()` is called).
+ *   - When the global MCP exits unexpectedly, every refcounted serial
+ *     receives a synthetic `mcp_exited` so each per-device FSM transitions
+ *     coherently and triggers a respawn (whose first call rebuilds the
+ *     singleton).
+ *
+ * The daemon's `--mcp-url` always points at the global port (recorded in
+ * `globalMcpPort`), so per-device daemons all share the same backend
+ * registry. Tool calls route by the `device` argument the daemon's
+ * `McpClient` injects from its `defaultDevice = serial`. The MCP server's
+ * own `--adb-serial` per-device pin flag is gone; the registry discovers
+ * every connected device on its own.
+ *
+ * Spawn surface:
+ *
+ *   - **mcp**    `device-mcp-server --backend <kind>
+ *                 --host 127.0.0.1 --port <globalMcpPort>` (singleton)
  *   - **daemon** `device-agent --key <keyFile> --agent-gateway-url <url>
- *                 --mcp-url http://127.0.0.1:<mcpPort> --adb <serial>
- *                 [--http --http-port <httpPort>]`
- *   - **scrcpy** `scrcpy-bridge` (no args; configured via env mirroring
- *                 `web/packages/core/src/runtime/scrcpy-bridge.ts` `buildEnv`).
- *                 Optional — only spawned when the binding's `videoMode === "scrcpy"`.
+ *                 --mcp-url http://127.0.0.1:<globalMcpPort>
+ *                 --device <serial> [--adb <serial> for ADB backends]
+ *                 [--http --http-port <httpPort>]`  (per device)
+ *   - **scrcpy** `scrcpy-bridge` (no args; per device, optional —
+ *                 only spawned when the binding's `videoMode === "scrcpy"`).
  *
  * Lifecycle responsibilities:
  *
- *   - `spawnMcp` waits for `GET /healthz` to return 200 (configurable timeout)
- *     before emitting `mcp_started`. If readiness times out the spawn is
- *     killed and an `mcp_exited` event is reported (so the FSM treats the
- *     attempt as a crash and either retries or backs off).
+ *   - `spawnMcp` (first call) waits for the MCP `initialize` handshake to
+ *     return 200/202 before emitting `mcp_started`. If readiness times out
+ *     the global child is killed and a synthetic `mcp_exited` is reported
+ *     so the FSM treats the attempt as a crash. Subsequent (refcount-bump)
+ *     calls emit `mcp_started` synchronously without re-probing.
  *   - `spawnDaemon` emits `daemon_started` as soon as the child has a PID
  *     (the daemon's own readiness is observable through ACP traffic which is
  *     out of fleet scope; the daemon process itself dying is what we react to
@@ -79,6 +110,42 @@ export class NodeProcessManager {
     slots = new Map();
     listeners = new Set();
     started = false;
+    // ── Singleton MCP bookkeeping ───────────────────────────────────────────
+    /**
+     * The lone `device-mcp-server` child shared across all devices, or
+     * `undefined` when no device currently needs the MCP. First `spawnMcp`
+     * call spawns it; the last `killMcp` (or `stop()`) tears it down.
+     */
+    globalMcpSlot;
+    /** Port the singleton is bound to. 0 when not running. */
+    globalMcpPort = 0;
+    /**
+     * Port the most recent successfully-probed singleton was bound to.
+     * Survives `globalMcpPort` being reset to 0 on exit; consulted by
+     * the next `startGlobalMcp` to detect port drift across respawn.
+     * 0 means "no prior cycle has succeeded" (suppresses the false-
+     * positive `mcp_port_changed` on the very first spawn).
+     */
+    previousGlobalMcpPort = 0;
+    /** Serials currently refcounting the global MCP. */
+    mcpRefs = new Set();
+    /**
+     * Single-flight readiness: when two devices land on `spawnMcp` at the
+     * same time we want only one of them to actually probe `initialize`;
+     * the other just awaits this promise.
+     */
+    mcpReadyPromise;
+    /**
+     * Single-flight first-spawn: protects the
+     * (`globalMcpSlot === undefined` → `spawnFn` → `globalMcpSlot = …`)
+     * critical section. Without this, two concurrent first-time
+     * `spawnMcp(A)` / `spawnMcp(B)` calls could each call `spawnFn`
+     * (the `globalMcpSlot` write is post-spawn, so the second caller
+     * sees `undefined` and overwrites with its own child, leaking
+     * the first one). When non-undefined, every other caller waits
+     * here instead of starting a second mcp.
+     */
+    globalMcpStartPromise;
     constructor(opts = {}) {
         this.mcpBin =
             opts.mcpBin ?? process.env.BEEOS_DEVICE_MCP_BIN ?? "device-mcp-server";
@@ -110,6 +177,16 @@ export class NodeProcessManager {
             this.killDaemon(s, { expected: true }),
             this.killScrcpy(s, { expected: true }),
         ]));
+        // Belt + braces: if any refs remain (shouldn't, but defensive), tear
+        // down the singleton MCP explicitly. Otherwise the last killMcp above
+        // already cleared it.
+        if (this.globalMcpSlot) {
+            await this.killGlobalMcp(true);
+        }
+        // Forget the prior port so a future `start()` doesn't fire a
+        // spurious `mcp_port_changed` against a slate that's been torn
+        // down completely.
+        this.previousGlobalMcpPort = 0;
     }
     on(listener) {
         this.listeners.add(listener);
@@ -153,24 +230,77 @@ export class NodeProcessManager {
             });
             return;
         }
-        // Per-device backend takes precedence over the constructor-time
-        // default. `devices.json#backend` flows here via `SpawnOptions`,
-        // so once self-attach lands the same code path serves ADB,
-        // macOS / Linux / Windows hosts.
+        // Singleton refcount path — when the global MCP is already running,
+        // we just attach this serial as a ref and emit the per-device
+        // `mcp_started` synchronously. No new process spawn, no second
+        // `initialize` probe.
+        if (this.globalMcpSlot) {
+            this.attachToGlobalMcp(slot, opts.serial);
+            return;
+        }
+        // Concurrent first-spawn: another caller is already driving
+        // `startGlobalMcp`. Wait for it instead of starting a duplicate
+        // child (which would leak the first one — `globalMcpSlot` is
+        // overwritten post-spawn, so a naive concurrent path could
+        // double-spawn the binary).
+        if (this.globalMcpStartPromise) {
+            await this.globalMcpStartPromise;
+            if (this.globalMcpSlot) {
+                this.attachToGlobalMcp(slot, opts.serial);
+                return;
+            }
+            // The driver's start failed — emit our own per-device synthetic
+            // `mcp_exited` so this caller's FSM transitions out of `spawning`
+            // (the driver only emitted for ITS serial).
+            this.emit({
+                kind: "mcp_exited",
+                serial: opts.serial,
+                code: null,
+                signal: null,
+                expected: false,
+            });
+            return;
+        }
+        // First device — actually spawn the MCP child. We use this device's
+        // allocated port (`opts.mcpPort`) as the global port; later devices
+        // will share it irrespective of what the allocator handed them.
+        this.globalMcpStartPromise = this.startGlobalMcp(opts).finally(() => {
+            this.globalMcpStartPromise = undefined;
+        });
+        await this.globalMcpStartPromise;
+        if (!this.globalMcpSlot) {
+            // startGlobalMcp already emitted a synthetic `mcp_exited` for this
+            // serial; nothing else to do — the FSM will retry per its policy.
+            return;
+        }
+        this.attachToGlobalMcp(slot, opts.serial);
+    }
+    // ── Singleton helpers ────────────────────────────────────────────────────
+    /**
+     * Spawn the singleton `device-mcp-server`. Driven by the FIRST device
+     * to enter the spawn pipeline — its `opts.mcpPort` becomes the global
+     * port, and its `opts.backend` (or the constructor default) selects
+     * the backend kind. On readiness failure, emits a synthetic per-device
+     * `mcp_exited` for `opts.serial` so the caller's FSM transitions
+     * cleanly; on success leaves `globalMcpSlot` populated for refcount
+     * attachment.
+     */
+    async startGlobalMcp(opts) {
         const backend = opts.backend ?? this.mcpBackend;
-        const args = ["--backend", backend];
-        // `--adb-serial` is only meaningful for the ADB backend. Other
-        // backends rely on the host process (one device-mcp-server per
-        // host), so passing the serial there would be confusing.
-        if (isAdbBackend(backend)) {
-            args.push("--adb-serial", opts.serial);
-        }
-        args.push("--host", this.mcpHost, "--port", String(opts.mcpPort));
+        const args = [
+            "--backend",
+            backend,
+            // 0.4.0: device-mcp-server discovers every connected ADB device on
+            // its own — no `--adb-serial` per-device pin flag.
+            "--host",
+            this.mcpHost,
+            "--port",
+            String(opts.mcpPort),
+        ];
         const env = {
             ...process.env,
             ...this.extraEnv,
             DEVICEAGENT_BACKEND: backend,
-            ANDROID_SERIAL: opts.serial,
             MCP_HOST: this.mcpHost,
             MCP_PORT: String(opts.mcpPort),
         };
@@ -179,7 +309,7 @@ export class NodeProcessManager {
             child = this.spawnFn(this.mcpBin, args, env);
         }
         catch (e) {
-            this.logger.error("failed to spawn mcp", {
+            this.logger.error("failed to spawn singleton mcp", {
                 serial: opts.serial,
                 error: String(e),
             });
@@ -192,54 +322,202 @@ export class NodeProcessManager {
             });
             return;
         }
-        const childSlot = {
+        const globalSlot = {
             child,
             expectingKill: false,
             spawnedAt: Date.now(),
             bin: this.mcpBin,
             args,
         };
-        slot.mcp = childSlot;
-        this.logger.info("spawned device-mcp-server", {
-            serial: opts.serial,
+        this.globalMcpSlot = globalSlot;
+        this.globalMcpPort = opts.mcpPort;
+        this.logger.info("spawned singleton device-mcp-server", {
             pid: child.pid ?? null,
             port: opts.mcpPort,
+            backend,
         });
-        this.attachExitListener(opts.serial, "mcp", childSlot);
-        // Readiness probe (best-effort; in tests httpProbeFn returns true instantly).
-        const url = `http://${this.mcpHost}:${opts.mcpPort}/healthz`;
-        const ok = await this.httpProbeFn(url, this.mcpHealthTimeoutMs);
+        this.attachGlobalExitListener(globalSlot);
+        // Single-flight initialize probe.
+        if (!this.mcpReadyPromise) {
+            const url = `http://${this.mcpHost}:${opts.mcpPort}/mcp`;
+            this.mcpReadyPromise = this.httpProbeFn(url, this.mcpHealthTimeoutMs);
+        }
+        let ok = false;
+        try {
+            ok = await this.mcpReadyPromise;
+        }
+        finally {
+            this.mcpReadyPromise = undefined;
+        }
         if (!ok) {
-            this.logger.warn("mcp /healthz did not return 200 within grace", {
+            this.logger.warn("singleton mcp initialize handshake did not succeed within grace", {
                 serial: opts.serial,
-                url,
+                port: opts.mcpPort,
             });
-            // Treat the readiness failure as a crash. Mark the upcoming exit as
-            // expected (we caused the kill) so the FSM won't double-count, but
-            // emit the synthetic exit AFTER the actual kill bookkeeping is done.
-            childSlot.expectingKill = true;
+            // Treat readiness failure as a crash. Fan-out synthetic
+            // `mcp_exited` to every serial that attached during the probe
+            // (concurrent waiters who saw `globalMcpSlot` truthy and joined
+            // as refs before the probe resolved) PLUS the driver itself if
+            // it isn't already a ref. Without this fan-out, those waiters
+            // would only see the eventual real-child exit (fired by the
+            // async SIGTERM listener), and we'd race the listener against
+            // the test / supervisor's expected immediate transition.
+            globalSlot.expectingKill = true;
             try {
                 child.kill("SIGTERM");
             }
             catch {
                 /* ignore */
             }
-            this.emit({
-                kind: "mcp_exited",
-                serial: opts.serial,
-                code: null,
-                signal: "SIGTERM",
-                expected: false,
-            });
+            const refsToFanOut = Array.from(this.mcpRefs);
+            this.globalMcpSlot = undefined;
+            this.globalMcpPort = 0;
+            this.mcpRefs.clear();
+            for (const serial of refsToFanOut) {
+                const refSlot = this.slots.get(serial);
+                if (refSlot)
+                    refSlot.mcp = undefined;
+                this.emit({
+                    kind: "mcp_exited",
+                    serial,
+                    code: null,
+                    signal: "SIGTERM",
+                    expected: false,
+                });
+            }
+            if (!refsToFanOut.includes(opts.serial)) {
+                this.emit({
+                    kind: "mcp_exited",
+                    serial: opts.serial,
+                    code: null,
+                    signal: "SIGTERM",
+                    expected: false,
+                });
+            }
+            return;
+        }
+        // Probe succeeded — the singleton is healthy on `globalMcpPort`. If
+        // the previous cycle was on a different port, every still-alive
+        // daemon is now wired to a stale `--mcp-url`. Emit per-serial
+        // `mcp_port_changed` so the supervisor's FSM (`mcp_port_changed`
+        // case in fromHealthy / fromSpawning) can issue a serialized
+        // `restart_daemon` for each. The very first successful spawn (no
+        // prior port) is silent.
+        const previous = this.previousGlobalMcpPort;
+        this.previousGlobalMcpPort = this.globalMcpPort;
+        if (previous > 0 && previous !== this.globalMcpPort) {
+            for (const [serial, slotEntry] of this.slots) {
+                if (slotEntry.daemon) {
+                    this.emit({
+                        kind: "mcp_port_changed",
+                        serial,
+                        previousPort: previous,
+                        newPort: this.globalMcpPort,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Wire `serial` into the running global MCP: store a ref-pointing
+     * `ChildSlot` on the device's slots, register the ref, and emit a
+     * per-device `mcp_started` event using the global port. Idempotent —
+     * a serial already in `mcpRefs` becomes a no-op.
+     */
+    attachToGlobalMcp(slot, serial) {
+        if (!this.globalMcpSlot)
+            return;
+        if (this.mcpRefs.has(serial)) {
+            this.logger.debug("mcp ref already present — skipping", { serial });
             return;
         }
+        // The per-device slot points at the SHARED child reference so
+        // pid()/isAlive() return sensible values, but kill()/exit listeners
+        // are managed at the global level. We do NOT call `attachExitListener`
+        // here — the global exit listener fans out to every ref.
+        slot.mcp = {
+            child: this.globalMcpSlot.child,
+            expectingKill: false,
+            spawnedAt: this.globalMcpSlot.spawnedAt,
+            bin: this.globalMcpSlot.bin,
+            args: this.globalMcpSlot.args,
+        };
+        this.mcpRefs.add(serial);
         this.emit({
             kind: "mcp_started",
-            serial: opts.serial,
-            pid: child.pid ?? 0,
-            port: opts.mcpPort,
+            serial,
+            pid: this.globalMcpSlot.child.pid ?? 0,
+            port: this.globalMcpPort,
         });
     }
+    /**
+     * Attach a single global exit listener to the singleton MCP child. When
+     * it dies, fan-out a synthetic `mcp_exited` to every refcounted serial
+     * (clearing their slots) so each per-device FSM transitions cleanly.
+     * The `expected` flag is taken from `globalMcpSlot.expectingKill`, which
+     * is set by `killGlobalMcp(expected=true)` during graceful shutdown.
+     */
+    attachGlobalExitListener(globalSlot) {
+        globalSlot.child.once("exit", (code, signal) => {
+            const expected = globalSlot.expectingKill;
+            const refs = Array.from(this.mcpRefs);
+            this.logger.warn("singleton mcp exited", {
+                code,
+                signal,
+                expected,
+                refs: refs.length,
+            });
+            // Clear bookkeeping BEFORE re-entry so a respawn-driving FSM can
+            // call `spawnMcp` and find `globalMcpSlot === undefined`.
+            this.globalMcpSlot = undefined;
+            this.globalMcpPort = 0;
+            this.mcpRefs.clear();
+            for (const serial of refs) {
+                const slot = this.slots.get(serial);
+                if (slot)
+                    slot.mcp = undefined;
+                this.emit({ kind: "mcp_exited", serial, code, signal, expected });
+            }
+        });
+        globalSlot.child.once("error", (err) => {
+            this.logger.error("singleton mcp child error", { error: String(err) });
+        });
+    }
+    /**
+     * Tear down the singleton MCP child unconditionally. `expected=true`
+     * marks the upcoming exit so FSMs don't penalise restartCount; the
+     * actual `*_exited` events are emitted by the global exit listener.
+     * A no-op when the singleton is already gone.
+     */
+    async killGlobalMcp(expected) {
+        const globalSlot = this.globalMcpSlot;
+        if (!globalSlot)
+            return;
+        globalSlot.expectingKill = expected;
+        try {
+            globalSlot.child.kill("SIGTERM");
+        }
+        catch (e) {
+            this.logger.warn("singleton mcp SIGTERM failed", { error: String(e) });
+        }
+        const start = Date.now();
+        while (this.globalMcpSlot && Date.now() - start < this.shutdownGraceMs) {
+            await sleep(50);
+        }
+        if (this.globalMcpSlot) {
+            this.logger.warn("singleton mcp SIGTERM grace expired — sending SIGKILL");
+            try {
+                globalSlot.child.kill("SIGKILL");
+            }
+            catch (e) {
+                this.logger.warn("singleton mcp SIGKILL failed", { error: String(e) });
+            }
+            const killStart = Date.now();
+            while (this.globalMcpSlot && Date.now() - killStart < 2_000) {
+                await sleep(50);
+            }
+        }
+    }
     async spawnDaemon(opts) {
         const slot = this.ensureSlot(opts.serial);
         if (slot.daemon) {
@@ -249,7 +527,17 @@ export class NodeProcessManager {
             });
             return;
         }
-        const mcpUrl = `http://${this.mcpHost}:${opts.mcpPort}`;
+        // 0.4.0 SINGLETON MCP TOPOLOGY: every daemon connects to the SAME
+        // shared `device-mcp-server`, so `--mcp-url` MUST point at
+        // `globalMcpPort`, not at this device's allocator-allocated port.
+        // Pre-singleton each device had its own MCP, so `opts.mcpPort` was
+        // authoritative; with the singleton refactor only the FIRST device's
+        // port is bound — for every subsequent device `opts.mcpPort` is the
+        // allocator-leased number that nothing actually listens on. Falling
+        // back to `opts.mcpPort` only when the singleton is not up keeps
+        // direct test invocations (no surrounding `spawnMcp` call) working.
+        const effectiveMcpPort = this.globalMcpPort > 0 ? this.globalMcpPort : opts.mcpPort;
+        const mcpUrl = `http://${this.mcpHost}:${effectiveMcpPort}`;
         // P1-K of the install-link review: only ADB devices need
         // `--adb <serial>` — the device-agent uses the flag to pick the
         // physical Android device. For desktop / self-attach backends
@@ -263,6 +551,12 @@ export class NodeProcessManager {
             ? opts.backend === "adb"
             : true;
         const args = ["--key", opts.keyFile, "--mcp-url", mcpUrl];
+        // 0.4.0: route every tool call to the right backend by setting the
+        // McpClient's `defaultDevice`. `--adb` is kept as an alias for ADB
+        // backends because the daemon's CLI still maps both `--adb` and
+        // `--device` to `adbSerial` for backward compat — but `--device`
+        // is the canonical 0.4.0 flag.
+        args.push("--device", opts.serial);
         if (isAdbBackend) {
             args.push("--adb", opts.serial);
         }
@@ -467,7 +761,32 @@ export class NodeProcessManager {
     }
     // ── Kill paths ───────────────────────────────────────────────────────────
     async killMcp(serial, opts = {}) {
-        await this.killChild(serial, "mcp", opts.expected ?? true);
+        const expected = opts.expected ?? true;
+        const slot = this.slots.get(serial);
+        if (!slot)
+            return;
+        // Singleton MCP: this serial may or may not currently hold a ref. Always
+        // clear the per-device pointer + emit per-device `mcp_exited`, then
+        // tear down the global child only when the LAST ref drops.
+        const hadRef = this.mcpRefs.delete(serial);
+        if (slot.mcp) {
+            slot.mcp = undefined;
+            // Per-device exit so the FSM transitions cleanly. The global child
+            // is still alive for any remaining refs (or being torn down below).
+            this.emit({
+                kind: "mcp_exited",
+                serial,
+                code: null,
+                signal: null,
+                expected,
+            });
+        }
+        if (hadRef && this.mcpRefs.size === 0 && this.globalMcpSlot) {
+            // Last ref gone — tear down the singleton. The global exit listener
+            // will be a no-op for `mcp_exited` fan-out (refs is empty), so this
+            // is safe even with `expected=true` already on the slot.
+            await this.killGlobalMcp(expected);
+        }
     }
     async killDaemon(serial, opts = {}) {
         await this.killChild(serial, "daemon", opts.expected ?? true);
@@ -600,20 +919,57 @@ const defaultSpawnFn = (bin, args, env) => {
     });
     return child;
 };
+/**
+ * MCP readiness probe — POSTs an `initialize` JSON-RPC request to the
+ * given URL (which is the singleton-MCP `/mcp` endpoint) and treats a
+ * 200 / 202 response as readiness. Replaces the pre-0.4 `/healthz` GET
+ * because device-mcp-server 0.4 only speaks the official MCP wire
+ * protocol over `/mcp`.
+ */
 const defaultHttpProbeFn = async (url, timeoutMs) => {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const ok = await probeOnce(url, 1_000);
+        const ok = await probeOnce(url, 1_500);
         if (ok)
             return true;
         await sleep(250);
     }
     return false;
 };
+const PROBE_INITIALIZE_BODY = JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+        protocolVersion: "2025-06-18",
+        capabilities: {},
+        clientInfo: { name: "fleet-readiness-probe", version: "0.4.0" },
+    },
+});
 function probeOnce(url, timeoutMs) {
     return new Promise((resolve) => {
-        const req = http.get(url, (res) => {
-            const ok = res.statusCode === 200;
+        const parsed = (() => {
+            try {
+                return new URL(url);
+            }
+            catch {
+                return null;
+            }
+        })();
+        if (!parsed)
+            return resolve(false);
+        const req = http.request({
+            method: "POST",
+            host: parsed.hostname,
+            port: parsed.port,
+            path: parsed.pathname || "/mcp",
+            headers: {
+                "content-type": "application/json",
+                accept: "application/json, text/event-stream",
+                "content-length": Buffer.byteLength(PROBE_INITIALIZE_BODY),
+            },
+        }, (res) => {
+            const ok = res.statusCode === 200 || res.statusCode === 202;
             res.resume();
             resolve(ok);
         });
@@ -622,6 +978,7 @@ function probeOnce(url, timeoutMs) {
             resolve(false);
         });
         req.on("error", () => resolve(false));
+        req.end(PROBE_INITIALIZE_BODY);
     });
 }
 /**
@@ -719,15 +1076,6 @@ async function materializeInlineAgentConfig(instanceId) {
         return null;
     }
 }
-/**
- * `device-mcp-server` `--adb-serial <serial>` is only meaningful when the
- * backend talks to ADB. Currently that's just `adb` (canonical) and the
- * `android` alias; desktop / mock backends ignore the flag entirely so we
- * skip it to keep argv readable in `ps`.
- */
-function isAdbBackend(name) {
-    return name === "adb" || name === "android";
-}
 function sleep(ms) {
     return new Promise((res) => {
         const t = setTimeout(res, ms);