local-browser-bridge 0.1.0

package/dist/src/codex.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCodexRoute = normalizeCodexRoute;
+exports.connectCodexViaCli = connectCodexViaCli;
+exports.connectCodexViaHttp = connectCodexViaHttp;
+const reference_adapter_1 = require("./reference-adapter");
+const claude_code_1 = require("./claude-code");
+const cli_reference_adapter_1 = require("./cli-reference-adapter");
+const http_reference_adapter_1 = require("./http-reference-adapter");
+function normalizeCodexRoute(route, sessionId) {
+    return (0, claude_code_1.normalizeClaudeCodeRoute)({ route, sessionId });
+}
+async function connectCodexViaCli(options) {
+    const adapter = (0, cli_reference_adapter_1.createCliBridgeAdapter)({
+        execute: options.execute
+    });
+    return (0, reference_adapter_1.connectViaBridge)(adapter, normalizeCodexRoute(options.route, options.sessionId));
+}
+async function connectCodexViaHttp(options) {
+    const adapter = (0, http_reference_adapter_1.createHttpBridgeAdapter)({
+        execute: options.execute,
+        paths: options.paths
+    });
+    return (0, reference_adapter_1.connectViaBridge)(adapter, normalizeCodexRoute(options.route, options.sessionId));
+}

package/dist/src/connection-ux.d.ts

@@ -0,0 +1,61 @@
+import { type BrowserAttachUxInterpretation } from "./browser-attach-ux-helper";
+import { type ClaudeCodeRouteName } from "./claude-code";
+import type { AttachService } from "./service/attach-service";
+import type { AttachmentSession, BridgeCapabilitiesContract, BrowserAttachMode, BrowserDiagnostics, ChromeRelayFailureOperation, ErrorPayload, SupportedBrowser } from "./types";
+export type ConnectionRouteName = ClaudeCodeRouteName;
+export interface ConnectionRouteInput {
+    route: ConnectionRouteName;
+    sessionId?: string;
+}
+export interface ConnectionNextStep {
+    action: "connect" | "fix-blocker" | "session-ready" | "retry" | "review-error";
+    prompt: string;
+    command?: string;
+}
+export type ConnectionOutcome = "success" | "blocked" | "unsupported" | "error";
+export type ConnectionStatus = "ready" | "connected" | "blocked" | "unsupported" | "failed";
+export type ConnectionCategory = "route-ready" | "route-blocked" | "session-connected" | "connection-blocked" | "connection-unsupported" | "connection-failed";
+export interface ConnectionReason {
+    code: string;
+    message: string;
+    retryable?: boolean;
+    userActionRequired?: boolean;
+}
+interface ConnectionRouteDescriptor {
+    name: ConnectionRouteName;
+    browser: SupportedBrowser;
+    attachMode: BrowserAttachMode;
+    sessionId?: string;
+}
+interface ConnectionEnvelopeBase {
+    ok: boolean;
+    command: "doctor" | "connect";
+    route: ConnectionRouteDescriptor;
+    operation: ChromeRelayFailureOperation;
+    outcome: ConnectionOutcome;
+    status: ConnectionStatus;
+    category: ConnectionCategory;
+    reason?: ConnectionReason;
+    summary: string;
+    prompt?: string;
+    nextStep: ConnectionNextStep;
+    capabilities: BridgeCapabilitiesContract;
+    diagnostics: BrowserDiagnostics;
+    routeUx: BrowserAttachUxInterpretation;
+}
+export interface ConnectionDoctorEnvelope extends ConnectionEnvelopeBase {
+    blocked: boolean;
+}
+export interface ConnectionConnectEnvelope extends ConnectionEnvelopeBase {
+    blocked: boolean;
+    connected: boolean;
+    session?: AttachmentSession;
+    sessionUx?: BrowserAttachUxInterpretation;
+    error?: ErrorPayload["error"];
+    errorUx?: BrowserAttachUxInterpretation;
+}
+export declare function normalizeConnectionRouteName(value: string | undefined): ConnectionRouteName;
+export declare function createServiceBridgeAdapter(service: Pick<AttachService, "getCapabilities" | "diagnostics" | "attach" | "resumeSession">): import("./reference-adapter").BridgeAdapter<BridgeCapabilitiesContract, AttachmentSession, import("./types").ResumedSession>;
+export declare function doctorConnectionRoute(service: Pick<AttachService, "getCapabilities" | "diagnostics" | "attach" | "resumeSession">, input: ConnectionRouteInput): Promise<ConnectionDoctorEnvelope>;
+export declare function connectConnectionRoute(service: Pick<AttachService, "getCapabilities" | "diagnostics" | "attach" | "resumeSession">, input: ConnectionRouteInput): Promise<ConnectionConnectEnvelope>;
+export {};

package/dist/src/connection-ux.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeConnectionRouteName = normalizeConnectionRouteName;
+exports.createServiceBridgeAdapter = createServiceBridgeAdapter;
+exports.doctorConnectionRoute = doctorConnectionRoute;
+exports.connectConnectionRoute = connectConnectionRoute;
+const browser_attach_ux_helper_1 = require("./browser-attach-ux-helper");
+const claude_code_1 = require("./claude-code");
+const errors_1 = require("./errors");
+const reference_adapter_1 = require("./reference-adapter");
+function normalizeConnectionRouteName(value) {
+    if (value === "safari" || value === "chrome-direct" || value === "chrome-relay") {
+        return value;
+    }
+    throw new errors_1.AppError("--route must be safari, chrome-direct, or chrome-relay.", 400, "invalid_route");
+}
+function createServiceBridgeAdapter(service) {
+    return (0, reference_adapter_1.createBridgeAdapter)({
+        async getCapabilities() {
+            return service.getCapabilities();
+        },
+        async getDiagnostics(browser) {
+            return service.diagnostics(browser);
+        },
+        async attach(route) {
+            return service.attach(route.browser, {
+                attach: route.attachMode ? { mode: route.attachMode } : undefined
+            });
+        },
+        async resume(sessionId) {
+            return service.resumeSession(sessionId);
+        }
+    });
+}
+function toDescriptor(input) {
+    const route = (0, claude_code_1.normalizeClaudeCodeRoute)(input);
+    return {
+        name: input.route,
+        browser: route.browser,
+        attachMode: route.attachMode ?? "direct",
+        ...(input.sessionId ? { sessionId: input.sessionId } : {})
+    };
+}
+function connectCommand(input) {
+    return input.sessionId
+        ? `local-browser-bridge connect --route ${input.route} --session-id ${input.sessionId}`
+        : `local-browser-bridge connect --route ${input.route}`;
+}
+function routeTruthNote(routeUx) {
+    if (routeUx.sharedTabScoped) {
+        return " It remains read-only and only covers the currently shared tab.";
+    }
+    if (routeUx.readOnly) {
+        return " It remains read-only.";
+    }
+    return " It is actionable.";
+}
+function summarizeDoctor(routeUx) {
+    if (routeUx.state === "blocked") {
+        return `${routeUx.label} is not ready yet.${routeTruthNote(routeUx)}`;
+    }
+    return `${routeUx.label} is ready for ${routeUx.operation === "resumeSession" ? "resume" : "attach"}.${routeTruthNote(routeUx)}`;
+}
+function summarizeSession(session, sessionUx) {
+    const verb = sessionUx.operation === "resumeSession" ? "Resumed" : "Connected";
+    return `${verb} ${sessionUx.label} session ${session.id}.${routeTruthNote(sessionUx)}`;
+}
+function summarizeFailure(routeUx, error) {
+    if (!routeUx) {
+        return `Connection failed: ${error.message}`;
+    }
+    return `${routeUx.label} could not connect.${routeTruthNote(routeUx)}`;
+}
+function nextStepForDoctor(input, routeUx) {
+    if (routeUx.state === "blocked") {
+        return {
+            action: "fix-blocker",
+            prompt: routeUx.prompt ?? "Resolve the reported blocker, then retry doctor or connect."
+        };
+    }
+    return {
+        action: "connect",
+        prompt: `Run ${connectCommand(input)} to continue.`,
+        command: connectCommand(input)
+    };
+}
+function nextStepForSession(session, sessionUx) {
+    if (session.status.canAct) {
+        return {
+            action: "session-ready",
+            prompt: `Use session ${session.id} for follow-up actions like activate, navigate, or screenshot.`
+        };
+    }
+    return {
+        action: "session-ready",
+        prompt: `Use session ${session.id} for inspect/resume flows and keep the read-only scope explicit.`
+    };
+}
+function nextStepForFailure(routeUx, error) {
+    if (routeUx?.userActionRequired || routeUx?.state === "user-action-required") {
+        return {
+            action: "fix-blocker",
+            prompt: routeUx.prompt ?? routeUx.retryGuidance ?? error.message
+        };
+    }
+    if (routeUx?.retryable) {
+        return {
+            action: "retry",
+            prompt: routeUx.retryGuidance ?? routeUx.prompt ?? error.message
+        };
+    }
+    return {
+        action: "review-error",
+        prompt: routeUx?.prompt ?? error.message
+    };
+}
+function firstDiagnosticBlocker(diagnostics, route) {
+    if (route.browser === "safari") {
+        return [
+            ...(diagnostics.preflight?.inspect.blockers ?? []),
+            ...(diagnostics.preflight?.automation.blockers ?? []),
+            ...(diagnostics.preflight?.screenshot.blockers ?? [])
+        ][0];
+    }
+    return (route.attachMode === "relay" ? diagnostics.attach?.relay?.blockers : diagnostics.attach?.direct?.blockers)?.[0];
+}
+function isUnsupportedReasonCode(code) {
+    return code === "shared_tab_scope_only"
+        || code === "unsupported_action"
+        || code === "unsupported_browser"
+        || code === "unsupported_route";
+}
+function toErrorReason(error, errorUx) {
+    return {
+        code: error.code,
+        message: error.message,
+        ...(typeof errorUx?.retryable === "boolean" ? { retryable: errorUx.retryable } : {}),
+        ...(typeof errorUx?.userActionRequired === "boolean" ? { userActionRequired: errorUx.userActionRequired } : {})
+    };
+}
+async function loadRouteState(adapter, input) {
+    const descriptor = toDescriptor(input);
+    const capabilities = await adapter.getCapabilities();
+    const diagnostics = await adapter.getDiagnostics(descriptor.browser);
+    const operation = input.sessionId ? "resumeSession" : "attach";
+    const routeUx = (0, browser_attach_ux_helper_1.interpretBrowserAttachUxFromDiagnostics)({
+        browser: descriptor.browser,
+        attachMode: descriptor.attachMode,
+        diagnostics,
+        operation
+    });
+    return {
+        descriptor,
+        capabilities,
+        diagnostics,
+        operation,
+        routeUx
+    };
+}
+async function doctorConnectionRoute(service, input) {
+    const adapter = createServiceBridgeAdapter(service);
+    const state = await loadRouteState(adapter, input);
+    return {
+        ok: state.routeUx.state !== "blocked",
+        command: "doctor",
+        route: state.descriptor,
+        operation: state.operation,
+        outcome: state.routeUx.state === "blocked" ? "blocked" : "success",
+        status: state.routeUx.state === "blocked" ? "blocked" : "ready",
+        category: state.routeUx.state === "blocked" ? "route-blocked" : "route-ready",
+        ...(state.routeUx.state === "blocked" ? { reason: firstDiagnosticBlocker(state.diagnostics, state.descriptor) } : {}),
+        summary: summarizeDoctor(state.routeUx),
+        prompt: state.routeUx.prompt,
+        nextStep: nextStepForDoctor(input, state.routeUx),
+        capabilities: state.capabilities,
+        diagnostics: state.diagnostics,
+        routeUx: state.routeUx,
+        blocked: state.routeUx.state === "blocked"
+    };
+}
+async function connectConnectionRoute(service, input) {
+    const adapter = createServiceBridgeAdapter(service);
+    const state = await loadRouteState(adapter, input);
+    try {
+        const prepared = await (0, claude_code_1.prepareClaudeCodeRoute)(adapter, input);
+        if (prepared.blocked) {
+            return {
+                ok: false,
+                command: "connect",
+                route: state.descriptor,
+                operation: state.operation,
+                outcome: "blocked",
+                status: "blocked",
+                category: "connection-blocked",
+                reason: firstDiagnosticBlocker(prepared.diagnostics, state.descriptor),
+                summary: summarizeDoctor(prepared.routeUx),
+                prompt: prepared.prompt,
+                nextStep: nextStepForDoctor(input, prepared.routeUx),
+                capabilities: prepared.capabilities,
+                diagnostics: prepared.diagnostics,
+                routeUx: prepared.routeUx,
+                blocked: true,
+                connected: false
+            };
+        }
+        const connection = prepared.connection;
+        return {
+            ok: true,
+            command: "connect",
+            route: state.descriptor,
+            operation: state.operation,
+            outcome: "success",
+            status: "connected",
+            category: "session-connected",
+            summary: summarizeSession(connection.session, connection.sessionUx),
+            prompt: prepared.prompt,
+            nextStep: nextStepForSession(connection.session, connection.sessionUx),
+            capabilities: connection.capabilities,
+            diagnostics: connection.diagnostics,
+            routeUx: connection.routeUx,
+            blocked: false,
+            connected: true,
+            session: connection.session,
+            sessionUx: connection.sessionUx
+        };
+    }
+    catch (error) {
+        const { payload } = (0, errors_1.toErrorPayload)(error);
+        const errorUx = (0, browser_attach_ux_helper_1.interpretBrowserAttachUxFromError)({
+            details: payload.error.details,
+            browser: state.descriptor.browser,
+            attachMode: state.descriptor.attachMode,
+            operation: state.operation
+        });
+        return {
+            ok: false,
+            command: "connect",
+            route: state.descriptor,
+            operation: state.operation,
+            outcome: isUnsupportedReasonCode(payload.error.code) ? "unsupported" : "error",
+            status: isUnsupportedReasonCode(payload.error.code) ? "unsupported" : "failed",
+            category: isUnsupportedReasonCode(payload.error.code) ? "connection-unsupported" : "connection-failed",
+            reason: toErrorReason(payload.error, errorUx),
+            summary: summarizeFailure(errorUx, payload.error),
+            prompt: errorUx?.prompt ?? payload.error.message,
+            nextStep: nextStepForFailure(errorUx, payload.error),
+            capabilities: state.capabilities,
+            diagnostics: state.diagnostics,
+            routeUx: state.routeUx,
+            blocked: false,
+            connected: false,
+            error: payload.error,
+            errorUx
+        };
+    }
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,12 @@
+import type { BridgeErrorDetails, ErrorPayload } from "./types";
+export declare class AppError<TDetails = BridgeErrorDetails> extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    readonly details?: TDetails;
+    constructor(message: string, statusCode?: number, code?: string, details?: TDetails);
+}
+export declare function toErrorPayload(error: unknown): {
+    statusCode: number;
+    payload: ErrorPayload;
+};
+export declare function writeJsonLine(stream: NodeJS.WritableStream, payload: unknown): void;

package/dist/src/errors.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+exports.toErrorPayload = toErrorPayload;
+exports.writeJsonLine = writeJsonLine;
+class AppError extends Error {
+    statusCode;
+    code;
+    details;
+    constructor(message, statusCode = 500, code = "internal_error", details) {
+        super(message);
+        this.name = "AppError";
+        this.statusCode = statusCode;
+        this.code = code;
+        this.details = details;
+    }
+}
+exports.AppError = AppError;
+function toErrorPayload(error) {
+    if (error instanceof AppError) {
+        return {
+            statusCode: error.statusCode,
+            payload: {
+                error: {
+                    code: error.code,
+                    message: error.message,
+                    statusCode: error.statusCode,
+                    ...(error.details ? { details: error.details } : {})
+                }
+            }
+        };
+    }
+    if (error instanceof SyntaxError) {
+        return {
+            statusCode: 400,
+            payload: {
+                error: {
+                    code: "invalid_json",
+                    message: "Request body must be valid JSON.",
+                    statusCode: 400
+                }
+            }
+        };
+    }
+    return {
+        statusCode: 500,
+        payload: {
+            error: {
+                code: "internal_error",
+                message: "Internal server error.",
+                statusCode: 500
+            }
+        }
+    };
+}
+function writeJsonLine(stream, payload) {
+    stream.write(JSON.stringify(payload, null, 2) + "\n");
+}

package/dist/src/http-reference-adapter.d.ts

@@ -0,0 +1,34 @@
+import { type BridgeAdapter, type BridgeSessionResult } from "./reference-adapter";
+import type { BrowserDiagnostics, BridgeCapabilitiesContract, ResumedSession } from "./types";
+export interface HttpBridgeRequest {
+    method: "GET" | "POST";
+    path: string;
+    body?: unknown;
+}
+export interface HttpBridgeResponse<TBody = unknown> {
+    status?: number;
+    body: TBody;
+}
+export type HttpBridgeExecutor = (request: HttpBridgeRequest) => Promise<HttpBridgeResponse>;
+export interface HttpCapabilitiesEnvelope<TCapabilities = BridgeCapabilitiesContract> {
+    capabilities?: TCapabilities;
+}
+export interface HttpDiagnosticsEnvelope {
+    diagnostics?: BrowserDiagnostics;
+}
+export interface HttpAttachEnvelope<TAttachResult extends BridgeSessionResult = BridgeSessionResult> {
+    session?: TAttachResult;
+}
+export interface HttpResumeEnvelope<TResumeResult extends ResumedSession = ResumedSession> {
+    resumedSession?: TResumeResult;
+}
+export interface CreateHttpBridgeAdapterOptions<TCapabilities = BridgeCapabilitiesContract, TAttachResult extends BridgeSessionResult = BridgeSessionResult, TResumeResult extends ResumedSession = ResumedSession> {
+    execute: HttpBridgeExecutor;
+    paths?: {
+        capabilities?: string;
+        diagnostics?: string;
+        attach?: string;
+        resumeSession?: (sessionId: string) => string;
+    };
+}
+export declare function createHttpBridgeAdapter<TCapabilities = BridgeCapabilitiesContract, TAttachResult extends BridgeSessionResult = BridgeSessionResult, TResumeResult extends ResumedSession = ResumedSession>(options: CreateHttpBridgeAdapterOptions<TCapabilities, TAttachResult, TResumeResult>): BridgeAdapter<TCapabilities, TAttachResult, TResumeResult>;

package/dist/src/http-reference-adapter.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpBridgeAdapter = createHttpBridgeAdapter;
+const errors_1 = require("./errors");
+const reference_adapter_1 = require("./reference-adapter");
+function requireEnvelopeField(envelope, key, context) {
+    const value = envelope[key];
+    if (value === undefined || value === null) {
+        throw new errors_1.AppError(`Expected ${context} response to include ${String(key)}.`, 500, "invalid_transport_response");
+    }
+    return value;
+}
+function buildQuery(path, values) {
+    const url = new URL(path, "http://local-browser-bridge.test");
+    for (const [key, value] of Object.entries(values)) {
+        if (value !== undefined) {
+            url.searchParams.set(key, value);
+        }
+    }
+    return `${url.pathname}${url.search}`;
+}
+function createHttpBridgeAdapter(options) {
+    const capabilitiesPath = options.paths?.capabilities ?? "/v1/capabilities";
+    const diagnosticsPath = options.paths?.diagnostics ?? "/v1/diagnostics";
+    const attachPath = options.paths?.attach ?? "/v1/attach";
+    const resumeSessionPath = options.paths?.resumeSession ?? ((sessionId) => `/v1/sessions/${encodeURIComponent(sessionId)}/resume`);
+    return (0, reference_adapter_1.createBridgeAdapter)({
+        async getCapabilities() {
+            const response = await options.execute({
+                method: "GET",
+                path: capabilitiesPath
+            });
+            return requireEnvelopeField(response.body, "capabilities", "capabilities");
+        },
+        async getDiagnostics(browser) {
+            const response = await options.execute({
+                method: "GET",
+                path: buildQuery(diagnosticsPath, { browser })
+            });
+            return requireEnvelopeField(response.body, "diagnostics", "diagnostics");
+        },
+        async attach(args) {
+            const response = await options.execute({
+                method: "POST",
+                path: attachPath,
+                body: {
+                    browser: args.browser,
+                    attach: { mode: args.attachMode }
+                }
+            });
+            return requireEnvelopeField(response.body, "session", "attach");
+        },
+        async resume(sessionId) {
+            const response = await options.execute({
+                method: "POST",
+                path: resumeSessionPath(sessionId)
+            });
+            return requireEnvelopeField(response.body, "resumedSession", "resumeSession");
+        }
+    });
+}

package/dist/src/http.d.ts

@@ -0,0 +1,3 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import { AttachService } from "./service/attach-service";
+export declare function createApiServer(service: AttachService): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/dist/src/http.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiServer = createApiServer;
+const node_http_1 = require("node:http");
+const errors_1 = require("./errors");
+const browser_1 = require("./browser");
+const target_1 = require("./target");
+function writeJson(response, statusCode, payload) {
+    response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(payload, null, 2));
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0) {
+        return {};
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    return JSON.parse(raw);
+}
+function requireString(value, fieldName, code) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new errors_1.AppError(`${fieldName} is required.`, 400, code);
+    }
+    return value.trim();
+}
+function createApiServer(service) {
+    return (0, node_http_1.createServer)(async (request, response) => {
+        try {
+            const url = new URL(request.url ?? "/", "http://127.0.0.1");
+            const method = request.method ?? "GET";
+            const sessionMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)$/);
+            const resumeMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/resume$/);
+            const activateMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/activate$/);
+            const navigateMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/navigate$/);
+            const sessionScreenshotMatch = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/screenshot$/);
+            if (method === "GET" && url.pathname === "/health") {
+                writeJson(response, 200, { ok: true });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/diagnostics") {
+                const browser = (0, browser_1.normalizeBrowser)(url.searchParams.get("browser") ?? undefined);
+                const diagnostics = await service.diagnostics(browser);
+                writeJson(response, 200, { diagnostics });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/capabilities") {
+                const browserFlag = url.searchParams.get("browser") ?? undefined;
+                const browser = browserFlag ? (0, browser_1.normalizeBrowser)(browserFlag) : undefined;
+                const capabilities = service.getCapabilities(browser);
+                writeJson(response, 200, { capabilities });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/front-tab") {
+                const browser = (0, browser_1.normalizeBrowser)(url.searchParams.get("browser") ?? undefined);
+                const frontTab = await service.inspectFrontTab(browser);
+                writeJson(response, 200, { frontTab });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/tab") {
+                const browser = (0, browser_1.normalizeBrowser)(url.searchParams.get("browser") ?? undefined);
+                const target = (0, target_1.buildTabTarget)({
+                    windowIndex: url.searchParams.get("windowIndex") ?? undefined,
+                    tabIndex: url.searchParams.get("tabIndex") ?? undefined,
+                    signature: url.searchParams.get("signature") ?? undefined,
+                    url: url.searchParams.get("url") ?? undefined,
+                    title: url.searchParams.get("title") ?? undefined
+                });
+                const tab = await service.inspectTab(browser, target);
+                writeJson(response, 200, { tab });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/tabs") {
+                const browser = (0, browser_1.normalizeBrowser)(url.searchParams.get("browser") ?? undefined);
+                const tabs = await service.listTabs(browser);
+                writeJson(response, 200, { tabs });
+                return;
+            }
+            if (method === "POST" && url.pathname === "/v1/attach") {
+                const body = (await readJsonBody(request));
+                const browser = (0, browser_1.normalizeBrowser)(body.browser);
+                const target = (0, target_1.buildTabTarget)(body.target);
+                const attachMode = body.attach?.mode;
+                if (attachMode !== undefined && attachMode !== "direct" && attachMode !== "relay") {
+                    throw new errors_1.AppError("attach.mode must be direct or relay.", 400, "invalid_attach_mode");
+                }
+                const session = await service.attach(browser, {
+                    target,
+                    attach: { mode: attachMode }
+                });
+                writeJson(response, 201, { session });
+                return;
+            }
+            if (method === "POST" && url.pathname === "/v1/activate") {
+                const body = (await readJsonBody(request));
+                const browser = (0, browser_1.normalizeBrowser)(body.browser);
+                const target = (0, target_1.buildTabTarget)(body.target);
+                const activation = await service.activate(browser, target);
+                writeJson(response, 201, { activation });
+                return;
+            }
+            if (method === "POST" && url.pathname === "/v1/navigate") {
+                const body = (await readJsonBody(request));
+                const browser = (0, browser_1.normalizeBrowser)(body.browser);
+                const target = (0, target_1.buildTabTarget)(body.target);
+                const navigation = await service.navigate(browser, target, {
+                    url: requireString(body.url, "url", "missing_url")
+                });
+                writeJson(response, 201, { navigation });
+                return;
+            }
+            if (method === "POST" && url.pathname === "/v1/screenshot") {
+                const body = (await readJsonBody(request));
+                const browser = (0, browser_1.normalizeBrowser)(body.browser);
+                const target = (0, target_1.buildTabTarget)(body.target);
+                const screenshot = await service.screenshot(browser, target, { outputPath: body.outputPath });
+                writeJson(response, 201, { screenshot });
+                return;
+            }
+            if (method === "GET" && url.pathname === "/v1/sessions") {
+                const sessions = await service.listSessions();
+                writeJson(response, 200, { sessions });
+                return;
+            }
+            if (method === "GET" && sessionMatch) {
+                const session = await service.getSession(decodeURIComponent(sessionMatch[1]));
+                writeJson(response, 200, { session });
+                return;
+            }
+            if (method === "POST" && resumeMatch) {
+                const resumedSession = await service.resumeSession(decodeURIComponent(resumeMatch[1]));
+                writeJson(response, 200, { resumedSession });
+                return;
+            }
+            if (method === "POST" && activateMatch) {
+                const sessionActivation = await service.activateSession(decodeURIComponent(activateMatch[1]));
+                writeJson(response, 201, { sessionActivation });
+                return;
+            }
+            if (method === "POST" && navigateMatch) {
+                const body = (await readJsonBody(request));
+                const sessionNavigation = await service.navigateSession(decodeURIComponent(navigateMatch[1]), { url: requireString(body.url, "url", "missing_url") });
+                writeJson(response, 201, { sessionNavigation });
+                return;
+            }
+            if (method === "POST" && sessionScreenshotMatch) {
+                const body = (await readJsonBody(request));
+                const sessionScreenshot = await service.screenshotSession(decodeURIComponent(sessionScreenshotMatch[1]), { outputPath: body.outputPath });
+                writeJson(response, 201, { sessionScreenshot });
+                return;
+            }
+            writeJson(response, 404, { error: { code: "not_found", message: "Route not found.", statusCode: 404 } });
+        }
+        catch (error) {
+            const { statusCode, payload } = (0, errors_1.toErrorPayload)(error);
+            writeJson(response, statusCode, payload);
+        }
+    });
+}