@reclaimprotocol/agent 0.1.24 → 0.1.25

package/src/mcp/tools/agent/live-view.ts

@@ -16,22 +16,14 @@
 import { badRequest, conflict } from '@hapi/boom'
 import assert from 'node:assert'
 import { startTunnel, type Tunnel } from '../../../live/tunnel.ts'
-import { type LiveView, startLiveView } from '../../../live/viewer.ts'
 import { LOGGER } from '../../../logger.ts'
 import { defineTool, type RegisteredTool } from '../../server.ts'
-import type { AttachState } from './attach.ts'
-import type { CaptureStore } from './capture.ts'
-
-/** Modes whose browser we reach over our own CDP connection, and which
- *  therefore have no hosted live view of their own. */
-const SHAREABLE_MODES = new Set(['dedicated', 'attach', 'custom'])
+import { type AttachState, SHAREABLE_MODES } from './attach.ts'
 
 export interface LiveShare {
-	view: LiveView
 	tunnel: Tunnel
+	/** The public URL handed to whoever is watching. */
 	url: string
-	interactive: boolean
-	startedAt: number
 }
 
 export interface LiveShareRef {
@@ -47,9 +39,8 @@ export async function stopLiveShare(ref: LiveShareRef): Promise<boolean> {
 	}
 
 	ref.current = undefined
-	await share.view.stop().catch((err) => {
-		LOGGER.warn({ err }, 'live view: server stop failed')
-	})
+	// Only the tunnel is ours to close. The browser and its viewer belong to the
+	// container, which keeps running until the browser is disposed.
 	await share.tunnel.stop().catch((err) => {
 		LOGGER.warn({ err }, 'live view: tunnel stop failed')
 	})
@@ -58,61 +49,52 @@ export async function stopLiveShare(ref: LiveShareRef): Promise<boolean> {
 
 export function liveViewTools(
 	attachRef: { current?: AttachState },
-	captures: CaptureStore,
 	shareRef: LiveShareRef,
 ): RegisteredTool[] {
 	return [
-		defineTool<{ tabId?: string, interactive?: boolean }>(
+		defineTool<Record<string, never>>(
 			{
 				name: 'share_browser_view',
 				description:
-					'Put the attached tab behind a PUBLIC HTTPS URL (a cloudflared '
-					+ 'quick tunnel) so someone elsewhere can watch it live, and by '
-					+ 'default click and type in it. Use it to hand a login or a 2FA '
-					+ 'step to the person who holds the credentials, or to let a '
-					+ 'colleague watch a capture. Returns the URL — relay it to the '
-					+ 'developer VERBATIM, on its own line. '
-					+ 'ONLY for a locally attached browser (attach_browser mode '
-					+ '`dedicated`, `attach`, or `custom`). In `builder` mode the '
-					+ 'Popcorn browser already has a hosted live view: use the '
-					+ '`liveViewUrl` that attach_browser returned instead. '
-					+ 'THE URL IS A CREDENTIAL: anyone holding it can see this tab, '
-					+ 'and with the default `interactive: true` can act in it as the '
-					+ 'signed-in user. Share it only with the person who needs it, and '
-					+ 'call stop_browser_view the moment they are done. Pass '
-					+ '`interactive: false` for a watch-only link. '
+					'Put the attached browser\'s live view behind a PUBLIC HTTPS URL (a '
+					+ 'cloudflared quick tunnel) so someone elsewhere can watch it and '
+					+ 'act in it. Use it to hand a login or a 2FA step to the person '
+					+ 'who holds the credentials, or to let a colleague watch a '
+					+ 'capture. Returns the URL — relay it to the developer VERBATIM, '
+					+ 'on its own line. '
+					+ 'ONLY for `container` mode, whose browser runs its own viewer. '
+					+ 'A `builder` browser already has a hosted live view: use the '
+					+ '`liveViewUrl` attach_browser returned. A local browser '
+					+ '(`dedicated`, `attach`, `custom`) cannot be shared at all — no '
+					+ 'tunnel can fix that, because there is no viewer behind it. Tell '
+					+ 'them so, and offer to re-attach: `container` is free and needs '
+					+ 'Docker, `builder` needs no install but is chargeable. '
+					+ 'THE URL IS THE ONLY CREDENTIAL: the random hostname is the whole '
+					+ 'secret, with no token or login behind it, so anyone who learns '
+					+ 'it can see and drive this browser as the signed-in user. Share '
+					+ 'it only with the person who needs it, and call stop_browser_view '
+					+ 'the moment they are done. '
 					+ 'Needs cloudflared: an existing install on PATH is used as-is, '
 					+ 'otherwise it is downloaded once to ~/.reclaim/bin on first '
 					+ 'share (never at install time). Set RECLAIM_CLOUDFLARED_PATH to '
 					+ 'point at your own copy instead.',
-				inputSchema: {
-					type: 'object',
-					properties: {
-						tabId: {
-							type: 'string',
-							description:
-								'Tab to stream, from list_tabs. Defaults to the tab the '
-								+ 'active capture is on, else the first tab.',
-						},
-						interactive: {
-							type: 'boolean',
-							description:
-								'Let the viewer click and type in the page. Default true. '
-								+ 'Set false to stream a read-only view.',
-						},
-					},
-				},
+				inputSchema: { type: 'object', properties: {} },
 			},
-			async({ tabId, interactive }) => {
+			async() => {
+
 				const attached = attachRef.current
 				assert(attached, badRequest(
 					'No browser attached. Call attach_browser first.',
 				))
 				assert(SHAREABLE_MODES.has(attached.mode), badRequest(
 					`share_browser_view does not apply to \`${attached.mode}\` mode. `
-					+ 'That browser already has a hosted live view — use the '
-					+ '`liveViewUrl` from attach_browser'
-					+ (attached.liveViewUrl ? `: ${attached.liveViewUrl}` : '')
+					+ (attached.liveViewUrl
+						? 'That browser already has a hosted live view — use the '
+							+ `\`liveViewUrl\` from attach_browser: ${attached.liveViewUrl}`
+						: 'That browser has no live view to put behind a URL. To let '
+							+ 'someone else in, re-attach with mode "container" (the '
+							+ 'Reclaim runtime in Docker — free, needs Docker) or '
+							+ '"builder" (hosted, no install, chargeable)')
 					+ '.',
 				))
 				assert(!shareRef.current, conflict(
@@ -121,47 +103,42 @@ export function liveViewTools(
 					+ 'reuse that URL.',
 				))
 
-				const tabs = tabId || captures.activeTab
-					? []
-					: await attached.handles.listTabs()
-				const target = tabId ?? captures.activeTab ?? tabs[0]?.tabId
-				assert(target, badRequest(
-					'No tab to stream. Open a tab, or call list_tabs to pick one.',
+				// The container publishes its viewer on loopback and its full CDP
+				// port beside it. Only the VIEWER is ever tunnelled: the CDP port is
+				// unauthenticated, total control of the browser, and putting it on a
+				// public URL would hand that to anyone with the link.
+				const viewerPort = attached.viewerPort
+				assert(viewerPort, badRequest(
+					'This browser reports no live-view port. Re-attach with mode '
+					+ '"container".',
 				))
 
-				const tab = await attached.handles.attachToTab(target)
-				const wantsInput = interactive !== false
-				const view = await startLiveView({
-					tab,
-					interactive: wantsInput,
-					title: `Reclaim — ${attached.mode} browser`,
-				})
-
-				let tunnel: Tunnel
-				try {
-					tunnel = await startTunnel(view.port)
-				} catch(err) {
-					// Don't leave the loopback server behind if the tunnel failed.
-					await view.stop().catch(() => {})
-					throw err
-				}
-
-				const url = `${tunnel.url}${view.path}`
+				const tunnel = await startTunnel(viewerPort)
+				// The path is the runtime's own viewer page; `magnify=1` is what makes
+				// it lay out for the device that opens it.
+				const url = `${tunnel.url}/liveview.html?magnify=1`
 				const share: LiveShare = {
-					view, tunnel, url, interactive: wantsInput, startedAt: Date.now(),
+					tunnel, url,
 				}
 				shareRef.current = share
-				LOGGER.info({ mode: attached.mode, interactive: wantsInput },
-					'live view shared')
+				LOGGER.info({ mode: attached.mode }, 'live view shared')
 
 				return {
 					url,
-					interactive: wantsInput,
-					tabId: target,
 					...(share.tunnel.binary.source === 'downloaded'
 						? { cloudflaredInstalled: true }
 						: {}),
-					...(share.tunnel.ready ? {} : { propagating: true }),
+					...(share.tunnel.ready
+						? {}
+						: {
+							propagating: true,
+							// cloudflared's own last words. Without them, "the URL does
+							// not connect" is unactionable: the tunnel, the local server
+							// and this machine's egress all look identical from outside.
+							...(share.tunnel.diagnostics
+								? { cloudflaredLog: share.tunnel.diagnostics }
+								: {}),
+						}),
 					_notes: [
 						...(share.tunnel.binary.source === 'downloaded'
 							? ['cloudflared was not installed, so it was downloaded once '
@@ -169,14 +146,21 @@ export function liveViewTools(
 							: []),
 						...(share.tunnel.ready
 							? []
-							: ['The tunnel had not started routing yet — if the URL '
-								+ 'errors, wait a few seconds and reload.']),
+							: ['The tunnel never confirmed a connection to Cloudflare, so '
+								+ 'the URL may not resolve yet. Give it ~10s and reload '
+								+ 'first. If it still fails, say so and offer to retry '
+								+ '(stop_browser_view then share_browser_view) — a quick '
+								+ 'tunnel does sometimes fail to register. '
+								+ '`cloudflaredLog` has its output if it keeps happening.']),
 						'Relay `url` to the developer verbatim, on its own line.',
-						'The URL is a credential: it needs no login, and anyone with '
-						+ 'it can see this tab'
-						+ (wantsInput ? ' and act in it as the signed-in user.' : '.'),
-						'Call stop_browser_view when they are done — the tunnel stays '
-						+ 'open until you do.',
+						'The URL is a credential: it needs no login, and anyone with it '
+						+ 'can see this browser and act in it as the signed-in user.',
+						'It shows the whole browser, so a sign-in that opens a separate '
+						+ 'window is visible too — unlike a single-tab stream.',
+						'Opening it on a phone lays the page out for that phone, with '
+						+ 'touch, pinch-zoom and the soft keyboard.',
+						'Call stop_browser_view when they are done. That closes the '
+						+ 'tunnel only — the browser keeps running.',
 					],
 				}
 			},
@@ -185,11 +169,11 @@ export function liveViewTools(
 			{
 				name: 'stop_browser_view',
 				description:
-					'Close the public live view opened by share_browser_view: stops '
-					+ 'the screen stream and shuts the tunnel down, so the URL stops '
-					+ 'resolving. Call it as soon as the person you shared with is '
-					+ 'finished. The browser itself stays attached and the capture '
-					+ 'keeps running.',
+					'Close the public URL opened by share_browser_view: shuts the '
+					+ 'tunnel down, so the URL stops resolving for whoever still has '
+					+ 'it. Call it as soon as the person you shared with is finished. '
+					+ 'Nothing else changes — the browser stays attached, its own live '
+					+ 'view keeps serving locally, and any capture keeps running.',
 				inputSchema: { type: 'object', properties: {} },
 			},
 			async() => ({ stopped: await stopLiveShare(shareRef) }),

package/src/mcp/tools/agent/session.ts

@@ -33,11 +33,7 @@ export function sessionTools(
 				// URL can recover it instead of opening a second tunnel.
 				...(liveShare.current
 					? {
-						sharedView: {
-							url: liveShare.current.url,
-							interactive: liveShare.current.interactive,
-							viewers: liveShare.current.view.viewers(),
-						},
+						sharedView: { url: liveShare.current.url },
 					}
 					: {}),
 			}),
@@ -74,13 +70,23 @@ export function sessionTools(
 	]
 }
 
-async function resetAll(
+/**
+ * Release everything a session holds: the public tunnel, the captures, and the
+ * browser itself.
+ *
+ * Exported because a session can end WITHOUT anyone calling `dispose_browser` —
+ * the developer closes their agent, the client kills the server, the transport
+ * drops. Nothing runs on its own then, so `start.ts` runs this. Without it a
+ * container keeps running and, worse, a public URL to a live browser outlives
+ * the session that created it.
+ */
+export async function resetAll(
 	attachRef: { current?: AttachState, config: ConfigStore },
 	captures: CaptureStore,
 	liveShare: LiveShareRef,
 ) {
-	// Before the captures: the live view holds a tab session of its own, and a
-	// public URL must never outlive the browser it points at.
+	// Before the captures: a public URL must never outlive the browser it points
+	// at.
 	await stopLiveShare(liveShare)
 	await resetCaptures(captures)
 	await disposeAttached(attachRef)

package/lib/cdp/browser-proxy.d.ts

@@ -1,78 +0,0 @@
-/** The minimal CDP surface this module needs. Both the agent's `CdpTabClient`
- *  and an app-side session-scoped wrapper around `chrome-remote-interface`'s
- *  `CDP.Client` already satisfy this. */
-export interface CdpProxySender {
-    send: (method: string, params?: object) => Promise<unknown>;
-    subscribe: <T = unknown>(method: string, listener: (params: T) => void) => () => void;
-}
-export interface BrowserProxyCredentials {
-    host: string;
-    port: number;
-    username: string;
-    password: string;
-}
-export interface TemplatedProxyUsernameOptions {
-    /** Vendor's env-configured base, e.g.
-     *  `brd-customer-<id>-zone-<zone>-country-{{COUNTRY_LOCATION}}`. */
-    template: string;
-    countryCode: string;
-    /** Sticky-session key — the same value must be used for every request
-     *  that should exit through the same proxy IP. */
-    proxySessionId: string;
-}
-/** Substitute `{{COUNTRY_LOCATION}}` in the vendor's username template (or
- *  append `-country-<cc>` if the template has no placeholder), then append
- *  the sticky-session suffix. */
-export declare function buildTemplatedProxyUsername(opts: TemplatedProxyUsernameOptions): string;
-/** A short alphanumeric sticky-session id suggestion for a proxy vendor's
- *  session placeholder (e.g. Bright Data's `-session-<id>` suffix) —
- *  deliberately not `captureId`/`sessionId` (long UUIDs, wrong shape for
- *  most vendors' conventions and for the attestor's own `proxySessionId`
- *  constraint: smallcase alphanumeric, 8-14 chars). Only a suggestion — the
- *  caller's own `proxySessionId`, when given, is used instead. */
-export declare function generateProxySessionId(): string;
-/** Parse a `PROXY_SERVER`-style `host:port` string. Throws on a malformed
- *  value — a bad env var should fail loudly, not silently proxy nowhere. */
-export declare function parseProxyServer(server: string): {
-    host: string;
-    port: number;
-};
-/**
- * Route the browser's network traffic through `host:port` via the Popcorn
- * extension's page API. Never throws — a `false` return means the extension
- * couldn't be reached (e.g. this isn't a Popcorn browser); callers still get
- * proxy auth wired up by {@link setupProxyAuthViaCdp} independently, since a
- * caller-supplied proxy might already be configured another way.
- */
-export declare function configureBrowserProxyViaExtension(sender: CdpProxySender, config: BrowserProxyCredentials): Promise<boolean>;
-/** Clear the extension-configured proxy, routing the browser direct again. */
-export declare function clearBrowserProxyViaExtension(sender: CdpProxySender): Promise<boolean>;
-/**
- * Answer the proxy's Basic-auth challenge over CDP `Fetch`, since Popcorn's
- * extension only sets host/port routing (not credentials — the proxy vendor
- * still challenges the browser for them the normal way). Self-disables once
- * the first challenge is answered (or after a timeout with none), rather
- * than intercepting every request for the session's whole lifetime.
- */
-export declare function setupProxyAuthViaCdp(sender: CdpProxySender, credentials: Pick<BrowserProxyCredentials, 'username' | 'password'>): Promise<void>;
-export interface ApplyBrowserProxyOptions extends BrowserProxyCredentials {
-    /** Defaults to true — proxy routing only affects new connections, so
-     *  existing page state must reload to actually go through it. */
-    reload?: boolean;
-}
-export interface ApplyBrowserProxyResult {
-    /** False means the extension wasn't reachable (not a Popcorn browser, or
-     *  it isn't installed) — auth handling was still armed regardless, in
-     *  case the proxy is configured another way. */
-    appliedViaExtension: boolean;
-}
-/** Configure routing + auth + reload, in the right order: routing must be
- *  live before the reload navigates, and auth must be armed before that
- *  navigation's requests go out. */
-export declare function applyBrowserProxy(sender: CdpProxySender, opts: ApplyBrowserProxyOptions): Promise<ApplyBrowserProxyResult>;
-/** Clear proxy routing and reload so subsequent requests go direct again. */
-export declare function clearBrowserProxy(sender: CdpProxySender, opts?: {
-    reload?: boolean;
-}): Promise<{
-    cleared: boolean;
-}>;

package/lib/cdp/browser-proxy.js

@@ -1,186 +0,0 @@
-/**
- * Native browser-level proxy for a Popcorn remote browser session.
- *
- * Routes the browser's OWN network traffic (not the attestor's zkTLS egress —
- * that's `geoLocation`/`useProxy` on `ProviderWebSettings`) through a
- * user-supplied proxy. Applied via the Popcorn kiosk image's `window.__pcn`
- * page API rather than a Playwright/CDP launch arg or a new browser context —
- * both of those would spawn a browser outside the pod's `--kiosk` window,
- * breaking the live-view stream this session is already being watched
- * through. Proxy auth (username/password) is answered separately over CDP's
- * `Fetch` domain, since Popcorn's extension only sets host/port routing.
- *
- * Shared between the app's verification runner and the agent's MCP tools —
- * both drive a Popcorn browser over `chrome-remote-interface`, just through
- * different wrapper types, so this module only depends on the minimal
- * {@link CdpProxySender} shape rather than either package's CDP client.
- */
-import { randomInt } from 'node:crypto';
-import { setTimeout as delay } from 'node:timers/promises';
-import { LOGGER } from "../logger.js";
-/** Substitute `{{COUNTRY_LOCATION}}` in the vendor's username template (or
- *  append `-country-<cc>` if the template has no placeholder), then append
- *  the sticky-session suffix. */
-export function buildTemplatedProxyUsername(opts) {
-    const { template, countryCode, proxySessionId } = opts;
-    const cc = countryCode.toLowerCase();
-    const base = template.includes('{{COUNTRY_LOCATION}}')
-        ? template.replaceAll('{{COUNTRY_LOCATION}}', cc)
-        : `${template}-country-${cc}`;
-    return `${base}-session-${proxySessionId}`;
-}
-const PROXY_SESSION_ID_CHARS = 'abcdefghijklmnopqrstuvwxyz0123456789';
-const PROXY_SESSION_ID_LENGTH = 10;
-/** A short alphanumeric sticky-session id suggestion for a proxy vendor's
- *  session placeholder (e.g. Bright Data's `-session-<id>` suffix) —
- *  deliberately not `captureId`/`sessionId` (long UUIDs, wrong shape for
- *  most vendors' conventions and for the attestor's own `proxySessionId`
- *  constraint: smallcase alphanumeric, 8-14 chars). Only a suggestion — the
- *  caller's own `proxySessionId`, when given, is used instead. */
-export function generateProxySessionId() {
-    let out = '';
-    for (let i = 0; i < PROXY_SESSION_ID_LENGTH; i++) {
-        out += PROXY_SESSION_ID_CHARS[randomInt(PROXY_SESSION_ID_CHARS.length)];
-    }
-    return out;
-}
-/** Parse a `PROXY_SERVER`-style `host:port` string. Throws on a malformed
- *  value — a bad env var should fail loudly, not silently proxy nowhere. */
-export function parseProxyServer(server) {
-    const match = /^([^:/]+):(\d+)$/.exec(server.trim());
-    if (!match) {
-        throw new Error(`PROXY_SERVER must be "host:port", got "${server}"`);
-    }
-    return { host: match[1], port: Number(match[2]) };
-}
-const PCN_READY_TIMEOUT_MS = 5000;
-const PCN_READY_POLL_MS = 100;
-/** Chrome caches a proxy credential per host:port after the first successful
- *  challenge, so this only needs to cover the FIRST request. If no challenge
- *  ever arrives (proxy doesn't require auth), don't leave `Fetch` enabled —
- *  it would otherwise hold every request pending on this handler forever. */
-const PROXY_AUTH_SAFETY_TIMEOUT_MS = 15000;
-async function isExtensionReady(sender) {
-    const { result } = await sender.send('Runtime.evaluate', {
-        expression: 'Boolean(window.__pcn && window.__pcn.ready)',
-        returnByValue: true,
-    });
-    return result?.value === true;
-}
-async function waitForExtensionReady(sender) {
-    const deadline = Date.now() + PCN_READY_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        if (await isExtensionReady(sender)) {
-            return true;
-        }
-        await delay(PCN_READY_POLL_MS);
-    }
-    return false;
-}
-/**
- * Route the browser's network traffic through `host:port` via the Popcorn
- * extension's page API. Never throws — a `false` return means the extension
- * couldn't be reached (e.g. this isn't a Popcorn browser); callers still get
- * proxy auth wired up by {@link setupProxyAuthViaCdp} independently, since a
- * caller-supplied proxy might already be configured another way.
- */
-export async function configureBrowserProxyViaExtension(sender, config) {
-    try {
-        if (!await isExtensionReady(sender)) {
-            // Force the content script to (re-)run so `window.__pcn` appears.
-            await sender.send('Page.navigate', { url: 'about:blank' });
-            if (!await waitForExtensionReady(sender)) {
-                LOGGER.warn('popcorn proxy extension not ready; skipping __pcn.set');
-                return false;
-            }
-        }
-        const { result } = await sender.send('Runtime.evaluate', {
-            expression: `(async () => {
-				try { await window.__pcn.set(${JSON.stringify(config)}); return true }
-				catch(e) { return false }
-			})()`,
-            awaitPromise: true,
-            returnByValue: true,
-        });
-        return result?.value === true;
-    }
-    catch (err) {
-        LOGGER.warn({ err }, 'configureBrowserProxyViaExtension failed');
-        return false;
-    }
-}
-/** Clear the extension-configured proxy, routing the browser direct again. */
-export async function clearBrowserProxyViaExtension(sender) {
-    try {
-        const { result } = await sender.send('Runtime.evaluate', {
-            expression: `(async () => {
-				try { await window.__pcn.clear(); return true }
-				catch(e) { return false }
-			})()`,
-            awaitPromise: true,
-            returnByValue: true,
-        });
-        return result?.value === true;
-    }
-    catch (err) {
-        LOGGER.warn({ err }, 'clearBrowserProxyViaExtension failed');
-        return false;
-    }
-}
-/**
- * Answer the proxy's Basic-auth challenge over CDP `Fetch`, since Popcorn's
- * extension only sets host/port routing (not credentials — the proxy vendor
- * still challenges the browser for them the normal way). Self-disables once
- * the first challenge is answered (or after a timeout with none), rather
- * than intercepting every request for the session's whole lifetime.
- */
-export async function setupProxyAuthViaCdp(sender, credentials) {
-    await sender.send('Fetch.enable', { handleAuthRequests: true });
-    let settled = false;
-    const finish = () => {
-        if (settled) {
-            return;
-        }
-        settled = true;
-        unsubAuth();
-        unsubPaused();
-        sender.send('Fetch.disable').catch(() => { });
-    };
-    const unsubAuth = sender.subscribe('Fetch.authRequired', (params) => {
-        sender.send('Fetch.continueWithAuth', {
-            requestId: params.requestId,
-            authChallengeResponse: {
-                response: 'ProvideCredentials',
-                username: credentials.username,
-                password: credentials.password,
-            },
-        }).then(finish).catch(() => { });
-    });
-    // Requests still need releasing while `Fetch` is enabled, whether or not
-    // they end up challenged. Fire-and-forget: serializing behind auth
-    // negotiation would stall unrelated requests.
-    const unsubPaused = sender.subscribe('Fetch.requestPaused', (params) => {
-        sender.send('Fetch.continueRequest', { requestId: params.requestId })
-            .catch(() => { });
-    });
-    setTimeout(finish, PROXY_AUTH_SAFETY_TIMEOUT_MS);
-}
-/** Configure routing + auth + reload, in the right order: routing must be
- *  live before the reload navigates, and auth must be armed before that
- *  navigation's requests go out. */
-export async function applyBrowserProxy(sender, opts) {
-    const appliedViaExtension = await configureBrowserProxyViaExtension(sender, opts);
-    await setupProxyAuthViaCdp(sender, opts);
-    if (opts.reload !== false) {
-        await sender.send('Page.reload', {});
-    }
-    return { appliedViaExtension };
-}
-/** Clear proxy routing and reload so subsequent requests go direct again. */
-export async function clearBrowserProxy(sender, opts = {}) {
-    const cleared = await clearBrowserProxyViaExtension(sender);
-    if (opts.reload !== false) {
-        await sender.send('Page.reload', {});
-    }
-    return { cleared };
-}

package/lib/live/page.d.ts

@@ -1,20 +0,0 @@
-/**
- * The live-view page served to whoever opens the tunnel URL.
- *
- * Deliberately dependency-free and inline: it is delivered through a throwaway
- * tunnel, so it cannot rely on a CDN, a bundler, or anything cached.
- *
- * Frames arrive as base64 JPEG over Server-Sent Events rather than a
- * WebSocket. SSE is one plain GET, so it survives tunnels and proxies that
- * mishandle upgrades, and it reconnects on its own. Input goes the other way
- * as small POSTs.
- */
-export interface PageOptions {
-    /** Path prefix that carries the access token, for example `/v/<token>`. */
-    base: string;
-    /** Whether to wire up mouse and keyboard forwarding. */
-    interactive: boolean;
-    /** Shown in the header so a viewer knows which tab they are watching. */
-    title: string;
-}
-export declare function renderViewerPage(opts: PageOptions): string;