@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/plugins/custom-rtmp/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * Custom RTMP streaming destination plugin.
- *
- * The simplest streaming destination — reads RTMP URL and key directly
- * from config. No platform API calls, no chat bridging.
- */
-import type { StreamingDestination } from "../../api/stream-routes";
-export declare function createCustomRtmpDestination(config?: {
-    rtmpUrl?: string;
-    rtmpKey?: string;
-}): StreamingDestination;
-//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/plugins/custom-rtmp/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/plugins/custom-rtmp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,wBAAgB,2BAA2B,CAAC,MAAM,CAAC,EAAE;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,oBAAoB,CA2BvB"}

package/packages/agent/src/plugins/custom-rtmp/index.js

@@ -1,26 +0,0 @@
-/**
- * Custom RTMP streaming destination plugin.
- *
- * The simplest streaming destination — reads RTMP URL and key directly
- * from config. No platform API calls, no chat bridging.
- */
-export function createCustomRtmpDestination(config) {
-    return {
-        id: "custom-rtmp",
-        name: "Custom RTMP",
-        async getCredentials() {
-            const rtmpUrl = (config?.rtmpUrl ??
-                process.env.CUSTOM_RTMP_URL ??
-                "").trim();
-            const rtmpKey = (config?.rtmpKey ??
-                process.env.CUSTOM_RTMP_KEY ??
-                "").trim();
-            if (!rtmpUrl || !rtmpKey) {
-                throw new Error("Custom RTMP requires rtmpUrl and rtmpKey in streaming.customRtmp config");
-            }
-            return { rtmpUrl, rtmpKey };
-        },
-        // No onStreamStart/onStreamStop — no platform to notify
-        // No chat polling — no platform chat
-    };
-}

package/packages/agent/src/runtime/cloud-onboarding.d.ts

@@ -1,55 +0,0 @@
-/**
- * Cloud onboarding flow for Eliza Cloud integration.
- *
- * Handles availability check → browser-based auth → agent provisioning
- * during `runFirstTimeSetup()`. Extracted to keep `eliza.ts` manageable.
- *
- * @module cloud-onboarding
- */
-/** Lazy-loaded @clack/prompts module type (matches eliza.ts pattern). */
-type ClackModule = typeof import("@clack/prompts");
-/** Style preset from onboarding-presets.ts. */
-interface StylePreset {
-    catchphrase: string;
-    hint?: string;
-    bio?: string[];
-    system?: string;
-    style?: {
-        all?: string[];
-        chat?: string[];
-        post?: string[];
-    };
-    adjectives?: string[];
-    topics?: string[];
-    postExamples?: string[];
-    messageExamples?: Array<Array<{
-        user: string;
-        content: {
-            text: string;
-        };
-    }>>;
-}
-/** Result of a successful cloud onboarding flow. */
-export interface CloudOnboardingResult {
-    apiKey: string;
-    agentId: string | undefined;
-    baseUrl: string;
-    bridgeUrl?: string;
-}
-/**
- * Quick pre-flight check: is Eliza Cloud accepting new agents?
- * Returns null if available, or an error message string if not.
- */
-export declare function checkCloudAvailability(baseUrl: string): Promise<string | null>;
-/**
- * Run the full cloud onboarding flow:
- * 1. Check availability
- * 2. Authenticate via browser
- * 3. Create + provision agent
- *
- * Returns the result or null if the user cancels / an error occurs.
- * On failure, the caller should fall back to local mode.
- */
-export declare function runCloudOnboarding(clack: ClackModule, agentName: string, preset?: StylePreset, baseUrl?: string): Promise<CloudOnboardingResult | null>;
-export {};
-//# sourceMappingURL=cloud-onboarding.d.ts.map

package/packages/agent/src/runtime/cloud-onboarding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cloud-onboarding.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/cloud-onboarding.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAcH,yEAAyE;AACzE,KAAK,WAAW,GAAG,cAAc,gBAAgB,CAAC,CAAC;AAEnD,+CAA+C;AAC/C,UAAU,WAAW;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC7D,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC,CAAC,CAAC;CAC7E;AAED,oDAAoD;AACpD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAcD;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8BxB;AAqJD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CA8DvC"}

package/packages/agent/src/runtime/cloud-onboarding.js

@@ -1,279 +0,0 @@
-/**
- * Cloud onboarding flow for Eliza Cloud integration.
- *
- * Handles availability check → browser-based auth → agent provisioning
- * during `runFirstTimeSetup()`. Extracted to keep `eliza.ts` manageable.
- *
- * @module cloud-onboarding
- */
-import { logger } from "@elizaos/core";
-import { cloudLogin } from "../cloud/auth";
-import { normalizeCloudSiteUrl } from "../cloud/base-url";
-import { ElizaCloudClient, } from "../cloud/bridge-client";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const DEFAULT_CLOUD_BASE_URL = "https://www.elizacloud.ai";
-const PROVISION_TIMEOUT_MS = 120_000; // 2 minutes
-const PROVISION_POLL_INTERVAL_MS = 3_000;
-// ---------------------------------------------------------------------------
-// Availability check
-// ---------------------------------------------------------------------------
-/**
- * Quick pre-flight check: is Eliza Cloud accepting new agents?
- * Returns null if available, or an error message string if not.
- */
-export async function checkCloudAvailability(baseUrl) {
-    try {
-        const url = `${normalizeCloudSiteUrl(baseUrl)}/api/compat/availability`;
-        const res = await fetch(url, {
-            method: "GET",
-            headers: { Accept: "application/json" },
-            signal: AbortSignal.timeout(10_000),
-        });
-        if (!res.ok) {
-            return `Cloud returned HTTP ${res.status}. It may be temporarily unavailable.`;
-        }
-        const body = (await res.json());
-        if (!body.success || !body.data?.acceptingNewAgents) {
-            return "Eliza Cloud is currently at capacity. Try again later or run locally.";
-        }
-        return null; // Available!
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes("timed out") || msg.includes("timeout")) {
-            return "Could not reach Eliza Cloud (request timed out). Check your internet connection.";
-        }
-        return `Could not reach Eliza Cloud: ${msg}`;
-    }
-}
-// ---------------------------------------------------------------------------
-// Cloud auth wrapper (with clack UI)
-// ---------------------------------------------------------------------------
-/**
- * Run the Eliza Cloud browser-based login, wrapped with clack spinners.
- * Returns the API key/result or null if the user wants to fall back.
- */
-async function runCloudAuth(clack, baseUrl) {
-    const spinner = clack.spinner();
-    spinner.start("Connecting to Eliza Cloud...");
-    try {
-        const result = await cloudLogin({
-            baseUrl,
-            timeoutMs: 300_000, // 5 minutes
-            onBrowserUrl: (url) => {
-                spinner.stop("Opening your browser to log in...");
-                clack.log.info(`If the browser didn't open, visit:\n  ${url}`);
-                // Try to open the browser
-                openBrowser(url).catch(() => {
-                    // Fallback: user can manually navigate
-                });
-                // Restart spinner for polling
-                spinner.start("Waiting for login in browser...");
-            },
-            onPollStatus: (status) => {
-                if (status === "pending") {
-                    spinner.message("Waiting for login in browser...");
-                }
-            },
-        });
-        spinner.stop("✓ Logged in to Eliza Cloud!");
-        return result;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        spinner.stop(`Login failed: ${msg}`);
-        return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Agent provisioning
-// ---------------------------------------------------------------------------
-/**
- * Create and provision a cloud agent, polling until it's running.
- * Returns the agent ID or null if provisioning fails.
- */
-async function provisionCloudAgent(clack, client, agentName, preset) {
-    const spinner = clack.spinner();
-    spinner.start("Creating your cloud agent...");
-    try {
-        // Build the agent config from the chosen style preset
-        const agentConfig = {};
-        if (preset) {
-            agentConfig.bio = preset.bio;
-            agentConfig.system = preset.system;
-            agentConfig.style = preset.style;
-            agentConfig.adjectives = preset.adjectives;
-            agentConfig.topics = preset.topics;
-            agentConfig.postExamples = preset.postExamples;
-            agentConfig.messageExamples = preset.messageExamples;
-        }
-        const params = {
-            agentName,
-            agentConfig,
-        };
-        const agent = await client.createAgent(params);
-        const agentId = agent.id;
-        spinner.message("Agent created! Provisioning cloud environment...");
-        // Poll for running status
-        const deadline = Date.now() + PROVISION_TIMEOUT_MS;
-        let lastStatus = agent.status;
-        while (Date.now() < deadline) {
-            await sleep(PROVISION_POLL_INTERVAL_MS);
-            try {
-                const current = await client.getAgent(agentId);
-                lastStatus = current.status;
-                switch (lastStatus) {
-                    case "running":
-                    case "completed":
-                        spinner.stop(`☁️  Cloud agent "${agentName}" is running!`);
-                        return { agentId, bridgeUrl: current.bridgeUrl };
-                    case "failed":
-                    case "error":
-                        spinner.stop(`Provisioning failed: ${current.errorMessage ?? "unknown error"}`);
-                        return null;
-                    case "queued":
-                        spinner.message("Queued — waiting for available slot...");
-                        break;
-                    case "provisioning":
-                        spinner.message("Provisioning cloud environment...");
-                        break;
-                    default:
-                        spinner.message(`Status: ${lastStatus}...`);
-                }
-            }
-            catch (pollErr) {
-                // Transient polling error — keep trying
-                logger.debug(`[cloud-onboarding] Poll error: ${pollErr instanceof Error ? pollErr.message : pollErr}`);
-            }
-        }
-        // Timed out
-        spinner.stop(`Provisioning timed out (last status: ${lastStatus}). The agent may still be starting up.`);
-        // Return the ID anyway — user can reconnect later
-        return { agentId };
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        spinner.stop(`Failed to create cloud agent: ${msg}`);
-        return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Main orchestrator
-// ---------------------------------------------------------------------------
-/**
- * Run the full cloud onboarding flow:
- * 1. Check availability
- * 2. Authenticate via browser
- * 3. Create + provision agent
- *
- * Returns the result or null if the user cancels / an error occurs.
- * On failure, the caller should fall back to local mode.
- */
-export async function runCloudOnboarding(clack, agentName, preset, baseUrl) {
-    const resolvedBaseUrl = normalizeCloudSiteUrl(baseUrl ?? DEFAULT_CLOUD_BASE_URL);
-    // ── Step 1: Availability check ──────────────────────────────────────
-    const unavailableReason = await checkCloudAvailability(resolvedBaseUrl);
-    if (unavailableReason) {
-        clack.log.warn(unavailableReason);
-        const fallback = await clack.confirm({
-            message: "Run locally instead?",
-            initialValue: true,
-        });
-        if (clack.isCancel(fallback) || fallback) {
-            return null; // Fall back to local
-        }
-        // User said "no" to fallback — try auth anyway (maybe availability is
-        // temporarily wrong).
-    }
-    // ── Step 2: Browser-based auth ──────────────────────────────────────
-    const authResult = await runCloudAuth(clack, resolvedBaseUrl);
-    if (!authResult) {
-        clack.log.warn("Cloud login was not completed.");
-        const retry = await clack.confirm({
-            message: "Try again, or run locally?",
-            active: "Try again",
-            inactive: "Run locally",
-            initialValue: false,
-        });
-        if (clack.isCancel(retry) || !retry) {
-            return null; // Fall back to local
-        }
-        // Retry auth once
-        const retryResult = await runCloudAuth(clack, resolvedBaseUrl);
-        if (!retryResult) {
-            clack.log.warn("Login was not completed. Falling back to local mode.");
-            return null;
-        }
-        // Use retry result
-        return await finishProvisioning(clack, resolvedBaseUrl, retryResult, agentName, preset);
-    }
-    return await finishProvisioning(clack, resolvedBaseUrl, authResult, agentName, preset);
-}
-/**
- * Complete provisioning after successful auth.
- */
-async function finishProvisioning(clack, baseUrl, authResult, agentName, preset) {
-    // ── Step 3: Create + provision agent ──────────────────────────────
-    const client = new ElizaCloudClient(baseUrl, authResult.apiKey);
-    const provisionResult = await provisionCloudAgent(clack, client, agentName, preset);
-    if (!provisionResult) {
-        clack.log.warn("Cloud provisioning did not complete. You can try `eliza cloud connect` later.");
-        const runLocal = await clack.confirm({
-            message: "Continue with local setup instead?",
-            initialValue: true,
-        });
-        if (clack.isCancel(runLocal) || runLocal) {
-            return null;
-        }
-        // User doesn't want local either — just return the auth result
-        // so config is saved (they can reconnect later)
-        return {
-            apiKey: authResult.apiKey,
-            agentId: undefined, // No agent provisioned yet
-            baseUrl,
-        };
-    }
-    return {
-        apiKey: authResult.apiKey,
-        agentId: provisionResult.agentId,
-        baseUrl,
-        bridgeUrl: provisionResult.bridgeUrl,
-    };
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Try to open a URL in the user's default browser.
- * Falls back silently — the URL is also printed to the terminal.
- *
- * Uses execFile with an args array (not exec with string interpolation)
- * to avoid shell injection via crafted URLs.
- */
-async function openBrowser(url) {
-    const { execFile } = await import("node:child_process");
-    const { platform } = await import("node:os");
-    const p = platform();
-    return new Promise((resolve) => {
-        const onError = (err) => {
-            if (err) {
-                logger.debug(`[cloud-onboarding] Failed to open browser: ${err.message}`);
-            }
-            resolve();
-        };
-        if (p === "darwin") {
-            execFile("open", [url], onError);
-        }
-        else if (p === "win32") {
-            execFile("cmd.exe", ["/c", "start", "", url], onError);
-        }
-        else {
-            execFile("xdg-open", [url], onError);
-        }
-    });
-}

package/packages/agent/src/server/index.d.ts

@@ -1,3 +0,0 @@
-export type { captureEarlyLogs } from "../api/server";
-export { startApiServer } from "../api/server";
-//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/server/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/server/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC"}

package/packages/agent/src/server/index.js

@@ -1 +0,0 @@
-export { startApiServer } from "../api/server";

package/packages/agent/src/services/browser-capture.d.ts

@@ -1,39 +0,0 @@
-/**
- * Headless browser capture — opens the StreamView in headless Chrome and
- * saves screenshots to a temp file. FFmpeg reads the temp file using
- * -loop 1 to continuously re-read the latest frame.
- *
- * This approach avoids the pipe bottleneck — FFmpeg reads at its own
- * pace while the browser updates the file independently.
- *
- * Visual parity with the desktop shell:
- * - Appends `?popout` to the URL so the app renders StreamView directly
- *   (skips onboarding, auth gates, navigation chrome).
- * - Enables SwiftShader for WebGL so VRM avatar renders identically.
- * - Seeds localStorage with overlay layout, theme, and avatar index so
- *   the first rendered frame matches the configured appearance.
- * - Uses `waitUntil: "networkidle0"` to ensure all assets load before capture.
- * - Keeps CSS animations/transitions enabled for visual parity.
- */
-/** Path to the temp frame file that FFmpeg reads */
-export declare const FRAME_FILE: string;
-export interface BrowserCaptureConfig {
-    url: string;
-    width?: number;
-    height?: number;
-    fps?: number;
-    quality?: number;
-    /** Optional overlay layout JSON to seed into localStorage before page load. */
-    overlayLayout?: string;
-    /** Theme name to apply (e.g. "eliza", "haxor", "psycho"). */
-    theme?: string;
-    /** Avatar VRM index (1–8). */
-    avatarIndex?: number;
-    /** Destination ID — seeds the destination-specific localStorage key. */
-    destinationId?: string;
-}
-export declare function startBrowserCapture(config: BrowserCaptureConfig): Promise<void>;
-export declare function stopBrowserCapture(): Promise<void>;
-export declare function isBrowserCaptureRunning(): boolean;
-export declare function hasFrameFile(): boolean;
-//# sourceMappingURL=browser-capture.d.ts.map

package/packages/agent/src/services/browser-capture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser-capture.d.ts","sourceRoot":"","sources":["../../../../../src/services/browser-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAiBH,oDAAoD;AACpD,eAAO,MAAM,UAAU,QAA2C,CAAC;AAEnE,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAgCD,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,oBAAoB,iBAiHrE;AAED,wBAAsB,kBAAkB,kBASvC;AAED,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}

package/packages/agent/src/services/browser-capture.js

@@ -1,162 +0,0 @@
-/**
- * Headless browser capture — opens the StreamView in headless Chrome and
- * saves screenshots to a temp file. FFmpeg reads the temp file using
- * -loop 1 to continuously re-read the latest frame.
- *
- * This approach avoids the pipe bottleneck — FFmpeg reads at its own
- * pace while the browser updates the file independently.
- *
- * Visual parity with the desktop shell:
- * - Appends `?popout` to the URL so the app renders StreamView directly
- *   (skips onboarding, auth gates, navigation chrome).
- * - Enables SwiftShader for WebGL so VRM avatar renders identically.
- * - Seeds localStorage with overlay layout, theme, and avatar index so
- *   the first rendered frame matches the configured appearance.
- * - Uses `waitUntil: "networkidle0"` to ensure all assets load before capture.
- * - Keeps CSS animations/transitions enabled for visual parity.
- */
-import { existsSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import puppeteer from "puppeteer-core";
-const CHROME_PATH = process.platform === "darwin"
-    ? "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
-    : process.platform === "win32"
-        ? "C:\\Program Files\\Google Chrome\\Application\\chrome.exe"
-        : "/usr/bin/google-chrome-stable";
-let activeBrowser = null;
-let stopSignal = false;
-/** Path to the temp frame file that FFmpeg reads */
-export const FRAME_FILE = join(tmpdir(), "eliza-stream-frame.jpg");
-/**
- * Ensure the URL includes the `?popout` parameter so the app renders only
- * StreamView, skipping startup gates and navigation chrome.
- */
-function ensurePopoutUrl(raw) {
-    try {
-        const u = new URL(raw);
-        // Handle both query and hash-based routing
-        if (u.hash?.includes("?")) {
-            if (!u.hash.includes("popout")) {
-                u.hash = `${u.hash}&popout`;
-            }
-        }
-        else if (u.hash) {
-            u.hash = `${u.hash}?popout`;
-        }
-        else if (!u.searchParams.has("popout")) {
-            u.searchParams.set("popout", "");
-        }
-        return u.toString();
-    }
-    catch {
-        // Fallback: just append
-        const sep = raw.includes("?") ? "&" : "?";
-        return `${raw}${sep}popout`;
-    }
-}
-export async function startBrowserCapture(config) {
-    if (activeBrowser) {
-        console.log("[browser-capture] Already running");
-        return;
-    }
-    const { url, width = 1280, height = 720, quality = 70 } = config;
-    const captureUrl = ensurePopoutUrl(url);
-    stopSignal = false;
-    console.log(`[browser-capture] Launching headless Chrome → ${captureUrl}`);
-    const browser = await puppeteer.launch({
-        executablePath: CHROME_PATH,
-        headless: true,
-        args: [
-            `--window-size=${width},${height}`,
-            "--no-sandbox",
-            "--disable-dev-shm-usage",
-            "--disable-extensions",
-            "--mute-audio",
-            // WebGL / SwiftShader — required for VRM avatar rendering parity
-            "--use-gl=swiftshader",
-            "--enable-webgl",
-            "--ignore-gpu-blocklist",
-        ],
-    });
-    activeBrowser = browser;
-    const page = await browser.newPage();
-    await page.setViewport({ width, height, deviceScaleFactor: 1 });
-    // Seed localStorage before navigation so the first render matches the desktop shell.
-    // Keys must match exactly what the React app reads:
-    //   - "eliza:theme"                        → ThemeName
-    //   - "eliza_avatar_index"                 → VRM index (1–8)
-    //   - "eliza.stream.overlay-layout.v1[.destId]" → OverlayLayout JSON
-    await page.evaluateOnNewDocument((overlayLayout, theme, avatarIndex, destinationId) => {
-        if (overlayLayout) {
-            // Seed both global and destination-specific keys so the hook
-            // resolves correctly regardless of when activeDestination loads.
-            localStorage.setItem("eliza.stream.overlay-layout.v1", overlayLayout);
-            if (destinationId) {
-                localStorage.setItem(`eliza.stream.overlay-layout.v1.${destinationId}`, overlayLayout);
-            }
-        }
-        if (theme) {
-            localStorage.setItem("eliza:theme", theme);
-        }
-        if (avatarIndex != null) {
-            localStorage.setItem("eliza_avatar_index", String(avatarIndex));
-        }
-    }, config.overlayLayout, config.theme, config.avatarIndex, config.destinationId);
-    // Use networkidle0 so fonts, VRM models, and preview images finish loading
-    await page.goto(captureUrl, {
-        waitUntil: "networkidle0",
-        timeout: 60_000,
-    });
-    console.log(`[browser-capture] Page loaded, writing frames to ${FRAME_FILE}`);
-    // Use CDP screencast for efficient frame delivery
-    const cdp = await page.createCDPSession();
-    let frameCount = 0;
-    cdp.on("Page.screencastFrame", async (params) => {
-        if (stopSignal)
-            return;
-        try {
-            const buf = Buffer.from(params.data, "base64");
-            if (buf.length > 0) {
-                writeFileSync(FRAME_FILE, buf);
-                frameCount++;
-                if (frameCount % 100 === 0) {
-                    console.log(`[browser-capture] ${frameCount} frames written`);
-                }
-            }
-            await cdp.send("Page.screencastFrameAck", {
-                sessionId: params.sessionId,
-            });
-        }
-        catch {
-            // Ignore
-        }
-    });
-    // Capture every frame from Chrome's compositor (~60fps internally,
-    // limited by everyNthFrame to ~15-30fps actual delivery)
-    await cdp.send("Page.startScreencast", {
-        format: "jpeg",
-        quality,
-        maxWidth: width,
-        maxHeight: height,
-        everyNthFrame: 2, // ~30fps from 60fps compositor
-    });
-    console.log(`[browser-capture] CDP screencast active, saving to ${FRAME_FILE}`);
-}
-export async function stopBrowserCapture() {
-    stopSignal = true;
-    if (activeBrowser) {
-        try {
-            await activeBrowser.close();
-        }
-        catch { }
-        activeBrowser = null;
-    }
-    console.log("[browser-capture] Stopped");
-}
-export function isBrowserCaptureRunning() {
-    return activeBrowser !== null;
-}
-export function hasFrameFile() {
-    return existsSync(FRAME_FILE);
-}