An agentic browser harness: an AI side panel & orb in your own logged-in Chrome, Edge, Arc, Brave or even Firefox run by the agent/subscription you already use (Claude Code, Codex, Antigravity). Free, open source, no API key. Also an MCP server.
TypeScript agentic-browseragentic-browsingagy-cliaiai-agentai-browser-extensionai-toolsbrave-extensionbrowser-agentbrowser-automationbrowser-extensionbrowser-usebrowserskillchrome-extensionclaude-codecodexfirefox-addonmcp-servernanobrowserweb-automation
feat(android): the Bridge relays DevTools between the extension and Chrome on the phone: one session per phone, owned by the browser that opened it, events and screencast frames to the owner only, frames dropped and acked when its socket backs up, and every forward removed when a session ends
Shahriardf28fbfaadf8
diff --git a/src/daemon/android/relay.test.ts b/src/daemon/android/relay.test.tsnew file mode 100644index 0000000..f04e945--- /dev/null+++ b/src/daemon/android/relay.test.ts@@ -0,0 +1,293 @@+import { readFileSync } from 'node:fs';+import { createServer, type IncomingMessage, type Server } from 'node:http';+import { afterEach, beforeEach, describe, expect, test } from 'vitest';+import { WebSocketServer, type WebSocket } from 'ws';+import type { SocketFrame } from '@/lib/actions/protocol';+import type { AndroidState } from '@/lib/phone/types';+import { logPath } from '../lockfile';+import { startRelay, type PhoneOwner, type Relay } from './relay';++const SERIAL = 'emulator-5554';+const PAGE = 'A1B2C3D4E5F60718293A4B5C6D7E8F90';++/** Chrome on the phone, as far as the relay sees it through the forwarded port. */+class FakeChrome {+ readonly paths: string[] = [];+ readonly origins: (string | undefined)[] = [];+ readonly commands: { method: string; params?: Record<string, unknown>; sessionId?: string }[] = [];+ readonly sockets: WebSocket[] = [];+ private http!: Server;++ async listen(): Promise<number> {+ const wss = new WebSocketServer({ noServer: true });+ this.http = createServer((req, res) => {+ this.paths.push(req.url ?? '');+ if (req.url !== '/json/version') return res.writeHead(404).end();+ const { port } = this.http.address() as { port: number };+ res.writeHead(200, { 'content-type': 'application/json' }).end(+ JSON.stringify({ Browser: 'Chrome/150.0.7871.186', 'Android-Package': 'com.android.chrome', webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser` }),+ );+ });+ this.http.on('upgrade', (req: IncomingMessage, socket, head) => {+ this.origins.push(req.headers.origin);+ wss.handleUpgrade(req, socket, head, (ws) => this.serve(ws));+ });+ await new Promise<void>((resolve) => this.http.listen(0, '127.0.0.1', resolve));+ return (this.http.address() as { port: number }).port;+ }++ async close(): Promise<void> {+ for (const socket of this.sockets) socket.terminate();+ await new Promise((resolve) => this.http.close(resolve));+ }++ emit(method: string, params: Record<string, unknown>, sessionId?: string): void {+ for (const socket of this.sockets) socket.send(JSON.stringify({ method, params, sessionId }));+ }++ hangUp(): void {+ for (const socket of this.sockets) socket.terminate();+ }++ private serve(ws: WebSocket): void {+ this.sockets.push(ws);+ ws.on('message', (raw) => {+ const { id, method, params, sessionId } = JSON.parse(String(raw));+ this.commands.push({ method, params, sessionId });+ const reply = (body: object) => ws.send(JSON.stringify({ id, ...body }));+ if (method === 'Target.setDiscoverTargets') reply({ result: {} });+ else if (method === 'Target.getTargets') {+ reply({+ result: {+ targetInfos: [+ { targetId: PAGE, type: 'page', url: 'https://example.com/', title: 'Example' },+ { targetId: '1', type: 'page', url: 'https://example.com/', title: 'Example' },+ { targetId: 'B'.repeat(32), type: 'service_worker', url: 'https://example.com/sw.js', title: '' },+ ],+ },+ });+ } else if (method === 'Runtime.evaluate') reply({ result: { result: { type: 'string', value: 'Example' } } });+ else if (method === 'Hang.forever') return;+ else if (method !== 'Page.screencastFrameAck') reply({ error: { code: -32601, message: `'${method}' wasn't found` } });+ });+ }+}++class Owner implements PhoneOwner {+ readonly sent: SocketFrame[] = [];+ isOpen = true;+ bufferedAmount = 0;+ constructor(readonly id: string) {}+ send(frame: SocketFrame): void {+ this.sent.push(frame);+ }+ events(): string[] {+ return this.sent.flatMap((frame) => (frame.t === 'cdpEvent' ? [frame.method] : []));+ }+}++const READY: AndroidState = {+ enabled: true,+ ready: true,+ adb: { found: true },+ devices: [{ serial: SERIAL, transport: 'usb', state: 'ready', chrome: { installed: true, running: true, debuggable: true } }],+};++let chrome: FakeChrome;+let port: number;+let state: AndroidState;+let forwards: { made: string[]; removed: number[] };+let sessions: AndroidState['session'][];+let relay: Relay;++beforeEach(async () => {+ chrome = new FakeChrome();+ port = await chrome.listen();+ state = READY;+ forwards = { made: [], removed: [] };+ sessions = [];+ relay = startRelay({+ server: {+ forward: async (serial, remote) => {+ forwards.made.push(`${serial} ${remote}`);+ return port;+ },+ removeForward: async (_serial, local) => {+ forwards.removed.push(local);+ },+ },+ state: async () => state,+ onSession: (session) => sessions.push(session),+ timeouts: { connect: 1_000, command: 100, slow: 200 },+ });+});++afterEach(async () => {+ await relay.stop();+ await chrome.close();+});++const until = async (done: () => boolean) => {+ for (let tries = 0; !done(); tries++) {+ if (tries > 200) throw new Error('timed out waiting');+ await new Promise((resolve) => setTimeout(resolve, 5));+ }+};++describe('opening a phone', () => {+ test('forwards the DevTools socket, connects with no Origin, and lists only real pages', async () => {+ const owner = new Owner('chrome-1');+ expect(await relay.open(owner, SERIAL)).toEqual({+ ok: true,+ data: {+ device: READY.devices[0],+ targets: [{ targetId: PAGE, url: 'https://example.com/', title: 'Example' }],+ browserVersion: 'Chrome/150.0.7871.186',+ },+ });+ expect(forwards.made).toEqual([`${SERIAL} localabstract:chrome_devtools_remote`]);+ expect(chrome.paths).toEqual(['/json/version']);+ expect(chrome.origins).toEqual([undefined]);+ expect(chrome.commands.map(({ method }) => method)).toEqual(['Target.setDiscoverTargets', 'Target.getTargets']);+ expect(sessions).toEqual([{ serial: SERIAL, since: expect.any(String) }]);+ });++ test('a phone that is not there, or whose Chrome is closed, is refused before any forward', async () => {+ const owner = new Owner('chrome-1');+ expect(await relay.open(owner, 'R5CT1234567')).toMatchObject({ ok: false, error: { code: 'NO_DEVICE' } });+ state = { ...READY, devices: [{ ...READY.devices[0], chrome: { installed: true, running: true, debuggable: false } }] };+ expect(await relay.open(owner, SERIAL)).toMatchObject({ ok: false, error: { code: 'CHROME_NOT_RUNNING' } });+ expect(forwards.made).toEqual([]);+ });++ test('two opens at once make one session, and asking again answers from it', async () => {+ const owner = new Owner('chrome-1');+ const [first, second] = await Promise.all([relay.open(owner, SERIAL), relay.open(owner, SERIAL)]);+ expect([first.ok, second.ok]).toEqual([true, true]);+ expect(forwards.made).toHaveLength(1);+ expect(chrome.sockets).toHaveLength(1);+ });++ test('a second browser is told another owns the phone, for opens and for commands', async () => {+ await relay.open(new Owner('chrome-1'), SERIAL);+ const other = new Owner('edge-1');+ expect(await relay.open(other, SERIAL)).toMatchObject({ ok: false, error: { code: 'NOT_OWNER' } });+ expect(await relay.command(other, { t: 'cdp', id: 'x', serial: SERIAL, method: 'Runtime.evaluate' })).toMatchObject({+ ok: false,+ error: { code: 'NOT_OWNER' },+ });+ });++ test('a Chrome that refuses the connection leaves no forward behind', async () => {+ await chrome.close();+ expect(await relay.open(new Owner('chrome-1'), SERIAL)).toMatchObject({ ok: false, error: { code: 'PHONE_GONE' } });+ expect(forwards.removed).toEqual([port]);+ chrome = new FakeChrome();+ await chrome.listen();+ });+});++describe('commands and events', () => {+ let owner: Owner;+ beforeEach(async () => {+ owner = new Owner('chrome-1');+ await relay.open(owner, SERIAL);+ });++ test('a command goes to the phone with its session id, and its answer comes back', async () => {+ const result = await relay.command(owner, { t: 'cdp', id: 'f1', serial: SERIAL, method: 'Runtime.evaluate', params: { expression: 'document.title' }, sessionId: 'S1' });+ expect(result).toEqual({ ok: true, data: { result: { type: 'string', value: 'Example' } } });+ expect(chrome.commands.at(-1)).toEqual({ method: 'Runtime.evaluate', params: { expression: 'document.title' }, sessionId: 'S1' });+ });++ test('Chrome\'s refusal is CDP_ERROR in its own words, and silence is TIMEOUT', async () => {+ expect(await relay.command(owner, { t: 'cdp', id: 'f2', serial: SERIAL, method: 'Nope.nope' })).toEqual({+ ok: false,+ error: { code: 'CDP_ERROR', message: "'Nope.nope' wasn't found" },+ });+ expect(await relay.command(owner, { t: 'cdp', id: 'f3', serial: SERIAL, method: 'Hang.forever' })).toMatchObject({+ ok: false,+ error: { code: 'TIMEOUT' },+ });+ });++ test('a command for a phone with no session is PHONE_GONE', async () => {+ expect(await relay.command(owner, { t: 'cdp', id: 'f4', serial: 'R5CT1234567', method: 'Runtime.evaluate' })).toMatchObject({+ ok: false,+ error: { code: 'PHONE_GONE' },+ });+ });++ test('every event reaches the owner, with the session it came from', async () => {+ chrome.emit('Target.targetCreated', { targetInfo: { targetId: PAGE } });+ chrome.emit('Page.screencastFrame', { data: 'jpeg', sessionId: 1, metadata: {} }, 'S1');+ await until(() => owner.events().length === 2);+ expect(owner.sent.at(-1)).toEqual({ t: 'cdpEvent', serial: SERIAL, method: 'Page.screencastFrame', params: { data: 'jpeg', sessionId: 1, metadata: {} }, sessionId: 'S1' });+ });++ test('a backed-up owner misses screencast frames, which the Bridge acks itself, and nothing else', async () => {+ owner.bufferedAmount = 5 * 1024 * 1024;+ chrome.emit('Page.screencastFrame', { data: 'jpeg', sessionId: 7, metadata: {} }, 'S1');+ chrome.emit('Page.frameNavigated', { frame: { id: 'F' } }, 'S1');+ await until(() => owner.events().length === 1);+ expect(owner.events()).toEqual(['Page.frameNavigated']);+ await until(() => chrome.commands.some(({ method }) => method === 'Page.screencastFrameAck'));+ expect(chrome.commands.at(-1)).toEqual({ method: 'Page.screencastFrameAck', params: { sessionId: 7 }, sessionId: 'S1' });+ });++ test('the log names each method and never what it carried', async () => {+ await relay.command(owner, { t: 'cdp', id: 'f5', serial: SERIAL, method: 'Input.insertText', params: { text: 'hunter2-secret' } });+ await relay.command(owner, { t: 'cdp', id: 'f6', serial: SERIAL, method: 'Page.screencastFrameAck', params: { sessionId: 1 } });+ chrome.emit('Page.screencastFrame', { data: 'FRAME-PIXELS', sessionId: 2, metadata: {} });+ await until(() => owner.events().length === 1);+ const logged = readFileSync(logPath, 'utf8');+ expect(logged).toMatch(/phone emulator-5554 Input\.insertText CDP_ERROR in \d+ ms/);+ expect(logged).not.toMatch(/hunter2-secret|FRAME-PIXELS|Page\.screencastFrameAck/);+ });+});++describe('when a session ends', () => {+ let owner: Owner;+ beforeEach(async () => {+ owner = new Owner('chrome-1');+ await relay.open(owner, SERIAL);+ });++ test('Chrome going away fails the command in flight, tells the owner why, and removes the forward', async () => {+ const pending = relay.command(owner, { t: 'cdp', id: 'g1', serial: SERIAL, method: 'Hang.forever' });+ await until(() => chrome.commands.some(({ method }) => method === 'Hang.forever'));+ chrome.hangUp();+ expect(await pending).toMatchObject({ ok: false, error: { code: 'PHONE_GONE' } });+ await until(() => owner.sent.some((frame) => frame.t === 'phoneClosed'));+ expect(owner.sent.filter((frame) => frame.t === 'phoneClosed')).toEqual([{ t: 'phoneClosed', serial: SERIAL, reason: 'chrome-exited' }]);+ expect(forwards.removed).toEqual([port]);+ expect(sessions.at(-1)).toBeUndefined();+ });++ test('a phone that left adb\'s list was unplugged', async () => {+ state = { ...READY, ready: false, devices: [] };+ chrome.hangUp();+ await until(() => owner.sent.some((frame) => frame.t === 'phoneClosed'));+ expect(owner.sent.find((frame) => frame.t === 'phoneClosed')).toMatchObject({ reason: 'unplugged' });+ });++ test('the owner closing it, or going away, ends it quietly and removes the forward', async () => {+ await relay.close(owner, SERIAL);+ expect(forwards.removed).toEqual([port]);+ await relay.open(owner, SERIAL);+ await relay.release(owner);+ expect(forwards.removed).toEqual([port, port]);+ expect(owner.sent.filter((frame) => frame.t === 'phoneClosed')).toEqual([]);+ });++ test('another browser cannot close it', async () => {+ await relay.close(new Owner('edge-1'), SERIAL);+ expect(forwards.removed).toEqual([]);+ });++ test('the Bridge stopping tells the owner and removes the forward', async () => {+ await relay.stop();+ expect(owner.sent.filter((frame) => frame.t === 'phoneClosed')).toEqual([{ t: 'phoneClosed', serial: SERIAL, reason: 'bridge-stopping' }]);+ expect(forwards.removed).toEqual([port]);+ });+});diff --git a/src/daemon/android/relay.ts b/src/daemon/android/relay.tsnew file mode 100644index 0000000..05c8fc8--- /dev/null+++ b/src/daemon/android/relay.ts@@ -0,0 +1,230 @@+import WebSocket from 'ws';+import { failure, success, type ActionResult, type SocketFrame } from '@/lib/actions/protocol';+import type { AndroidState, PhoneClosedReason, PhoneOpened, PhoneTarget } from '@/lib/phone/types';+import { log } from '../log';+import type { AdbServer } from './adb-server';++export interface PhoneOwner {+ readonly id: string;+ readonly isOpen: boolean;+ readonly bufferedAmount: number;+ send(frame: SocketFrame): void;+}++export type CdpRequest = Extract<SocketFrame, { t: 'cdp' }>;+type CdpResult = ActionResult<Record<string, unknown>>;++export interface Relay {+ open(owner: PhoneOwner, serial: string): Promise<ActionResult<PhoneOpened>>;+ command(owner: PhoneOwner, request: CdpRequest): Promise<CdpResult>;+ close(owner: PhoneOwner, serial: string): Promise<void>;+ release(owner: PhoneOwner): Promise<void>;+ stop(): Promise<void>;+}++export interface RelayDeps {+ server: Pick<AdbServer, 'forward' | 'removeForward'>;+ state(): Promise<AndroidState>;+ onSession(session: AndroidState['session']): void;+ host?: string;+ timeouts?: { connect: number; command: number; slow: number };+}++const DEVTOOLS_SOCKET = 'localabstract:chrome_devtools_remote';+const TIMEOUTS = { connect: 5_000, command: 15_000, slow: 30_000 };+const SLOW_COMMANDS = new Set(['Page.captureScreenshot', 'Page.navigate']);+const FRAME_BACKLOG_BYTES = 4 * 1024 * 1024;+const MAX_MESSAGE_BYTES = 256 * 1024 * 1024;+/** Discovery also reports a phantom `"1"` for a restored tab, and every command sent to it hangs. */+const REAL_TARGET = /^[0-9A-F]{32}$/i;++interface Call {+ resolve(result: CdpResult): void;+ timer: ReturnType<typeof setTimeout>;+}++interface Session {+ serial: string;+ owner: PhoneOwner;+ port: number;+ socket: WebSocket;+ since: string;+ browserVersion: string;+ calls: Map<number, Call>;+ nextId: number;+}++export function startRelay({ server, state, onSession, host = '127.0.0.1', timeouts = TIMEOUTS }: RelayDeps): Relay {+ const sessions = new Map<string, Session>();+ const opening = new Map<string, Promise<unknown>>();++ const announce = () => {+ const [current] = sessions.values();+ onSession(current && { serial: current.serial, since: current.since });+ };++ function call(session: Session, method: string, params?: Record<string, unknown>, sessionId?: string): Promise<CdpResult> {+ if (sessions.get(session.serial) !== session || session.socket.readyState !== WebSocket.OPEN) {+ return Promise.resolve(failure('PHONE_GONE', 'The phone disconnected.'));+ }+ const id = session.nextId++;+ const timeoutMs = SLOW_COMMANDS.has(method) ? timeouts.slow : timeouts.command;+ return new Promise((resolve) => {+ const timer = setTimeout(() => {+ session.calls.delete(id);+ resolve(failure('TIMEOUT', `${method} got no answer from the phone within ${timeoutMs / 1000} s`));+ }, timeoutMs);+ session.calls.set(id, { resolve, timer });+ session.socket.send(JSON.stringify({ id, method, params, sessionId }));+ });+ }++ function receive(session: Session, raw: WebSocket.RawData): void {+ let message: { id?: number; result?: Record<string, unknown>; error?: { message?: string }; method?: string; params?: Record<string, unknown>; sessionId?: string };+ try {+ message = JSON.parse(String(raw));+ } catch {+ return;+ }+ if (typeof message.id === 'number') {+ const waiting = session.calls.get(message.id);+ if (!waiting) return;+ session.calls.delete(message.id);+ clearTimeout(waiting.timer);+ return waiting.resolve(message.error ? failure('CDP_ERROR', message.error.message ?? 'Chrome refused the command') : success(message.result ?? {}));+ }+ if (!message.method || !session.owner.isOpen) return;+ if (message.method === 'Page.screencastFrame' && session.owner.bufferedAmount > FRAME_BACKLOG_BYTES) {+ const ack = { id: session.nextId++, method: 'Page.screencastFrameAck', params: { sessionId: message.params?.sessionId }, sessionId: message.sessionId };+ return session.socket.send(JSON.stringify(ack));+ }+ session.owner.send({ t: 'cdpEvent', serial: session.serial, method: message.method, params: message.params ?? {}, sessionId: message.sessionId });+ }++ async function teardown(session: Session, reason: PhoneClosedReason, tellOwner: boolean): Promise<void> {+ if (sessions.get(session.serial) !== session) return;+ sessions.delete(session.serial);+ for (const waiting of session.calls.values()) {+ clearTimeout(waiting.timer);+ waiting.resolve(failure('PHONE_GONE', 'The phone disconnected while this command was on its way.'));+ }+ session.calls.clear();+ session.socket.removeAllListeners();+ session.socket.on('error', () => {});+ session.socket.terminate();+ await server.removeForward(session.serial, session.port).catch(() => {});+ if (tellOwner && session.owner.isOpen) session.owner.send({ t: 'phoneClosed', serial: session.serial, reason });+ log(`phone ${session.serial} session ended: ${reason}`);+ announce();+ }++ async function lost(session: Session): Promise<void> {+ const device = (await state().catch(() => null))?.devices.find((each) => each.serial === session.serial);+ await teardown(session, device?.state === 'ready' ? 'chrome-exited' : 'unplugged', true);+ }++ async function connect(serial: string, port: number): Promise<{ socket: WebSocket; browserVersion: string }> {+ const version = (await (await fetch(`http://${host}:${port}/json/version`, { signal: AbortSignal.timeout(timeouts.connect) })).json()) as {+ Browser?: string;+ webSocketDebuggerUrl?: string;+ };+ const path = version.webSocketDebuggerUrl ? new URL(version.webSocketDebuggerUrl).pathname : '/devtools/browser';+ const socket = new WebSocket(`ws://${host}:${port}${path}`, { perMessageDeflate: false, maxPayload: MAX_MESSAGE_BYTES });+ await new Promise<void>((resolve, reject) => {+ const timer = setTimeout(() => reject(new Error(`Chrome on ${serial} did not accept the DevTools connection`)), timeouts.connect);+ socket.once('open', () => {+ clearTimeout(timer);+ resolve();+ });+ socket.once('error', (error) => {+ clearTimeout(timer);+ reject(error);+ });+ });+ return { socket, browserVersion: version.Browser ?? 'Chrome' };+ }++ async function opened(session: Session): Promise<ActionResult<PhoneOpened>> {+ const listed = await call(session, 'Target.getTargets');+ const infos = (listed.ok ? (listed.data.targetInfos as { targetId: string; type: string; url: string; title: string }[] | undefined) : undefined) ?? [];+ const targets: PhoneTarget[] = infos+ .filter((info) => info.type === 'page' && REAL_TARGET.test(info.targetId))+ .map(({ targetId, url, title }) => ({ targetId, url, title }));+ const device = (await state()).devices.find((each) => each.serial === session.serial);+ if (!device) return failure('PHONE_GONE', 'The phone disconnected while the session was opening.');+ return success({ device, targets, browserVersion: session.browserVersion });+ }++ async function open(owner: PhoneOwner, serial: string): Promise<ActionResult<PhoneOpened>> {+ while (opening.has(serial)) await opening.get(serial);+ const held = sessions.get(serial);+ if (held && held.owner !== owner) return failure('NOT_OWNER', 'Another browser is driving this phone.');+ if (held) return opened(held);+ const attempt = start(owner, serial);+ opening.set(serial, attempt);+ try {+ return await attempt;+ } finally {+ opening.delete(serial);+ }+ }++ async function start(owner: PhoneOwner, serial: string): Promise<ActionResult<PhoneOpened>> {+ const device = (await state()).devices.find((each) => each.serial === serial);+ if (!device) return failure('NO_DEVICE', `No phone "${serial}" is connected.`);+ if (device.state !== 'ready') return failure(device.problem?.code ?? 'DEVICE_OFFLINE', device.problem?.message ?? 'The phone is not ready.');+ if (!device.chrome.debuggable) return failure('CHROME_NOT_RUNNING', 'Chrome is not open on the phone.');++ let port: number | undefined;+ try {+ port = await server.forward(serial, DEVTOOLS_SOCKET);+ const { socket, browserVersion } = await connect(serial, port);+ const session: Session = { serial, owner, port, socket, since: new Date().toISOString(), browserVersion, calls: new Map(), nextId: 1 };+ sessions.set(serial, session);+ socket.on('message', (raw) => receive(session, raw));+ socket.on('close', () => void lost(session));+ socket.on('error', () => socket.terminate());+ await call(session, 'Target.setDiscoverTargets', { discover: true });+ log(`phone ${serial} opened (${browserVersion}, forward tcp:${port})`);+ announce();+ return await opened(session);+ } catch (error) {+ if (port !== undefined && !sessions.has(serial)) await server.removeForward(serial, port).catch(() => {});+ const message = error instanceof Error ? error.message : String(error);+ log(`phone ${serial} did not open: ${message}`);+ return failure('PHONE_GONE', `Could not reach Chrome on the phone: ${message}`);+ }+ }++ return {+ open,++ async command(owner, { serial, method, params, sessionId }) {+ const session = sessions.get(serial);+ if (!session) return failure('PHONE_GONE', 'No phone session is open. Switch Android on again.');+ if (session.owner !== owner) return failure('NOT_OWNER', 'Another browser is driving this phone.');+ const started = Date.now();+ const result = await call(session, method, params, sessionId);+ if (!isChatter(method, params)) log(`phone ${serial} ${method} ${result.ok ? 'ok' : result.error.code} in ${Date.now() - started} ms`);+ return result;+ },++ async close(owner, serial) {+ const session = sessions.get(serial);+ if (session?.owner === owner) await teardown(session, 'closed', false);+ },++ async release(owner) {+ await Promise.all([...sessions.values()].filter((session) => session.owner === owner).map((session) => teardown(session, 'closed', false)));+ },++ async stop() {+ await Promise.all([...sessions.values()].map((session) => teardown(session, 'bridge-stopping', true)));+ },+ };+}++/** Screencast acks and finger or pointer moves arrive many times a second; one line each would bury everything else in daemon.log. */+function isChatter(method: string, params?: Record<string, unknown>): boolean {+ return method === 'Page.screencastFrameAck' || (method.startsWith('Input.dispatch') && /move/i.test(String(params?.type ?? '')));+}diff --git a/src/daemon/android/service.ts b/src/daemon/android/service.tsindex 8b0ebd4..10a4876 100644--- a/src/daemon/android/service.ts+++ b/src/daemon/android/service.ts@@ -1,5 +1,5 @@import { failure, success, type ActionResult } from '@/lib/actions/protocol';-import type { AndroidState } from '@/lib/phone/types';+import type { AndroidState, PhoneOpened } from '@/lib/phone/types';import { androidSettings, readAgentConfig, type AndroidSettings } from '../agent/config';import { log } from '../log';import { locateAdb, startServer, type AdbFound } from './adb';@@ -8,6 +8,7 @@ import { parseDeviceList, type TrackedDevice } from './devices';import { launchChrome, openChromeListing } from './launch';import { FACTS_COMMAND, parseFacts, type PhoneFacts } from './phone-facts';import { judge } from './readiness';+import { startRelay, type CdpRequest, type PhoneOwner } from './relay';export interface Android {state(): Promise<AndroidState>;@@ -17,6 +18,12 @@ export interface Android {*/watch(listener: (state: AndroidState) => void): () => void;launch(serial: string, url?: string): Promise<ActionResult<AndroidState>>;+ /** A session with Chrome on the phone, owned by the browser that opened it; only that browser's commands reach it. */+ open(owner: PhoneOwner, serial: string): Promise<ActionResult<PhoneOpened>>;+ command(owner: PhoneOwner, request: CdpRequest): Promise<ActionResult<Record<string, unknown>>>;+ close(owner: PhoneOwner, serial: string): Promise<void>;+ /** The owner went away: its sessions end without telling it. */+ release(owner: PhoneOwner): Promise<void>;stop(): Promise<void>;}@@ -42,11 +49,17 @@ export function androidOff(): Android {queueMicrotask(() => listener(ANDROID_OFF_STATE));return () => {};},- launch: async () => failure('ANDROID_OFF', ANDROID_OFF_STATE.problem?.message ?? 'Android is switched off.'),+ launch: async () => switchedOff(),+ open: async () => switchedOff(),+ command: async () => switchedOff(),+ close: async () => {},+ release: async () => {},stop: async () => {},};}+const switchedOff = () => failure('ANDROID_OFF', ANDROID_OFF_STATE.problem?.message ?? 'Android is switched off.');+export function liveAndroidDeps(): AndroidDeps {return {settings: () => androidSettings(readAgentConfig()),@@ -71,6 +84,17 @@ export function startAndroid(deps: AndroidDeps = liveAndroidDeps()): Android {let retrack: ReturnType<typeof setTimeout> | undefined;let refreshing: Promise<AndroidState> | null = null;let again = false;+ let session: AndroidState['session'];+ const current = (): Promise<AndroidState> => (latest && tracker ? Promise.resolve(latest) : refresh());+ const relay = startRelay({+ server: deps.server,+ state: current,+ onSession: (next) => {+ session = next;+ if (latest) publish({ ...latest, session });+ void refresh();+ },+ });const watched = () => heard.size > 0;@@ -128,7 +152,7 @@ export function startAndroid(deps: AndroidDeps = liveAndroidDeps()): Android {async function observe(): Promise<AndroidState> {const settings = deps.settings();- const seen = { enabled: settings.enabled, platform: deps.platform, devices: [] };+ const seen = { enabled: settings.enabled, platform: deps.platform, devices: [], session };if (!settings.enabled) {stopTracking();return judge(seen);@@ -185,7 +209,7 @@ export function startAndroid(deps: AndroidDeps = liveAndroidDeps()): Android {}return {- state: () => (latest && tracker ? Promise.resolve(latest) : refresh()),+ state: current,watch(listener) {heard.set(listener, '');@@ -223,7 +247,13 @@ export function startAndroid(deps: AndroidDeps = liveAndroidDeps()): Android {return success(await refresh());},+ open: (owner, serial) => relay.open(owner, serial),+ command: (owner, request) => relay.command(owner, request),+ close: (owner, serial) => relay.close(owner, serial),+ release: (owner) => relay.release(owner),+async stop() {+ await relay.stop();heard.clear();clearInterval(ticker);stopTracking();diff --git a/src/daemon/daemon.ts b/src/daemon/daemon.tsindex 0915f29..bf18c84 100644--- a/src/daemon/daemon.ts+++ b/src/daemon/daemon.ts@@ -425,6 +425,7 @@ export async function startDaemon({ version, idleExit = true, android = androidOscheduler.linkClosed(closing.id);analyses.cancelOwnedBy(closing);unwatchAndroid(closing);+ void android.release(closing);if (links.get(closing.id) === closing) links.delete(closing.id);log(`${closing.label} disconnected`);scheduleIdleExit();@@ -573,9 +574,13 @@ export async function startDaemon({ version, idleExit = true, android = androidO}if (request.t === 'phoneLaunch') {void android.launch(request.serial, request.url).then((result) => source.send({ t: 'androidInfo', id: request.id, result }));- return;+ } else if (request.t === 'phoneOpen') {+ void android.open(source, request.serial).then((result) => source.send({ t: 'phoneOpened', id: request.id, result }));+ } else if (request.t === 'cdp') {+ void android.command(source, request).then((result) => source.send({ t: 'cdpResult', id: request.id, result }));+ } else {+ void android.close(source, request.serial);}- answer(failure('UNSUPPORTED', 'This Bridge cannot drive a phone yet.'));}function openLinks(): ExtensionLink[] {diff --git a/src/daemon/extension-link.ts b/src/daemon/extension-link.tsindex 9052615..b5a4fe9 100644--- a/src/daemon/extension-link.ts+++ b/src/daemon/extension-link.ts@@ -83,6 +83,10 @@ export class ExtensionLink {return this.protocolVersion >= version;}+ get bufferedAmount(): number {+ return this.socket.bufferedAmount;+ }+get isOpen(): boolean {return !this.closed && this.socket.readyState === this.socket.OPEN;}diff --git a/src/daemon/test/fake-android.ts b/src/daemon/test/fake-android.tsindex a30ba54..70233fd 100644--- a/src/daemon/test/fake-android.ts+++ b/src/daemon/test/fake-android.ts@@ -1,5 +1,6 @@-import { success, type ActionResult } from '@/lib/actions/protocol';-import type { AndroidState } from '@/lib/phone/types';+import { failure, success, type ActionResult } from '@/lib/actions/protocol';+import type { AndroidState, PhoneOpened } from '@/lib/phone/types';+import type { CdpRequest, PhoneOwner } from '../android/relay';import type { Android } from '../android/service';export const NO_PHONE: AndroidState = {@@ -29,6 +30,9 @@ export const READY_PHONE: AndroidState = {export class FakeAndroid implements Android {current: AndroidState = NO_PHONE;readonly launched: string[] = [];+ /** Every phone request that reached the Bridge's Android half, by the browser that sent it. */+ readonly asked: { owner: string; t: string; serial: string; method?: string }[] = [];+ readonly released: string[] = [];private readonly listeners = new Set<(state: AndroidState) => void>();get watchers(): number {@@ -50,6 +54,25 @@ export class FakeAndroid implements Android {return success(this.current);}+ async open(owner: PhoneOwner, serial: string): Promise<ActionResult<PhoneOpened>> {+ this.asked.push({ owner: owner.id, t: 'phoneOpen', serial });+ const device = this.current.devices.find((each) => each.serial === serial);+ return device ? success({ device, targets: [], browserVersion: 'Chrome/150.0.7871.186' }) : failure('NO_DEVICE', 'No such phone.');+ }++ async command(owner: PhoneOwner, request: CdpRequest): Promise<ActionResult<Record<string, unknown>>> {+ this.asked.push({ owner: owner.id, t: 'cdp', serial: request.serial, method: request.method });+ return success({ echoed: request.method });+ }++ async close(owner: PhoneOwner, serial: string): Promise<void> {+ this.asked.push({ owner: owner.id, t: 'phoneClose', serial });+ }++ async release(owner: PhoneOwner): Promise<void> {+ this.released.push(owner.id);+ }+async stop(): Promise<void> {this.listeners.clear();}diff --git a/src/daemon/test/protocol-window.test.ts b/src/daemon/test/protocol-window.test.tsindex 0096047..c2688e4 100644--- a/src/daemon/test/protocol-window.test.ts+++ b/src/daemon/test/protocol-window.test.ts@@ -34,6 +34,8 @@ afterEach(async () => {clearAuth();android.current = NO_PHONE;android.launched.length = 0;+ android.asked.length = 0;+ android.released.length = 0;});async function control(): Promise<RemoteBridge> {@@ -131,6 +133,34 @@ describe('Android across the protocol window', () => {expect(android.launched).toEqual(['emulator-5554']);});+ test('a protocol-23 extension\'s phone requests reach the Bridge\'s Android half, and leaving releases its sessions', async () => {+ android.current = READY_PHONE;+ const browser = await pair({ ...store, protocolVersion: ANDROID_PROTOCOL });+ expect(await browser.ask({ t: 'phoneOpen', id: 'open-2', serial: 'emulator-5554' })).toMatchObject({+ t: 'phoneOpened',+ result: { ok: true, data: { device: { serial: 'emulator-5554' } } },+ });+ expect(await browser.ask({ t: 'cdp', id: 'cdp-2', serial: 'emulator-5554', method: 'Runtime.evaluate', params: { expression: '1' } })).toEqual({+ t: 'cdpResult',+ id: 'cdp-2',+ result: { ok: true, data: { echoed: 'Runtime.evaluate' } },+ });+ browser.tell({ t: 'phoneClose', id: 'close-2', serial: 'emulator-5554' });+ await browser.focus();+ expect(android.asked.map(({ t, method }) => method ?? t)).toEqual(['phoneOpen', 'Runtime.evaluate', 'phoneClose']);+ expect(new Set(android.asked.map(({ owner }) => owner))).toEqual(new Set([store.installId]));++ browser.close();+ await browser.closed;+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(android.released).toEqual([store.installId]);+ });++ test('a Firefox extension is not watched for phones, since its toggle is hidden', async () => {+ await pair({ origin: 'moz-extension://8f0e1d2c-0000-4000-8000-000000000000', installId: 'install-firefox-01', browser: 'Firefox', protocolVersion: ANDROID_PROTOCOL });+ expect(android.watchers).toBe(0);+ });+test('the control op answers the state, and a watcher hears it and each change', async () => {const bridge = await control();const heard: unknown[] = [];