@beeos-ai/device-agent 0.4.0

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

@@ -0,0 +1,664 @@
+/**
+ * Adapter — `IProcessManager` implementation backed by `child_process.spawn`.
+ *
+ * Spawns and supervises up to three long-running siblings per bound device:
+ *
+ *   - **mcp**    `device-mcp-server --backend <kind> --adb-serial <serial>
+ *                 --host 127.0.0.1 --port <mcpPort>`
+ *   - **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"`.
+ *
+ * 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).
+ *   - `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
+ *     here). Optional `daemonHttpPort` is probed similarly when set.
+ *   - `spawnScrcpy` is best-effort — a missing binary yields a synthetic
+ *     `scrcpy_exited` event (with `reason`) instead of a thrown error.
+ *     scrcpy-bridge has no `/healthz`, so readiness is degraded to
+ *     "process still alive `scrcpyStartupGraceMs` after spawn"; before that
+ *     window elapses we don't emit `scrcpy_started`. If the child exits
+ *     within the grace, we emit `scrcpy_exited` instead.
+ *   - `kill*` sends SIGTERM, then SIGKILL after `shutdownGraceMs`. When the
+ *     supervisor initiates the kill we mark the resulting exit as `expected`
+ *     so the pure FSM (`fsm.ts`) doesn't penalise restartCount.
+ *   - When a child dies on its own (`expected=false`), we emit the matching
+ *     `*_exited` event and let the supervisor (driving the FSM) decide whether
+ *     to respawn. We never auto-restart from inside this adapter — the FSM
+ *     owns the policy.
+ *
+ * Binary discovery:
+ *   - mcp:    `BEEOS_DEVICE_MCP_BIN` → `device-mcp-server` on PATH (override via opts.mcpBin).
+ *   - daemon: `BEEOS_DEVICE_AGENT_BIN` → `device-agent` on PATH (override via opts.daemonBin).
+ *   - scrcpy: `BEEOS_SCRCPY_BRIDGE_BIN` env → `~/.beeos/bin/scrcpy-bridge[.exe]` (managed install).
+ *             Override via `opts.scrcpyBin` (absolute path) or `opts.findScrcpyBinFn` (test hook).
+ *
+ * The implementation deliberately exposes a hookable `spawnFn` /
+ * `httpProbeFn` / `findScrcpyBinFn` so unit tests can drive the manager with
+ * fake children and synthetic /healthz responses without touching the OS.
+ */
+import { spawn as nodeSpawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as http from "node:http";
+import * as os from "node:os";
+import * as path from "node:path";
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+// ── NodeProcessManager ──────────────────────────────────────────────────────
+export class NodeProcessManager {
+    mcpBin;
+    daemonBin;
+    scrcpyBinOverride;
+    mcpBackend;
+    mcpHost;
+    agentGatewayUrl;
+    bridgeUrl;
+    region;
+    mcpHealthTimeoutMs;
+    scrcpyStartupGraceMs;
+    shutdownGraceMs;
+    spawnFn;
+    httpProbeFn;
+    findScrcpyBinFn;
+    logger;
+    extraEnv;
+    slots = new Map();
+    listeners = new Set();
+    started = false;
+    constructor(opts = {}) {
+        this.mcpBin =
+            opts.mcpBin ?? process.env.BEEOS_DEVICE_MCP_BIN ?? "device-mcp-server";
+        this.daemonBin =
+            opts.daemonBin ?? process.env.BEEOS_DEVICE_AGENT_BIN ?? "device-agent";
+        this.scrcpyBinOverride = opts.scrcpyBin;
+        this.mcpBackend = opts.mcpBackend ?? process.env.BEEOS_MCP_BACKEND ?? "android";
+        this.mcpHost = opts.mcpHost ?? "127.0.0.1";
+        this.agentGatewayUrl = opts.agentGatewayUrl ?? process.env.AGENT_GATEWAY_URL;
+        this.bridgeUrl = opts.bridgeUrl ?? process.env.BRIDGE_URL;
+        this.region = opts.region ?? process.env.BEEOS_REGION;
+        this.mcpHealthTimeoutMs = opts.mcpHealthTimeoutMs ?? 10_000;
+        this.scrcpyStartupGraceMs = opts.scrcpyStartupGraceMs ?? 5_000;
+        this.shutdownGraceMs = opts.shutdownGraceMs ?? 5_000;
+        this.spawnFn = opts.spawnFn ?? defaultSpawnFn;
+        this.httpProbeFn = opts.httpProbeFn ?? defaultHttpProbeFn;
+        this.findScrcpyBinFn = opts.findScrcpyBinFn ?? (() => defaultFindScrcpyBin(this.scrcpyBinOverride));
+        this.logger = opts.logger ?? noopLogger;
+        this.extraEnv = opts.extraEnv ?? {};
+    }
+    async start() {
+        this.started = true;
+    }
+    async stop() {
+        this.started = false;
+        const serials = Array.from(this.slots.keys());
+        await Promise.all(serials.flatMap((s) => [
+            this.killMcp(s, { expected: true }),
+            this.killDaemon(s, { expected: true }),
+            this.killScrcpy(s, { expected: true }),
+        ]));
+    }
+    on(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    isAlive(serial, which) {
+        const slot = this.slots.get(serial);
+        if (!slot)
+            return false;
+        return Boolean(this.slotFor(slot, which));
+    }
+    pid(serial, which) {
+        const slot = this.slots.get(serial);
+        if (!slot)
+            return null;
+        const childSlot = this.slotFor(slot, which);
+        return childSlot?.child.pid ?? null;
+    }
+    slotFor(slot, which) {
+        if (which === "mcp")
+            return slot.mcp;
+        if (which === "daemon")
+            return slot.daemon;
+        return slot.scrcpy;
+    }
+    setSlot(slot, which, value) {
+        if (which === "mcp")
+            slot.mcp = value;
+        else if (which === "daemon")
+            slot.daemon = value;
+        else
+            slot.scrcpy = value;
+    }
+    // ── Spawn paths ──────────────────────────────────────────────────────────
+    async spawnMcp(opts) {
+        const slot = this.ensureSlot(opts.serial);
+        if (slot.mcp) {
+            this.logger.warn("spawnMcp called while mcp already alive — ignoring", {
+                serial: opts.serial,
+                pid: slot.mcp.child.pid,
+            });
+            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.
+        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 env = {
+            ...process.env,
+            ...this.extraEnv,
+            DEVICEAGENT_BACKEND: backend,
+            ANDROID_SERIAL: opts.serial,
+            MCP_HOST: this.mcpHost,
+            MCP_PORT: String(opts.mcpPort),
+        };
+        let child;
+        try {
+            child = this.spawnFn(this.mcpBin, args, env);
+        }
+        catch (e) {
+            this.logger.error("failed to spawn mcp", {
+                serial: opts.serial,
+                error: String(e),
+            });
+            this.emit({
+                kind: "mcp_exited",
+                serial: opts.serial,
+                code: -1,
+                signal: null,
+                expected: false,
+            });
+            return;
+        }
+        const childSlot = {
+            child,
+            expectingKill: false,
+            spawnedAt: Date.now(),
+            bin: this.mcpBin,
+            args,
+        };
+        slot.mcp = childSlot;
+        this.logger.info("spawned device-mcp-server", {
+            serial: opts.serial,
+            pid: child.pid ?? null,
+            port: opts.mcpPort,
+        });
+        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);
+        if (!ok) {
+            this.logger.warn("mcp /healthz did not return 200 within grace", {
+                serial: opts.serial,
+                url,
+            });
+            // 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;
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                /* ignore */
+            }
+            this.emit({
+                kind: "mcp_exited",
+                serial: opts.serial,
+                code: null,
+                signal: "SIGTERM",
+                expected: false,
+            });
+            return;
+        }
+        this.emit({
+            kind: "mcp_started",
+            serial: opts.serial,
+            pid: child.pid ?? 0,
+            port: opts.mcpPort,
+        });
+    }
+    async spawnDaemon(opts) {
+        const slot = this.ensureSlot(opts.serial);
+        if (slot.daemon) {
+            this.logger.warn("spawnDaemon called while daemon already alive — ignoring", {
+                serial: opts.serial,
+                pid: slot.daemon.child.pid,
+            });
+            return;
+        }
+        const mcpUrl = `http://${this.mcpHost}:${opts.mcpPort}`;
+        const args = [
+            "--key",
+            opts.keyFile,
+            "--mcp-url",
+            mcpUrl,
+            "--adb",
+            opts.serial,
+        ];
+        const agw = opts.agentGatewayUrl ?? this.agentGatewayUrl;
+        if (agw) {
+            args.push("--agent-gateway-url", agw);
+        }
+        if (this.bridgeUrl) {
+            args.push("--bridge", this.bridgeUrl);
+        }
+        if (this.region) {
+            args.push("--region", this.region);
+        }
+        if (typeof opts.daemonHttpPort === "number" && opts.daemonHttpPort > 0) {
+            args.push("--http", "--http-port", String(opts.daemonHttpPort));
+        }
+        // Per-instance VLM / orchestrator config that the CLI's
+        // `persistAgentConfigBestEffort` writes during `beeos device attach`.
+        // Injected only when the file actually exists so daemons started for
+        // edge / staging deploys (where the CLI hasn't run) still come up
+        // with their built-in defaults.
+        if (opts.instanceId) {
+            const cfg = path.join(beeoHome(), `${opts.instanceId}.config.json`);
+            if (await fileExists(cfg)) {
+                args.push("--vlm-config-file", cfg);
+            }
+        }
+        const env = {
+            ...process.env,
+            ...this.extraEnv,
+            MCP_URL: mcpUrl,
+            ANDROID_SERIAL: opts.serial,
+        };
+        let child;
+        try {
+            child = this.spawnFn(this.daemonBin, args, env);
+        }
+        catch (e) {
+            this.logger.error("failed to spawn daemon", {
+                serial: opts.serial,
+                error: String(e),
+            });
+            this.emit({
+                kind: "daemon_exited",
+                serial: opts.serial,
+                code: -1,
+                signal: null,
+                expected: false,
+            });
+            return;
+        }
+        const childSlot = {
+            child,
+            expectingKill: false,
+            spawnedAt: Date.now(),
+            bin: this.daemonBin,
+            args,
+        };
+        slot.daemon = childSlot;
+        this.logger.info("spawned device-agent daemon", {
+            serial: opts.serial,
+            pid: child.pid ?? null,
+            mcpUrl,
+        });
+        this.attachExitListener(opts.serial, "daemon", childSlot);
+        this.emit({
+            kind: "daemon_started",
+            serial: opts.serial,
+            pid: child.pid ?? 0,
+        });
+    }
+    async spawnScrcpy(opts) {
+        const slot = this.ensureSlot(opts.serial);
+        if (slot.scrcpy) {
+            this.logger.warn("spawnScrcpy called while scrcpy already alive — ignoring", {
+                serial: opts.serial,
+                pid: slot.scrcpy.child.pid,
+            });
+            return;
+        }
+        const bin = await this.findScrcpyBinFn();
+        if (!bin) {
+            // Best-effort: missing binary must NOT block the device. Emit a
+            // synthetic exit (with a `reason`) so the supervisor records the
+            // degraded video state on the snapshot. mcp + daemon still come up.
+            this.logger.warn("scrcpy-bridge binary not found; video disabled", {
+                serial: opts.serial,
+            });
+            this.emit({
+                kind: "scrcpy_exited",
+                serial: opts.serial,
+                code: null,
+                signal: null,
+                expected: false,
+                reason: "binary_not_found",
+            });
+            return;
+        }
+        // Mirror `web/packages/core/src/runtime/scrcpy-bridge.ts` `buildEnv`
+        // (kept inline here to avoid a `@beeos/core` dependency in the
+        // device-agent package).
+        const env = {
+            ...process.env,
+            ...this.extraEnv,
+            DEVICE_ID: `device-${opts.instanceId}`,
+            ADB_SERIAL: opts.serial,
+            AGENT_GATEWAY_URL: opts.agentGatewayUrl,
+            BRIDGE_PRIVATE_KEY_FILE: opts.bridgePrivateKeyFile,
+            BRIDGE_PUBLIC_KEY_FILE: opts.bridgePublicKeyFile,
+            LOG_FORMAT: "json",
+            ...(opts.videoBitrateKbps != null
+                ? { VIDEO_BITRATE_KBPS: String(opts.videoBitrateKbps) }
+                : {}),
+            ...(opts.maxFps != null ? { MAX_FPS: String(opts.maxFps) } : {}),
+            ...(opts.iceUrls?.length ? { ICE_URLS: opts.iceUrls.join(",") } : {}),
+            ...(opts.turnUrls?.length ? { TURN_URLS: opts.turnUrls.join(",") } : {}),
+            ...(opts.turnUsername ? { TURN_USERNAME: opts.turnUsername } : {}),
+            ...(opts.turnCredential ? { TURN_CREDENTIAL: opts.turnCredential } : {}),
+            ...(opts.extraEnv ?? {}),
+        };
+        let child;
+        try {
+            child = this.spawnFn(bin, [], env);
+        }
+        catch (e) {
+            this.logger.error("failed to spawn scrcpy-bridge", {
+                serial: opts.serial,
+                error: String(e),
+            });
+            this.emit({
+                kind: "scrcpy_exited",
+                serial: opts.serial,
+                code: -1,
+                signal: null,
+                expected: false,
+                reason: "spawn_failed",
+            });
+            return;
+        }
+        const childSlot = {
+            child,
+            expectingKill: false,
+            spawnedAt: Date.now(),
+            bin,
+            args: [],
+            startedEmitted: false,
+        };
+        slot.scrcpy = childSlot;
+        this.logger.info("spawned scrcpy-bridge", {
+            serial: opts.serial,
+            pid: child.pid ?? null,
+            deviceId: env.DEVICE_ID,
+        });
+        this.attachExitListener(opts.serial, "scrcpy", childSlot);
+        // scrcpy-bridge has no /healthz endpoint (its readiness is the WebRTC
+        // signalling round-trip, which is per-session and out of fleet scope).
+        // We treat "still alive after `scrcpyStartupGraceMs`" as healthy. If
+        // the child exits earlier the exit listener emits `scrcpy_exited`
+        // BEFORE this timer fires and `startedEmitted` stays false.
+        const timer = setTimeout(() => {
+            if (childSlot.startedEmitted)
+                return;
+            // Re-check the slot is still ours (may have been replaced by a
+            // restart loop, in which case the new spawn owns the timer).
+            const current = this.slots.get(opts.serial)?.scrcpy;
+            if (current !== childSlot)
+                return;
+            childSlot.startedEmitted = true;
+            this.emit({
+                kind: "scrcpy_started",
+                serial: opts.serial,
+                pid: child.pid ?? 0,
+            });
+        }, this.scrcpyStartupGraceMs);
+        if (typeof timer === "object" && timer && "unref" in timer) {
+            try {
+                timer.unref();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        childSlot.startupTimer = timer;
+    }
+    // ── Kill paths ───────────────────────────────────────────────────────────
+    async killMcp(serial, opts = {}) {
+        await this.killChild(serial, "mcp", opts.expected ?? true);
+    }
+    async killDaemon(serial, opts = {}) {
+        await this.killChild(serial, "daemon", opts.expected ?? true);
+    }
+    async killScrcpy(serial, opts = {}) {
+        await this.killChild(serial, "scrcpy", opts.expected ?? true);
+    }
+    // ── Internals ────────────────────────────────────────────────────────────
+    ensureSlot(serial) {
+        let slot = this.slots.get(serial);
+        if (!slot) {
+            slot = { serial };
+            this.slots.set(serial, slot);
+        }
+        return slot;
+    }
+    attachExitListener(serial, which, childSlot) {
+        childSlot.child.once("exit", (code, signal) => {
+            const slot = this.slots.get(serial);
+            if (!slot)
+                return;
+            const previous = this.slotFor(slot, which);
+            if (previous !== childSlot) {
+                // Some other slot already replaced this one (rare race) — ignore.
+                return;
+            }
+            const expected = childSlot.expectingKill;
+            this.setSlot(slot, which, undefined);
+            // scrcpy startup-grace timer must be cleared regardless of how the
+            // child died — otherwise a delayed `scrcpy_started` could fire
+            // after `scrcpy_exited`, confusing the supervisor's snapshot.
+            if (childSlot.startupTimer) {
+                clearTimeout(childSlot.startupTimer);
+                childSlot.startupTimer = undefined;
+            }
+            this.logger.warn("child exited", {
+                serial,
+                which,
+                code,
+                signal,
+                expected,
+            });
+            if (which === "mcp") {
+                this.emit({ kind: "mcp_exited", serial, code, signal, expected });
+            }
+            else if (which === "daemon") {
+                this.emit({ kind: "daemon_exited", serial, code, signal, expected });
+            }
+            else {
+                this.emit({
+                    kind: "scrcpy_exited",
+                    serial,
+                    code,
+                    signal,
+                    expected,
+                    // If the child died inside the startup grace window we tag it
+                    // for snapshot consumers so they can render a degraded label
+                    // (e.g. "scrcpy crashed during boot") without parsing logs.
+                    reason: childSlot.startedEmitted === false ? "startup_failed" : undefined,
+                });
+            }
+        });
+        childSlot.child.once("error", (err) => {
+            this.logger.error("child error", { serial, which, error: String(err) });
+        });
+    }
+    async killChild(serial, which, expected) {
+        const slot = this.slots.get(serial);
+        if (!slot)
+            return;
+        const childSlot = this.slotFor(slot, which);
+        if (!childSlot)
+            return;
+        childSlot.expectingKill = expected;
+        try {
+            childSlot.child.kill("SIGTERM");
+        }
+        catch (e) {
+            this.logger.warn("SIGTERM failed", { serial, which, error: String(e) });
+        }
+        // Wait up to shutdownGraceMs for `exit`. The exit listener is what
+        // clears the slot; we just observe.
+        const start = Date.now();
+        while (this.slotFor(slot, which) && Date.now() - start < this.shutdownGraceMs) {
+            await sleep(50);
+        }
+        if (this.slotFor(slot, which)) {
+            this.logger.warn("SIGTERM grace expired — sending SIGKILL", {
+                serial,
+                which,
+            });
+            try {
+                childSlot.child.kill("SIGKILL");
+            }
+            catch (e) {
+                this.logger.warn("SIGKILL failed", { serial, which, error: String(e) });
+            }
+            // wait briefly for SIGKILL exit
+            const killStart = Date.now();
+            while (this.slotFor(slot, which) && Date.now() - killStart < 2_000) {
+                await sleep(50);
+            }
+        }
+    }
+    emit(event) {
+        for (const l of this.listeners) {
+            try {
+                l(event);
+            }
+            catch (e) {
+                this.logger.warn("process event listener threw", { error: String(e) });
+            }
+        }
+    }
+}
+// ── Defaults ────────────────────────────────────────────────────────────────
+const defaultSpawnFn = (bin, args, env) => {
+    const child = nodeSpawn(bin, [...args], {
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+    });
+    // Pipe child output through fleet's logger transparently — the supervisor
+    // doesn't need parsed lines, just visibility.
+    child.stdout?.on("data", (chunk) => {
+        process.stdout.write(`[${bin}] ${chunk.toString()}`);
+    });
+    child.stderr?.on("data", (chunk) => {
+        process.stderr.write(`[${bin} stderr] ${chunk.toString()}`);
+    });
+    return child;
+};
+const defaultHttpProbeFn = async (url, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const ok = await probeOnce(url, 1_000);
+        if (ok)
+            return true;
+        await sleep(250);
+    }
+    return false;
+};
+function probeOnce(url, timeoutMs) {
+    return new Promise((resolve) => {
+        const req = http.get(url, (res) => {
+            const ok = res.statusCode === 200;
+            res.resume();
+            resolve(ok);
+        });
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.on("error", () => resolve(false));
+    });
+}
+/**
+ * Default scrcpy-bridge binary discovery — used when no `findScrcpyBinFn`
+ * is injected. Mirrors `scrcpyBridgeRuntime.findBinary()` semantics in
+ * `web/packages/core/src/runtime/scrcpy-bridge.ts` (constructor override
+ * → `BEEOS_SCRCPY_BRIDGE_BIN` env → `~/.beeos/bin/scrcpy-bridge[.exe]`).
+ *
+ * We deliberately do NOT consult `$PATH` (vs the `@beeos/core` adapter
+ * which uses `which`) — the fleet daemon usually runs from a non-login
+ * shell where `$PATH` is minimal, so PATH-based discovery is unreliable.
+ * The CLI's `scrcpyBridgeRuntime.ensureInstalled` always lays the binary
+ * at `~/.beeos/bin/scrcpy-bridge`, so the managed-install path is
+ * sufficient for the supported deploy modes.
+ */
+async function defaultFindScrcpyBin(override) {
+    if (override && (await fileExists(override)))
+        return override;
+    const envBin = process.env.BEEOS_SCRCPY_BRIDGE_BIN;
+    if (envBin && (await fileExists(envBin)))
+        return envBin;
+    const home = beeoHome();
+    const exe = process.platform === "win32" ? "scrcpy-bridge.exe" : "scrcpy-bridge";
+    const managed = path.join(home, "bin", exe);
+    if (await fileExists(managed))
+        return managed;
+    return null;
+}
+/** Resolve the BeeOS home directory (override-aware, mirrors `port-allocator.ts`). */
+function beeoHome() {
+    const override = process.env.BEEOS_HOME;
+    if (override && override.length > 0)
+        return override;
+    return path.join(os.homedir(), ".beeos");
+}
+async function fileExists(p) {
+    try {
+        await fs.promises.access(p, fs.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `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);
+        if (typeof t === "object" && t && "unref" in t) {
+            try {
+                t.unref();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    });
+}
+//# sourceMappingURL=node-process-manager.js.map