@minionry/minion 0.7.36

package/electron-host/dist/main.js

@@ -0,0 +1,716 @@
+import { readFileSync } from "node:fs";
+import { Socket } from "node:net";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { app, BrowserWindow, webContents as electronWebContents, ipcMain, session, } from "electron";
+import { AgentLeaseRegistry, } from "./agent-lease.js";
+import { ControllerChannel } from "./controller-channel.js";
+import { DeviceEmulator, } from "./device-emulator.js";
+import { DomDriver, } from "./dom-driver.js";
+import { registerDomainMethods } from "./domain-registry.js";
+import { EditableFocusReporter, } from "./editable-focus-reporter.js";
+import { hostLog } from "./host-log.js";
+import { AGENT_SESSION_ID, } from "./host-wire.js";
+import { InputRouter, } from "./input-router.js";
+import { IpcServer, } from "./ipc-server.js";
+import { JsDriver, } from "./js-driver.js";
+import { isConnectionStatePayload, isLocalIcePayload, isOfferPayload, } from "./main-guards.js";
+import { materialiseRosterOnSurface, propagateHumanNavigation, } from "./roster-sync.js";
+import { registerTabMethods } from "./rpc-tab-methods.js";
+import { registerWebrtcMethods } from "./rpc-webrtc-methods.js";
+import { SdkInjector, } from "./sdk-injector.js";
+import { lowestFreeSlot, makeSurfaceWindowAndViewManager, resolveArmedCapture, surfaceOrigin, surfaceTabWebContents, } from "./session-surface.js";
+import { applyDeviceProfileToTab, } from "./surface-sizing.js";
+import { CH_ARM_DISPLAY_MEDIA, CH_CLOSE_SESSION, CH_CONNECTION_STATE, CH_ERROR, CH_EVICT_SESSION_CAPTURE, CH_LOCAL_ICE, CH_LOCAL_OFFER, CH_REFRESH_CAPTURE, } from "./webrtc-channels.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const log = hostLog("main");
+const hlog = log;
+const hinfo = log.info;
+let root = null;
+let disposeDomainMethods = null;
+let pendingArm = null;
+let inputRouterTarget = null;
+const unroutedInputSessions = new Set();
+function sessionSurfaceForInput(r, sessionId) {
+    const surface = r.surfaces.get(sessionId);
+    if (surface)
+        return surface;
+    if (!unroutedInputSessions.has(sessionId)) {
+        if (unroutedInputSessions.size >= 256)
+            unroutedInputSessions.clear();
+        unroutedInputSessions.add(sessionId);
+        hinfo("input.noSurface", `session=${sessionId.slice(0, 8)} surfaces=${r.surfaces.size} — falling back to the agent surface`);
+    }
+    return null;
+}
+function agentSurfaceOrNull(r) {
+    if (!r)
+        return null;
+    return r.surfaces.get(r.agentSessionId) ?? null;
+}
+function agentSurface(r) {
+    const s = r.surfaces.get(r.agentSessionId);
+    if (!s)
+        throw new Error("agent surface missing — bootstrap did not run");
+    return s;
+}
+function agentViewManager(r) {
+    return agentSurfaceOrNull(r)?.viewManager ?? null;
+}
+function getOrCreateSurface(r, sessionId) {
+    const existing = r.surfaces.get(sessionId);
+    if (existing)
+        return existing;
+    const isAgent = sessionId === r.agentSessionId;
+    const gridSlot = lowestFreeSlot(r.surfaces.values());
+    const { window, viewManager } = makeSurfaceWindowAndViewManager(surfaceOrigin(gridSlot));
+    const surface = {
+        sessionId,
+        window,
+        viewManager,
+        armedTabId: null,
+        isAgent,
+        expectedUrls: new Map(),
+        gridSlot,
+        focusReporters: new Map(),
+    };
+    r.surfaces.set(sessionId, surface);
+    wireSurfaceEvents(r, surface);
+    if (!isAgent) {
+        materialiseRosterOnSurface(r.roster, surface);
+        window.on("closed", () => {
+            if (r.shuttingDown || surface.isAgent)
+                return;
+            hlog("surface.windowClosed", `session=${sessionId.slice(0, 8)}`);
+            teardownSurface(r, sessionId);
+        });
+    }
+    hinfo("surface.create", `session=${sessionId.slice(0, 8)} isAgent=${isAgent} slot=${gridSlot} surfaces=${r.surfaces.size}`);
+    return surface;
+}
+function refreshSurfaceCapture(r, surface, tabId) {
+    r.controllerChannel.send(CH_REFRESH_CAPTURE, {
+        sessionId: surface.sessionId,
+        tabId,
+    });
+}
+function attachFocusReporter(r, surface, tabId) {
+    if (surface.isAgent)
+        return;
+    if (surface.focusReporters.has(tabId))
+        return;
+    const wc = surfaceTabWebContents(surface, tabId);
+    const dbg = wc?.debugger;
+    if (!wc || !dbg)
+        return;
+    const sessionId = surface.sessionId;
+    const reporter = new EditableFocusReporter({
+        debugger: dbg,
+        onFocusChange: (focused) => {
+            void r.ipcServer.notify("browser.inputFocus", { sessionId, tabId, focused });
+            hlog("inputFocus", `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)} focused=${focused}`);
+        },
+    });
+    surface.focusReporters.set(tabId, reporter);
+    reporter.start();
+}
+function disposeFocusReporter(surface, tabId) {
+    const reporter = surface.focusReporters.get(tabId);
+    if (!reporter)
+        return;
+    reporter.dispose();
+    surface.focusReporters.delete(tabId);
+}
+function loadSdkStubSource(stubPath) {
+    if (!stubPath)
+        return null;
+    try {
+        const source = readFileSync(stubPath, "utf8");
+        hlog("sdk.stubLoaded", `path=${stubPath} bytes=${source.length}`);
+        return source;
+    }
+    catch (err) {
+        console.warn(`[electron-host] SDK injection disabled — failed to read stub at ${stubPath}: ${String(err)}`);
+        return null;
+    }
+}
+function attachSdkInjector(r, surface, tabId) {
+    if (!r.sdkStubSource)
+        return;
+    const wc = surfaceTabWebContents(surface, tabId);
+    const dbg = wc?.debugger;
+    if (!wc || !dbg)
+        return;
+    const pageId = wc.id;
+    if (r.sdkInjectors.has(pageId))
+        return;
+    const sessionId = surface.sessionId;
+    const injector = new SdkInjector({
+        debugger: dbg,
+        stubSource: r.sdkStubSource,
+        onRequest: (request) => {
+            void r.ipcServer.notify("sdk.request", {
+                pageId,
+                tabId,
+                sessionId,
+                origin: request.origin,
+                payload: request.payload,
+            });
+            hlog("sdk.request", `page=${pageId} tab=${tabId.slice(0, 8)} origin=${request.origin}`);
+        },
+    });
+    r.sdkInjectors.set(pageId, injector);
+    injector.start();
+}
+function disposeSdkInjector(r, wcId) {
+    const injector = r.sdkInjectors.get(wcId);
+    if (!injector)
+        return;
+    injector.dispose();
+    r.sdkInjectors.delete(wcId);
+}
+function grantDisplayMedia(pending) {
+    const resolved = root ? resolveArmedCapture(root.surfaces, root.agentSessionId, pending) : null;
+    if (!resolved) {
+        hinfo("getDisplayMedia.deny", `reason=no_tab_armed pendingSession=${pending?.sessionId.slice(0, 8) ?? "-"} pendingTab=${pending?.tabId.slice(0, 8) ?? "-"} surfaceKnown=${pending ? root?.surfaces.has(pending.sessionId) === true : "-"}`);
+        return {};
+    }
+    const { surface, armed } = resolved;
+    const armSource = pending ? "pending" : "surface";
+    const wcId = surface.viewManager.getCaptureSourceId(armed);
+    const frame = (wcId === null ? null : electronWebContents.fromId(wcId))?.mainFrame ?? null;
+    if (!frame) {
+        hinfo("getDisplayMedia.deny", `session=${surface.sessionId.slice(0, 8)} armed=${armed.slice(0, 8)} reason=no_frame source=${armSource} tabOnSurface=${wcId !== null}`);
+        return {};
+    }
+    hlog("getDisplayMedia.grant", `armed=${armed.slice(0, 8)} wcId=${wcId} session=${surface.sessionId.slice(0, 8)} source=${armSource}`);
+    return { video: frame, audio: frame, enableLocalEcho: false };
+}
+async function bootstrap() {
+    await app.whenReady();
+    if (process.platform === "darwin") {
+        app.setActivationPolicy("accessory");
+        app.dock?.hide();
+    }
+    const inputRouter = new InputRouter({
+        views: {
+            getActiveView: () => {
+                const vm = inputRouterTarget?.viewManager ?? agentViewManager(root);
+                if (!vm)
+                    return null;
+                const activeId = vm.getActiveTabId();
+                if (!activeId)
+                    return null;
+                return resolveInputCapableView(vm, activeId);
+            },
+            getViewByTabId: (tabId) => {
+                const vm = inputRouterTarget?.viewManager ?? agentViewManager(root);
+                if (!vm)
+                    return null;
+                return resolveInputCapableView(vm, tabId);
+            },
+        },
+    });
+    const controllerWindow = new BrowserWindow({
+        show: false,
+        width: 1,
+        height: 1,
+        skipTaskbar: true,
+        webPreferences: {
+            nodeIntegration: true,
+            contextIsolation: false,
+            sandbox: false,
+            preload: join(HERE, "..", "webrtc-controller-preload.cjs"),
+        },
+    });
+    const controllerChannel = new ControllerChannel({
+        transport: {
+            send: (channel, payload) => controllerWindow.webContents.send(channel, payload),
+            isDestroyed: () => controllerWindow.isDestroyed(),
+        },
+        log: hinfo,
+    });
+    controllerWindow.webContents.session.setDisplayMediaRequestHandler((_request, callback) => {
+        const pending = pendingArm;
+        pendingArm = null;
+        callback(grantDisplayMedia(pending));
+    });
+    ipcMain.handle(CH_ARM_DISPLAY_MEDIA, (_evt, payload) => {
+        if (!root)
+            return false;
+        if (!payload || typeof payload !== "object")
+            return false;
+        const tabId = payload.tabId;
+        if (typeof tabId !== "string" || tabId.length === 0)
+            return false;
+        const rawSession = payload.sessionId;
+        const sessionId = typeof rawSession === "string" && rawSession.length > 0
+            ? rawSession
+            : root.agentSessionId;
+        pendingArm = { sessionId, tabId };
+        const surface = root.surfaces.get(sessionId);
+        if (surface)
+            surface.armedTabId = tabId;
+        hlog("arm-display-media", `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)}`);
+        return true;
+    });
+    const ipcServer = new IpcServer({
+        transport: makeFdTransport(),
+        onError: (err) => {
+            console.error("[electron-host] ipc-server error:", err);
+        },
+        onDisconnect: () => {
+            console.error("[electron-host] parent disconnected, quitting");
+            void shutdown("parent_disconnect").then(() => {
+                app.quit();
+            });
+        },
+    });
+    const leaseRegistry = new AgentLeaseRegistry();
+    leaseRegistry.gcLoop();
+    const domDriver = new DomDriver({
+        tabs: {
+            getWebContents: (tabId) => {
+                const vm = agentViewManager(root);
+                const wcId = vm?.getCaptureSourceId(tabId) ?? null;
+                if (wcId === null)
+                    return null;
+                const wc = electronWebContents.fromId(wcId);
+                if (!wc)
+                    return null;
+                return wc;
+            },
+        },
+        leases: {
+            extendLease: (tabId, agentId, untilMs) => {
+                const ttl = Math.max(0, untilMs - Date.now());
+                const r = leaseRegistry.heartbeat({
+                    agentId,
+                    tabIds: [tabId],
+                    ttlMs: ttl,
+                });
+                return r.stillLeased.includes(tabId) ? untilMs : null;
+            },
+        },
+    });
+    const jsDriver = new JsDriver({
+        resolveTab: (tabId) => {
+            const vm = agentViewManager(root);
+            const wcId = vm?.getCaptureSourceId(tabId) ?? null;
+            if (wcId === null)
+                return null;
+            const wc = electronWebContents.fromId(wcId);
+            if (!wc)
+                return null;
+            return wc;
+        },
+    });
+    const deviceEmulator = new DeviceEmulator();
+    const tabProfiles = new Map();
+    const surfaces = new Map();
+    root = {
+        controllerWindow,
+        controllerChannel,
+        inputRouter,
+        ipcServer,
+        leaseRegistry,
+        domDriver,
+        jsDriver,
+        deviceEmulator,
+        surfaces,
+        agentSessionId: AGENT_SESSION_ID,
+        tabProfiles,
+        sizing: { tabProfiles, deviceEmulator, log: hlog },
+        roster: {
+            surfaces,
+            agentSessionId: AGENT_SESSION_ID,
+            notifyNavigated: (event) => {
+                void ipcServer.notify("tab.navigated", event);
+            },
+            log: hlog,
+            info: hinfo,
+        },
+        viewers: new Map(),
+        sdkInjectors: new Map(),
+        sdkStubSource: loadSdkStubSource(process.env.MINIONRY_SDK_STUB_PATH),
+        shuttingDown: false,
+    };
+    getOrCreateSurface(root, AGENT_SESSION_ID);
+    registerHostMethods(rpcContext(root));
+    disposeDomainMethods = registerDomainMethods({
+        ipcServer,
+        leaseRegistry,
+        domDriver,
+        jsDriver,
+    });
+    wireControllerIpc(root);
+    ipcServer.start();
+    hlog("ipcServer.started");
+    void ipcServer.notify("host.hello", { version: "1.0" });
+    hinfo("host.hello", `sent pid=${process.pid}`);
+    void (async () => {
+        try {
+            hlog("controllerWindow.loadFile", "starting");
+            await controllerWindow.loadFile(join(HERE, "..", "webrtc-controller.html"));
+            hinfo("controllerWindow.loaded", `queued=${controllerChannel.pendingCount}`);
+            controllerChannel.markReady();
+            wireControllerCrashFence(root);
+            void ipcServer.notify("host.capture_ready", { version: "1.0" });
+            hinfo("host.capture_ready", "sent");
+        }
+        catch (err) {
+            if (root?.shuttingDown)
+                return;
+            console.error("[electron-host] controller renderer load failed:", err);
+            controllerChannel.markNotReady();
+            void ipcServer
+                .notify("status.change", {
+                state: "controller_crashed",
+                reason: `controller_load_failed: ${err instanceof Error ? err.message : String(err)}`,
+            })
+                .catch(() => undefined)
+                .finally(() => {
+                process.exit(2);
+            });
+        }
+    })();
+    void ipcServer.notify("status.change", { state: "ready" });
+    console.log("electron-host-ready");
+}
+function rpcContext(r) {
+    return {
+        ipcServer: r.ipcServer,
+        controllerChannel: r.controllerChannel,
+        inputRouter: r.inputRouter,
+        surfaces: r.surfaces,
+        agentSessionId: r.agentSessionId,
+        viewers: r.viewers,
+        tabProfiles: r.tabProfiles,
+        sizing: r.sizing,
+        roster: r.roster,
+        sdkInjectors: r.sdkInjectors,
+        agentSurface: () => agentSurface(r),
+        getOrCreateSurface: (sessionId) => getOrCreateSurface(r, sessionId),
+        teardownSurface: (sessionId) => teardownSurface(r, sessionId),
+        attachFocusReporter: (surface, tabId) => attachFocusReporter(r, surface, tabId),
+        refreshCapture: (surface, tabId) => refreshSurfaceCapture(r, surface, tabId),
+        withInputTarget: (sessionId, dispatch) => {
+            inputRouterTarget = (sessionId ? sessionSurfaceForInput(r, sessionId) : null) ?? agentSurfaceOrNull(r);
+            try {
+                dispatch();
+            }
+            finally {
+                inputRouterTarget = null;
+            }
+        },
+        requestShutdown: () => {
+            void shutdown("rpc").then(() => app.quit());
+        },
+        log: hlog,
+        info: hinfo,
+    };
+}
+function registerHostMethods(ctx) {
+    registerTabMethods(ctx);
+    registerWebrtcMethods(ctx);
+}
+export { AGENT_SESSION_ID } from "./host-wire.js";
+export { hostWindowOptions } from "./session-surface.js";
+export { registerDomainMethods };
+const REFRESH_DEBOUNCE_MS = 75;
+const _SETBOUNDS_REFRESH_DEBOUNCE_MS = 150;
+function wireSurfaceEvents(r, surface) {
+    const { ipcServer, controllerWindow, controllerChannel, inputRouter, domDriver, jsDriver } = r;
+    const { viewManager } = surface;
+    const isAgent = surface.isAgent;
+    const tabWebContentsIds = new Map();
+    const refreshTimers = new Map();
+    const scheduleCaptureRefresh = (tabId, delayMs) => {
+        if (controllerWindow.isDestroyed())
+            return;
+        const existing = refreshTimers.get(tabId);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            refreshTimers.delete(tabId);
+            if (controllerWindow.isDestroyed())
+                return;
+            controllerChannel.send(CH_REFRESH_CAPTURE, {
+                sessionId: surface.sessionId,
+                tabId,
+            });
+            hlog("navTiming.refreshCapture", `session=${surface.sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)} delay=${delayMs} t=${Date.now()}`);
+        }, delayMs);
+        refreshTimers.set(tabId, timer);
+    };
+    viewManager.on("tab-created", (e) => {
+        tabWebContentsIds.set(e.tabId, e.webContentsId);
+        if (isAgent) {
+            void ipcServer.notify("tab.created", {
+                id: e.tabId,
+                url: e.url,
+                webContentsId: e.webContentsId,
+            });
+        }
+        else {
+            applyDeviceProfileToTab(r.sizing, surface, e.tabId);
+            attachFocusReporter(r, surface, e.tabId);
+        }
+        attachSdkInjector(r, surface, e.tabId);
+    });
+    viewManager.on("tab-closed", (e) => {
+        if (surface.armedTabId === e.tabId)
+            surface.armedTabId = null;
+        if (isAgent) {
+            domDriver.disposeTab(e.tabId);
+            jsDriver.invalidate(e.tabId);
+            r.tabProfiles.delete(e.tabId);
+            void ipcServer.notify("tab.closed", { id: e.tabId });
+        }
+        disposeFocusReporter(surface, e.tabId);
+        const wcId = tabWebContentsIds.get(e.tabId);
+        if (wcId !== undefined) {
+            inputRouter.releaseTab(wcId);
+            r.deviceEmulator.releaseTab(wcId);
+            disposeSdkInjector(r, wcId);
+            tabWebContentsIds.delete(e.tabId);
+        }
+    });
+    viewManager.on("tab-navigated", (e) => {
+        if (!e.inPage &&
+            surface.armedTabId === e.tabId &&
+            e.url !== "about:blank" &&
+            e.url !== "") {
+            hlog("navTiming.commit", `session=${surface.sessionId.slice(0, 8)} tab=${e.tabId.slice(0, 8)} t=${Date.now()}`);
+            scheduleCaptureRefresh(e.tabId, 0);
+        }
+        if (isAgent) {
+            void ipcServer.notify("tab.navigated", e);
+        }
+        else {
+            propagateHumanNavigation(r.roster, surface, e.tabId, e.url, e.inPage, e.canGoBack, e.canGoForward);
+        }
+    });
+    viewManager.on("tab-loaded", (e) => {
+        if (!isAgent)
+            applyDeviceProfileToTab(r.sizing, surface, e.tabId);
+        if (!surface.armedTabId || surface.armedTabId !== e.tabId)
+            return;
+        if (e.url === "about:blank" || e.url === "")
+            return;
+        if (controllerWindow.isDestroyed())
+            return;
+        hlog("navTiming.tabLoaded", `session=${surface.sessionId.slice(0, 8)} tab=${e.tabId.slice(0, 8)} t=${Date.now()}`);
+        scheduleCaptureRefresh(e.tabId, REFRESH_DEBOUNCE_MS);
+    });
+    if (isAgent) {
+        viewManager.on("tab-crashed", (e) => {
+            void ipcServer.notify("tab.crashed", e);
+        });
+        viewManager.on("tab-title-changed", (e) => {
+            void ipcServer.notify("tab.titleChanged", e);
+        });
+        viewManager.on("tab-load-failed", (e) => {
+            void ipcServer.notify("tab.failed", e);
+        });
+    }
+}
+function teardownSurface(r, sessionId) {
+    if (sessionId === r.agentSessionId)
+        return;
+    const surface = r.surfaces.get(sessionId);
+    if (!surface)
+        return;
+    r.surfaces.delete(sessionId);
+    if (surface.pendingCaptureRefresh) {
+        clearTimeout(surface.pendingCaptureRefresh);
+        surface.pendingCaptureRefresh = undefined;
+    }
+    hinfo("surface.teardown", `session=${sessionId.slice(0, 8)} surfaces=${r.surfaces.size}`);
+    r.controllerChannel.send(CH_EVICT_SESSION_CAPTURE, { sessionId });
+    for (const reporter of surface.focusReporters.values())
+        reporter.dispose();
+    surface.focusReporters.clear();
+    try {
+        surface.viewManager.disposeAll();
+    }
+    catch (err) {
+        hlog("surface.teardown.disposeAllFailed", String(err));
+    }
+    try {
+        if (!surface.window.isDestroyed())
+            surface.window.destroy();
+    }
+    catch {
+    }
+}
+function wireControllerIpc(r) {
+    const { ipcServer, controllerWindow } = r;
+    const fromController = (channel, handler) => {
+        ipcMain.on(channel, (event, payload) => {
+            if (controllerWindow.isDestroyed())
+                return;
+            if (event.sender.id !== controllerWindow.webContents.id)
+                return;
+            handler(payload);
+        });
+    };
+    fromController(CH_LOCAL_OFFER, (payload) => {
+        if (!isOfferPayload(payload))
+            return;
+        hinfo("controller.offer", `session=${payload.sessionId.slice(0, 8)} sdpLen=${payload.sdp.length}`);
+        void ipcServer.notify("webrtc.offer", payload);
+    });
+    fromController(CH_LOCAL_ICE, (payload) => {
+        if (!isLocalIcePayload(payload))
+            return;
+        hlog("controller.ice", `session=${payload.sessionId.slice(0, 8)} eoc=${payload.candidate === null}`);
+        void ipcServer.notify("webrtc.ice", {
+            sessionId: payload.sessionId,
+            candidate: payload.candidate,
+        });
+    });
+    fromController(CH_CONNECTION_STATE, (payload) => {
+        if (!isConnectionStatePayload(payload))
+            return;
+        hinfo("controller.state", `session=${payload.sessionId.slice(0, 8)} state=${payload.state} reason=${payload.reason ?? '-'}`);
+        void ipcServer.notify("webrtc.state", payload);
+    });
+    fromController(CH_ERROR, (payload) => {
+        hinfo("controller.error", JSON.stringify(payload));
+        if (!payload || typeof payload !== "object")
+            return;
+        const message = payload.message;
+        void ipcServer.notify("status.change", {
+            state: "ready",
+            reason: typeof message === "string" ? `controller_error: ${message}` : "controller_error",
+        });
+    });
+}
+function wireControllerCrashFence(r) {
+    const { controllerWindow, ipcServer } = r;
+    controllerWindow.webContents.on("render-process-gone", (_e, details) => {
+        if (r.shuttingDown)
+            return;
+        r.controllerChannel.markNotReady();
+        console.error("[electron-host] controller renderer gone:", details.reason, details.exitCode);
+        void ipcServer
+            .notify("status.change", {
+            state: "controller_crashed",
+            reason: details.reason,
+        })
+            .catch(() => undefined)
+            .finally(() => {
+            process.exit(2);
+        });
+    });
+    controllerWindow.on("closed", () => {
+        if (r.shuttingDown)
+            return;
+        console.error("[electron-host] controller window closed unexpectedly");
+        process.exit(2);
+    });
+}
+function disposeSurfaces(r) {
+    const agentId = r.agentSessionId;
+    const orderedSurfaces = [
+        ...[...r.surfaces.values()].filter((s) => !s.isAgent),
+        ...[...r.surfaces.values()].filter((s) => s.isAgent),
+    ];
+    for (const surface of orderedSurfaces) {
+        for (const reporter of surface.focusReporters.values())
+            reporter.dispose();
+        surface.focusReporters.clear();
+        try {
+            surface.viewManager.disposeAll();
+        }
+        catch (err) {
+            console.error("[electron-host] viewManager.disposeAll failed:", err);
+        }
+        try {
+            if (!surface.window.isDestroyed())
+                surface.window.destroy();
+        }
+        catch {
+        }
+    }
+    r.surfaces.clear();
+    void agentId;
+}
+async function shutdown(reason) {
+    if (!root || root.shuttingDown)
+        return;
+    root.shuttingDown = true;
+    console.error("[electron-host] shutting down:", reason);
+    root.controllerChannel.send(CH_CLOSE_SESSION, {});
+    root.controllerChannel.clear();
+    disposeSurfaces(root);
+    root.leaseRegistry.stopGc();
+    disposeDomainMethods?.();
+    disposeDomainMethods = null;
+    try {
+        if (!root.controllerWindow.isDestroyed())
+            root.controllerWindow.destroy();
+    }
+    catch {
+    }
+    try {
+        await root.ipcServer.notify("status.change", { state: "stopping", reason });
+    }
+    catch {
+    }
+    try {
+        await root.ipcServer.stop();
+    }
+    catch (err) {
+        console.error("[electron-host] ipcServer.stop failed:", err);
+    }
+}
+function startElectronHost() {
+    if (process.platform === "darwin") {
+        app.on("will-finish-launching", () => {
+            app.setActivationPolicy("prohibited");
+        });
+    }
+    app.on("before-quit", (event) => {
+        if (!root || root.shuttingDown)
+            return;
+        event.preventDefault();
+        void shutdown("before_quit").then(() => app.quit());
+    });
+    app.on("window-all-closed", () => {
+        if (root?.shuttingDown) {
+            app.quit();
+        }
+    });
+    bootstrap().catch((err) => {
+        console.error("electron-host-bootstrap-failed", err);
+        process.exit(1);
+    });
+}
+if (process.argv.includes("--minionry-host")) {
+    startElectronHost();
+    process.on("uncaughtException", (err) => {
+        console.error("[electron-host] uncaughtException:", err);
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (err) => {
+        console.error("[electron-host] unhandledRejection:", err);
+        process.exit(1);
+    });
+}
+function makeFdTransport() {
+    const readable = new Socket({ fd: 3, readable: true, writable: false });
+    const writable = new Socket({ fd: 4, readable: false, writable: true });
+    return { readable, writable };
+}
+function resolveInputCapableView(viewManager, tabId) {
+    const wcId = viewManager.getCaptureSourceId(tabId);
+    if (wcId === null)
+        return null;
+    const wc = electronWebContents.fromId(wcId);
+    if (!wc)
+        return null;
+    return { webContents: wc };
+}
+void session;