@autifyhq/aximo-cli 0.9.0 → 0.10.0

package/dist/mobile-control/appium-controller.test.js

@@ -398,3 +398,105 @@ describe("AppiumController launch + lifecycle", () => {
         expect(calls.some((c) => c.method === "DELETE" && c.path === "/session/sess-1")).toBe(true);
     });
 });
+describe("AppiumController MJPEG capture", () => {
+    it("adds the mjpegServerPort capability and applies conservative settings", async () => {
+        const { transport, calls } = fakeTransport();
+        const controller = new AppiumController({
+            endpoint: "http://x",
+            platform: "android",
+            target: "udid-1",
+            mjpegServerPort: async () => 7777,
+            transport,
+        });
+        await controller.ensureReady();
+        const body = calls.find((c) => c.method === "POST" && c.path === "/session")?.body;
+        expect(body["capabilities"]?.alwaysMatch["appium:mjpegServerPort"]).toBe(7777);
+        const settings = calls.find((c) => c.path.endsWith("/appium/settings"));
+        expect(settings?.body).toEqual({
+            settings: {
+                mjpegServerFramerate: 10,
+                mjpegScalingFactor: 50,
+                mjpegServerScreenshotQuality: 40,
+            },
+        });
+        expect(controller.getMjpegPort()).toBe(7777);
+    });
+    it("omits the capability and settings call when no port is configured", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.screenshot();
+        const body = calls.find((c) => c.method === "POST" && c.path === "/session")?.body;
+        expect(body["capabilities"]?.alwaysMatch["appium:mjpegServerPort"]).toBeUndefined();
+        expect(calls.some((c) => c.path.endsWith("/appium/settings"))).toBe(false);
+        expect(controller.getMjpegPort()).toBeUndefined();
+    });
+});
+describe("AppiumController session recovery", () => {
+    function deadSessionTransport(failuresBeforeRecovery) {
+        const calls = [];
+        let sessions = 0;
+        let remainingFailures = failuresBeforeRecovery;
+        const transport = {
+            async request(method, path, body) {
+                calls.push({ method, path, body });
+                if (method === "POST" && path === "/session") {
+                    sessions += 1;
+                    return { sessionId: `sess-${sessions}` };
+                }
+                if (path.endsWith("/screenshot")) {
+                    if (remainingFailures > 0) {
+                        remainingFailures -= 1;
+                        throw new Error("WebDriver GET /screenshot failed: invalid session id");
+                    }
+                    return pngWithWidth(400);
+                }
+                return {};
+            },
+        };
+        return { transport, calls };
+    }
+    it("rebuilds the session once and retries when the cached session has died", async () => {
+        const { transport, calls } = deadSessionTransport(1);
+        const controller = new AppiumController({
+            endpoint: "http://x",
+            platform: "android",
+            target: "udid-1",
+            transport,
+        });
+        const shot = await controller.screenshot();
+        expect(Buffer.isBuffer(shot)).toBe(true);
+        expect(calls.filter((c) => c.method === "POST" && c.path === "/session")).toHaveLength(2);
+    });
+    it("surfaces the error when the rebuilt session is dead too", async () => {
+        const { transport, calls } = deadSessionTransport(2);
+        const controller = new AppiumController({
+            endpoint: "http://x",
+            platform: "android",
+            target: "udid-1",
+            transport,
+        });
+        await expect(controller.screenshot()).rejects.toThrow(/invalid session id/);
+        expect(calls.filter((c) => c.method === "POST" && c.path === "/session")).toHaveLength(2);
+    });
+    it("does not rebuild the session for ordinary command failures", async () => {
+        const calls = [];
+        const transport = {
+            async request(method, path, body) {
+                calls.push({ method, path, body });
+                if (method === "POST" && path === "/session")
+                    return { sessionId: "sess-1" };
+                if (path.endsWith("/screenshot")) {
+                    throw new Error("WebDriver GET /screenshot failed: unexpected server error");
+                }
+                return {};
+            },
+        };
+        const controller = new AppiumController({
+            endpoint: "http://x",
+            platform: "android",
+            target: "udid-1",
+            transport,
+        });
+        await expect(controller.screenshot()).rejects.toThrow(/unexpected server error/);
+        expect(calls.filter((c) => c.method === "POST" && c.path === "/session")).toHaveLength(1);
+    });
+});

package/dist/mobile-control/frame-sender.d.ts

@@ -0,0 +1,34 @@
+import { type Socket } from "socket.io-client";
+export interface FrameSenderOptions {
+    wsUrl: string;
+    deviceToken: string;
+    /** Called when the gateway acks that no viewer is watching — capture should stop. */
+    onInactive: () => void;
+    log?: (message: string) => void;
+    /** Test seam: overrides the socket factory. */
+    connect?: (wsUrl: string, deviceToken: string) => Socket;
+}
+/**
+ * Pushes JPEG frames to the gateway over a DEDICATED socket.io connection
+ * (handshake `role: "frames"`) so frame bytes never share a TCP stream with
+ * command acks or engine.io pings — on a saturated uplink that head-of-line
+ * blocking delays tap acks by seconds and starves pings into a tunnel drop.
+ *
+ * Sending is ack-clocked with keep-latest replacement: one frame in flight,
+ * and whatever arrives while it is unacknowledged replaces the queued one.
+ * socket.io `volatile` cannot bound this — the websocket transport reports
+ * writable again on the next tick without consulting the real send buffer, so
+ * volatile frames still queue unboundedly on a slow link.
+ */
+export declare class FrameSender {
+    private readonly options;
+    private socket;
+    private pending;
+    private pumping;
+    private oversizedWarned;
+    constructor(options: FrameSenderOptions);
+    start(): void;
+    stop(): void;
+    push(frame: Buffer): void;
+    private pump;
+}

package/dist/mobile-control/frame-sender.js

@@ -0,0 +1,96 @@
+import { io } from "socket.io-client";
+const SOCKET_PATH = "/devices/tunnel";
+const ACK_TIMEOUT_MS = 10_000;
+// Frames at the pinned capture settings are ~30-80KB. Anything this large
+// means misapplied settings; sending it would monopolize a slow uplink.
+const MAX_FRAME_BYTES = 1024 * 1024;
+/**
+ * Pushes JPEG frames to the gateway over a DEDICATED socket.io connection
+ * (handshake `role: "frames"`) so frame bytes never share a TCP stream with
+ * command acks or engine.io pings — on a saturated uplink that head-of-line
+ * blocking delays tap acks by seconds and starves pings into a tunnel drop.
+ *
+ * Sending is ack-clocked with keep-latest replacement: one frame in flight,
+ * and whatever arrives while it is unacknowledged replaces the queued one.
+ * socket.io `volatile` cannot bound this — the websocket transport reports
+ * writable again on the next tick without consulting the real send buffer, so
+ * volatile frames still queue unboundedly on a slow link.
+ */
+export class FrameSender {
+    options;
+    socket = null;
+    pending = null;
+    pumping = false;
+    oversizedWarned = false;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        if (this.socket)
+            return;
+        const connect = this.options.connect ?? defaultConnect;
+        this.socket = connect(this.options.wsUrl, this.options.deviceToken);
+        this.socket.on("connect_error", (err) => {
+            this.options.log?.(`Frame connection error: ${err.message}`);
+        });
+        // A reconnect may have frames waiting from before the drop.
+        this.socket.on("connect", () => void this.pump());
+    }
+    stop() {
+        this.pending = null;
+        this.socket?.close();
+        this.socket = null;
+    }
+    push(frame) {
+        if (frame.length > MAX_FRAME_BYTES) {
+            if (!this.oversizedWarned) {
+                this.oversizedWarned = true;
+                this.options.log?.(`Dropping oversized MJPEG frame (${frame.length} bytes) — capture settings were likely not applied.`);
+            }
+            return;
+        }
+        this.pending = frame;
+        void this.pump();
+    }
+    async pump() {
+        if (this.pumping)
+            return;
+        this.pumping = true;
+        try {
+            while (this.pending) {
+                const socket = this.socket;
+                // Disconnected: leave the newest frame queued; the connect handler
+                // resumes the pump once the transport is back.
+                if (!socket?.connected)
+                    return;
+                const frame = this.pending;
+                this.pending = null;
+                try {
+                    const ack = (await socket.timeout(ACK_TIMEOUT_MS).emitWithAck("stream_frame", frame));
+                    if (ack?.active === false) {
+                        this.pending = null;
+                        this.options.onInactive();
+                        return;
+                    }
+                }
+                catch {
+                    // Ack timeout: the link is stalling. The frame is already stale —
+                    // drop it and let the next capture retry.
+                    return;
+                }
+            }
+        }
+        finally {
+            this.pumping = false;
+        }
+    }
+}
+function defaultConnect(wsUrl, deviceToken) {
+    return io(wsUrl, {
+        path: SOCKET_PATH,
+        transports: ["websocket"],
+        auth: { deviceToken, role: "frames" },
+        reconnectionAttempts: Infinity,
+        timeout: 10_000,
+    });
+}

package/dist/mobile-control/frame-sender.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mobile-control/frame-sender.test.js

@@ -0,0 +1,108 @@
+import { describe, expect, it, vi } from "vitest";
+import { FrameSender } from "./frame-sender.js";
+class FakeFramesSocket {
+    connected = true;
+    sent = [];
+    acks = [];
+    handlers = new Map();
+    on(event, handler) {
+        this.handlers.set(event, handler);
+        return this;
+    }
+    fire(event, ...args) {
+        this.handlers.get(event)?.(...args);
+    }
+    timeout(_ms) {
+        return {
+            emitWithAck: (_event, frame) => new Promise((resolve) => {
+                this.sent.push(frame);
+                this.acks.push(resolve);
+            }),
+        };
+    }
+    close() {
+        this.connected = false;
+    }
+}
+function tick() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function build(socket, onInactive = vi.fn()) {
+    const sender = new FrameSender({
+        wsUrl: "ws://gateway",
+        deviceToken: "token",
+        onInactive,
+        connect: () => socket,
+    });
+    sender.start();
+    return { sender, onInactive };
+}
+describe("FrameSender", () => {
+    it("ack-clocks with keep-latest: frames pushed mid-flight collapse to the newest", async () => {
+        const socket = new FakeFramesSocket();
+        const { sender } = build(socket);
+        sender.push(Buffer.from("f1"));
+        await tick();
+        sender.push(Buffer.from("f2"));
+        sender.push(Buffer.from("f3"));
+        await tick();
+        // f1 unacked: nothing else may be in flight.
+        expect(socket.sent.map(String)).toEqual(["f1"]);
+        socket.acks[0]?.({ active: true });
+        await tick();
+        // f2 was replaced by f3 while waiting.
+        expect(socket.sent.map(String)).toEqual(["f1", "f3"]);
+        socket.acks[1]?.({ active: true });
+        await tick();
+        expect(socket.sent).toHaveLength(2);
+    });
+    it("stops capture when the gateway acks that nobody is watching", async () => {
+        const socket = new FakeFramesSocket();
+        const { sender, onInactive } = build(socket);
+        sender.push(Buffer.from("frame"));
+        await tick();
+        socket.acks[0]?.({ active: false });
+        await tick();
+        expect(onInactive).toHaveBeenCalledTimes(1);
+    });
+    it("holds the newest frame while disconnected and resumes on connect", async () => {
+        const socket = new FakeFramesSocket();
+        socket.connected = false;
+        const { sender } = build(socket);
+        sender.push(Buffer.from("f1"));
+        sender.push(Buffer.from("f2"));
+        await tick();
+        expect(socket.sent).toHaveLength(0);
+        socket.connected = true;
+        socket.fire("connect");
+        await tick();
+        expect(socket.sent.map(String)).toEqual(["f2"]);
+    });
+    it("drops oversized frames instead of sending them", async () => {
+        const socket = new FakeFramesSocket();
+        const log = vi.fn();
+        const sender = new FrameSender({
+            wsUrl: "ws://gateway",
+            deviceToken: "token",
+            onInactive: vi.fn(),
+            log,
+            connect: () => socket,
+        });
+        sender.start();
+        sender.push(Buffer.alloc(2 * 1024 * 1024));
+        await tick();
+        expect(socket.sent).toHaveLength(0);
+        expect(log).toHaveBeenCalledOnce();
+    });
+    it("stop() clears the queue and closes the socket", async () => {
+        const socket = new FakeFramesSocket();
+        const { sender } = build(socket);
+        sender.push(Buffer.from("f1"));
+        await tick();
+        sender.stop();
+        expect(socket.connected).toBe(false);
+        socket.acks[0]?.({ active: true });
+        await tick();
+        expect(socket.sent).toHaveLength(1);
+    });
+});

package/dist/mobile-control/mjpeg-stream.d.ts

@@ -0,0 +1,43 @@
+import { type Socket as NetSocket } from "node:net";
+/**
+ * Incremental JPEG frame extractor for an MJPEG byte stream. Scans raw bytes
+ * for SOI/EOI markers instead of parsing multipart headers — the WDA and
+ * UiAutomator2 servers frame their streams differently, and marker scanning
+ * handles both and resyncs after corruption (HTTP headers and part boundaries
+ * fall out naturally because scanning starts at the first SOI).
+ */
+export declare class MjpegFrameParser {
+    private buffer;
+    push(chunk: Buffer): Buffer[];
+}
+export interface MjpegStreamClientOptions {
+    /** Bring the device session (and its forwarded MJPEG port) up; called before each connect. */
+    ensureReady: () => Promise<void>;
+    /** Local port the driver forwarded to the on-device MJPEG server. */
+    getPort: () => number | undefined;
+    onFrame: (jpeg: Buffer) => void;
+    log?: (message: string) => void;
+    /** Test seam: overrides the TCP connection factory. */
+    createConnection?: (port: number) => NetSocket;
+}
+/**
+ * Connects to the driver-forwarded MJPEG port and emits complete JPEG frames.
+ * Reconnects with capped backoff while started — an Appium session rebuild
+ * lands on a fresh port, which `getPort` reflects on the next attempt. All
+ * timers are cancellable so `stop()` never holds the process open.
+ */
+export declare class MjpegStreamClient {
+    private readonly options;
+    private active;
+    private socket;
+    private attempt;
+    private loop;
+    private wake;
+    constructor(options: MjpegStreamClientOptions);
+    isActive(): boolean;
+    start(): void;
+    stop(): Promise<void>;
+    private run;
+    private streamOnce;
+    private sleep;
+}

package/dist/mobile-control/mjpeg-stream.js

@@ -0,0 +1,160 @@
+import { connect } from "node:net";
+const SOI = Buffer.from([0xff, 0xd8]);
+const EOI = Buffer.from([0xff, 0xd9]);
+// A frame at the pinned capture settings is ~30-80KB; anything near this cap
+// means the parser lost sync or the driver ignored the settings. Dropping the
+// buffer resyncs on the next SOI marker.
+const MAX_PARSER_BUFFER = 8 * 1024 * 1024;
+// No bytes at all for this long means the server is wedged (locked phone with a
+// dead WDA, stale forward) — drop the connection and let the retry loop rebuild.
+const STREAM_IDLE_TIMEOUT_MS = 15_000;
+const MAX_RECONNECT_DELAY_MS = 10_000;
+/**
+ * Incremental JPEG frame extractor for an MJPEG byte stream. Scans raw bytes
+ * for SOI/EOI markers instead of parsing multipart headers — the WDA and
+ * UiAutomator2 servers frame their streams differently, and marker scanning
+ * handles both and resyncs after corruption (HTTP headers and part boundaries
+ * fall out naturally because scanning starts at the first SOI).
+ */
+export class MjpegFrameParser {
+    buffer = Buffer.alloc(0);
+    push(chunk) {
+        this.buffer = this.buffer.length === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+        const frames = [];
+        for (;;) {
+            const soi = this.buffer.indexOf(SOI);
+            if (soi === -1) {
+                // Nothing before a frame start is useful; keep one byte in case a
+                // marker straddles the chunk edge.
+                this.buffer = this.buffer.subarray(Math.max(0, this.buffer.length - 1));
+                break;
+            }
+            if (soi > 0)
+                this.buffer = this.buffer.subarray(soi);
+            const eoi = this.buffer.indexOf(EOI, SOI.length);
+            if (eoi === -1)
+                break;
+            frames.push(this.buffer.subarray(0, eoi + EOI.length));
+            this.buffer = this.buffer.subarray(eoi + EOI.length);
+        }
+        if (this.buffer.length > MAX_PARSER_BUFFER)
+            this.buffer = Buffer.alloc(0);
+        return frames;
+    }
+}
+/**
+ * Connects to the driver-forwarded MJPEG port and emits complete JPEG frames.
+ * Reconnects with capped backoff while started — an Appium session rebuild
+ * lands on a fresh port, which `getPort` reflects on the next attempt. All
+ * timers are cancellable so `stop()` never holds the process open.
+ */
+export class MjpegStreamClient {
+    options;
+    active = false;
+    socket = null;
+    attempt = 0;
+    loop = null;
+    wake = null;
+    constructor(options) {
+        this.options = options;
+    }
+    isActive() {
+        return this.active;
+    }
+    start() {
+        if (this.active)
+            return;
+        this.active = true;
+        this.attempt = 0;
+        this.loop = this.run().catch((err) => {
+            this.options.log?.(`MJPEG capture loop crashed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    async stop() {
+        if (!this.active)
+            return;
+        this.active = false;
+        this.socket?.destroy();
+        this.socket = null;
+        this.wake?.();
+        await this.loop;
+        this.loop = null;
+    }
+    async run() {
+        while (this.active) {
+            try {
+                await this.options.ensureReady();
+                if (!this.active)
+                    break;
+                const port = this.options.getPort();
+                if (!port)
+                    throw new Error("MJPEG server port is not configured");
+                await this.streamOnce(port);
+            }
+            catch (err) {
+                if (this.active) {
+                    this.options.log?.(`MJPEG stream interrupted: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            if (!this.active)
+                break;
+            const delay = Math.min(1000 * 2 ** this.attempt, MAX_RECONNECT_DELAY_MS);
+            this.attempt += 1;
+            await this.sleep(delay);
+        }
+    }
+    streamOnce(port) {
+        return new Promise((resolve, reject) => {
+            const parser = new MjpegFrameParser();
+            const socket = this.options.createConnection?.(port) ?? connect({ host: "127.0.0.1", port });
+            this.socket = socket;
+            let failed = null;
+            socket.setNoDelay(true);
+            socket.setTimeout(STREAM_IDLE_TIMEOUT_MS, () => {
+                failed = new Error(`no stream data for ${STREAM_IDLE_TIMEOUT_MS}ms`);
+                socket.destroy();
+            });
+            // WDA streams to any TCP client; the UiAutomator2 server wants a request
+            // line first. Sending one is harmless for both.
+            socket.on("connect", () => {
+                socket.write("GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n");
+            });
+            socket.on("data", (chunk) => {
+                const frames = parser.push(chunk);
+                if (frames.length === 0)
+                    return;
+                // A delivered frame proves the pipeline works — restart backoff.
+                this.attempt = 0;
+                // Keep-latest: only the newest frame matters for a live view.
+                const latest = frames[frames.length - 1];
+                if (latest)
+                    this.options.onFrame(latest);
+            });
+            socket.on("error", (err) => {
+                failed = failed ?? err;
+            });
+            socket.on("close", () => {
+                if (this.socket === socket)
+                    this.socket = null;
+                if (failed)
+                    reject(failed);
+                else
+                    resolve();
+            });
+        });
+    }
+    sleep(ms) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.wake = null;
+                resolve();
+            }, ms);
+            timer.unref?.();
+            this.wake = () => {
+                clearTimeout(timer);
+                this.wake = null;
+                resolve();
+            };
+        });
+    }
+}

package/dist/mobile-control/mjpeg-stream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mobile-control/mjpeg-stream.test.js

@@ -0,0 +1,93 @@
+import { createServer } from "node:net";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { MjpegFrameParser, MjpegStreamClient } from "./mjpeg-stream.js";
+function jpeg(payload) {
+    return Buffer.from([0xff, 0xd8, ...payload, 0xff, 0xd9]);
+}
+describe("MjpegFrameParser", () => {
+    it("extracts a complete frame from one chunk", () => {
+        const parser = new MjpegFrameParser();
+        const frame = jpeg([1, 2, 3]);
+        expect(parser.push(frame)).toEqual([frame]);
+    });
+    it("reassembles a frame split across chunks", () => {
+        const parser = new MjpegFrameParser();
+        const frame = jpeg([9, 8, 7, 6]);
+        expect(parser.push(frame.subarray(0, 3))).toEqual([]);
+        expect(parser.push(frame.subarray(3))).toEqual([frame]);
+    });
+    it("skips multipart headers and boundary bytes between frames", () => {
+        const parser = new MjpegFrameParser();
+        const a = jpeg([1]);
+        const b = jpeg([2]);
+        const stream = Buffer.concat([
+            Buffer.from("HTTP/1.1 200 OK\r\nContent-Type: multipart/x-mixed-replace\r\n\r\n--BoundaryString\r\n"),
+            a,
+            Buffer.from("\r\n--BoundaryString\r\nContent-Length: 4\r\n\r\n"),
+            b,
+        ]);
+        expect(parser.push(stream)).toEqual([a, b]);
+    });
+    it("keeps a trailing partial marker across pushes", () => {
+        const parser = new MjpegFrameParser();
+        const frame = jpeg([5]);
+        // First push ends exactly on the 0xff of the next frame's SOI.
+        expect(parser.push(Buffer.concat([frame, Buffer.from([0xff])]))).toEqual([frame]);
+        const next = jpeg([6]);
+        expect(parser.push(next.subarray(1))).toEqual([next]);
+    });
+});
+describe("MjpegStreamClient", () => {
+    let server = null;
+    afterEach(() => {
+        server?.close();
+        server = null;
+    });
+    function listen(handler) {
+        return new Promise((resolve) => {
+            const created = createServer((socket) => {
+                socket.on("error", () => { });
+                handler((data) => socket.write(data));
+            });
+            server = created;
+            created.listen(0, "127.0.0.1", () => {
+                resolve(created.address().port);
+            });
+        });
+    }
+    it("delivers frames from the device stream", async () => {
+        const frame = jpeg([1, 2, 3, 4]);
+        const port = await listen((write) => {
+            write(Buffer.from("HTTP/1.1 200 OK\r\n\r\n"));
+            write(frame);
+        });
+        const frames = [];
+        const client = new MjpegStreamClient({
+            ensureReady: async () => { },
+            getPort: () => port,
+            onFrame: (f) => frames.push(f),
+        });
+        client.start();
+        await vi.waitFor(() => expect(frames.length).toBeGreaterThanOrEqual(1));
+        expect(frames[0]?.equals(frame)).toBe(true);
+        await client.stop();
+    });
+    it("stop() resolves promptly and stops reconnect attempts", async () => {
+        let readyCalls = 0;
+        const client = new MjpegStreamClient({
+            ensureReady: async () => {
+                readyCalls += 1;
+                throw new Error("session down");
+            },
+            getPort: () => undefined,
+            onFrame: () => { },
+        });
+        client.start();
+        await vi.waitFor(() => expect(readyCalls).toBeGreaterThanOrEqual(1));
+        await client.stop();
+        const after = readyCalls;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        expect(readyCalls).toBe(after);
+        expect(client.isActive()).toBe(false);
+    });
+});

package/dist/mobile-control/tunnel.d.ts

@@ -9,7 +9,16 @@ export interface RunControlTunnelOptions {
     installApp?: (args: {
         uploadId: string;
     }) => Promise<void>;
+    /**
+     * Live-view MJPEG pipeline hooks. The gateway demand-gates capture:
+     * `stream_start` when a viewer is watching, `stream_stop` when idle. Capture
+     * must also stop on release/disconnect so an unwatched phone never streams.
+     */
+    stream?: {
+        start: () => void;
+        stop: () => void;
+    };
     connect?: (wsUrl: string, deviceToken: string) => Socket;
 }
-export declare function registerHandlers(socket: Socket, controller: MobileController, installApp?: RunControlTunnelOptions["installApp"]): void;
+export declare function registerHandlers(socket: Socket, controller: MobileController, installApp?: RunControlTunnelOptions["installApp"], stream?: RunControlTunnelOptions["stream"]): void;
 export declare function runControlTunnel(options: RunControlTunnelOptions): Promise<void>;