@minionry/minion 0.7.36

package/electron-host/dist/sdp.js

@@ -0,0 +1,102 @@
+const MEDIA_LINE_RE = /^m=(\S+)\s+(\d+)\s+(\S+)\s+(.+)$/;
+const RTPMAP_H264_RE = /^a=rtpmap:(\d+)\s+H264\//i;
+const RTPMAP_RTX_RE = /^a=rtpmap:(\d+)\s+rtx\//i;
+const FMTP_LINE_RE = /^a=fmtp:(\d+)\s+(.+)$/;
+const FMTP_APT_RE = /(?:^|;)\s*apt=(\d+)/;
+export function reorderH264First(sdp) {
+    if (!sdp)
+        return sdp;
+    const useCrlf = sdp.includes('\r\n');
+    const sep = useCrlf ? '\r\n' : '\n';
+    const lines = sdp.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? '';
+        const m = MEDIA_LINE_RE.exec(line);
+        if (!m || m[1] !== 'video') {
+            i++;
+            continue;
+        }
+        let end = lines.length;
+        for (let j = i + 1; j < lines.length; j++) {
+            if ((lines[j] ?? '').startsWith('m=')) {
+                end = j;
+                break;
+            }
+        }
+        const reordered = reorderVideoSection(lines.slice(i, end), m);
+        for (let j = 0; j < reordered.length; j++) {
+            lines[i + j] = reordered[j];
+        }
+        i = end;
+    }
+    return lines.join(sep);
+}
+function reorderVideoSection(sectionLines, mediaMatch) {
+    const mediaLine = sectionLines[0] ?? '';
+    const ptList = mediaMatch[4].split(/\s+/).filter((s) => s.length > 0);
+    const pts = collectVideoPts(sectionLines);
+    if (pts.h264Pts.size === 0) {
+        return sectionLines.slice();
+    }
+    const newPtList = orderH264First(ptList, pts);
+    const prefix = mediaLine.slice(0, mediaLine.indexOf(mediaMatch[4]));
+    const out = sectionLines.slice();
+    out[0] = `${prefix}${newPtList.join(' ')}`;
+    return out;
+}
+function collectVideoPts(sectionLines) {
+    const h264Pts = new Set();
+    const rtxPts = new Set();
+    const rtxApt = new Map();
+    for (let j = 1; j < sectionLines.length; j++) {
+        const l = sectionLines[j] ?? '';
+        const h = RTPMAP_H264_RE.exec(l);
+        if (h) {
+            h264Pts.add(h[1]);
+            continue;
+        }
+        const r = RTPMAP_RTX_RE.exec(l);
+        if (r) {
+            rtxPts.add(r[1]);
+            continue;
+        }
+        const f = FMTP_LINE_RE.exec(l);
+        if (f) {
+            const apt = FMTP_APT_RE.exec(f[2]);
+            if (apt)
+                rtxApt.set(f[1], apt[1]);
+        }
+    }
+    return { h264Pts, rtxPts, rtxApt };
+}
+function orderH264First(ptList, pts) {
+    const consumed = new Set();
+    const h264Group = [];
+    for (const pt of ptList) {
+        if (!pts.h264Pts.has(pt) || consumed.has(pt))
+            continue;
+        h264Group.push(pt);
+        consumed.add(pt);
+        for (const rtx of pairedRtxFor(ptList, pt, pts, consumed)) {
+            h264Group.push(rtx);
+            consumed.add(rtx);
+        }
+    }
+    const restGroup = [];
+    for (const pt of ptList) {
+        if (!consumed.has(pt))
+            restGroup.push(pt);
+    }
+    return [...h264Group, ...restGroup];
+}
+function pairedRtxFor(ptList, pt, pts, consumed) {
+    const paired = [];
+    for (const other of ptList) {
+        if (consumed.has(other))
+            continue;
+        if (pts.rtxPts.has(other) && pts.rtxApt.get(other) === pt)
+            paired.push(other);
+    }
+    return paired;
+}

package/electron-host/dist/session-surface.js

@@ -0,0 +1,78 @@
+import { BaseWindow, webContents as electronWebContents, WebContentsView } from "electron";
+import { makeWebContentsViewFactory, ViewManager } from "./view-manager.js";
+const SURFACE_TILE_COLS = 3;
+const SURFACE_TILE_W = 1280;
+const SURFACE_TILE_H = 720;
+export function surfaceOrigin(slot, platform = process.platform) {
+    const col = slot % SURFACE_TILE_COLS;
+    const row = Math.floor(slot / SURFACE_TILE_COLS);
+    const dx = col * SURFACE_TILE_W;
+    const dy = row * SURFACE_TILE_H;
+    if (platform === "linux")
+        return { x: dx, y: dy };
+    return { x: -10000 - dx, y: -10000 - dy };
+}
+export function lowestFreeSlot(surfaces) {
+    const used = new Set();
+    for (const surface of surfaces)
+        used.add(surface.gridSlot);
+    let slot = 0;
+    while (used.has(slot))
+        slot += 1;
+    return slot;
+}
+export function makeSurfaceWindowAndViewManager(origin) {
+    const window = new BaseWindow({ ...hostWindowOptions(), x: origin.x, y: origin.y });
+    const viewManager = new ViewManager({
+        hostWindow: window,
+        viewFactory: makeWebContentsViewFactory({
+            WebContentsView,
+            webPreferencesFor: () => ({
+                webPreferences: {
+                    backgroundThrottling: false,
+                    sandbox: true,
+                    contextIsolation: true,
+                    nodeIntegration: false,
+                },
+            }),
+        }),
+    });
+    return { window, viewManager };
+}
+export function hostWindowOptions(platform = process.platform) {
+    const base = { show: true, width: 1280, height: 720 };
+    if (platform === "darwin") {
+        return {
+            ...base,
+            show: false,
+            x: -10000,
+            y: -10000,
+            skipTaskbar: true,
+            type: "utility",
+        };
+    }
+    if (platform === "win32") {
+        return {
+            ...base,
+            x: -10000,
+            y: -10000,
+            skipTaskbar: true,
+        };
+    }
+    return { ...base, width: 1280, height: 720 };
+}
+export function surfaceTabWebContents(surface, tabId) {
+    const wcId = surface.viewManager.getCaptureSourceId(tabId);
+    if (wcId === null)
+        return null;
+    return electronWebContents.fromId(wcId) ?? null;
+}
+export function resolveArmedCapture(surfaces, agentSessionId, pending) {
+    const surface = pending
+        ? (surfaces.get(pending.sessionId) ?? null)
+        : (surfaces.get(agentSessionId) ?? null);
+    const armed = pending?.tabId ?? surface?.armedTabId ?? null;
+    if (!surface || !armed)
+        return null;
+    return { surface, armed };
+}

package/electron-host/dist/surface-sizing.js

@@ -0,0 +1,59 @@
+import { MAX_HOST_DIM, MIN_HOST_DIM } from "./host-wire.js";
+import { surfaceTabWebContents } from "./session-surface.js";
+export function applyDeviceProfileToTab(deps, surface, tabId) {
+    if (surface.isAgent)
+        return;
+    if (surface.window.isDestroyed())
+        return;
+    const wc = surfaceTabWebContents(surface, tabId);
+    if (!wc)
+        return;
+    const profile = deps.tabProfiles.get(tabId);
+    const mobile = profile?.formFactor === "mobile";
+    const mobileDims = mobile && surface.viewerMobile && surface.viewerSize
+        ? surface.viewerSize
+        : { width: profile?.width ?? MIN_HOST_DIM, height: profile?.height ?? MIN_HOST_DIM };
+    deps.deviceEmulator.applyProfile(wc, {
+        mobile,
+        width: mobileDims.width,
+        height: mobileDims.height,
+        deviceScaleFactor: 1,
+    });
+}
+export function applyDeviceProfileToSurface(deps, surface) {
+    if (surface.isAgent)
+        return;
+    const ids = new Set();
+    const active = surface.viewManager.getActiveTabId();
+    if (active)
+        ids.add(active);
+    if (surface.armedTabId)
+        ids.add(surface.armedTabId);
+    for (const id of ids)
+        applyDeviceProfileToTab(deps, surface, id);
+}
+export function effectiveSurfaceSize(deps, surface) {
+    const tabId = surface.armedTabId ?? surface.viewManager.getActiveTabId();
+    const profile = tabId ? deps.tabProfiles.get(tabId) : undefined;
+    if (profile?.formFactor === "mobile") {
+        if (surface.viewerMobile && surface.viewerSize)
+            return surface.viewerSize;
+        return { width: profile.width, height: profile.height };
+    }
+    return surface.viewerSize ?? { width: 1280, height: 720 };
+}
+export function sizeSurfaceForArmedTab(deps, surface) {
+    if (surface.isAgent || surface.window.isDestroyed())
+        return;
+    const { width, height } = effectiveSurfaceSize(deps, surface);
+    const w = Math.max(MIN_HOST_DIM, Math.min(width, MAX_HOST_DIM));
+    const h = Math.max(MIN_HOST_DIM, Math.min(height, MAX_HOST_DIM));
+    try {
+        surface.window.setContentSize(w, h);
+    }
+    catch (err) {
+        deps.log("surface.sizeFailed", `session=${surface.sessionId.slice(0, 8)} ${String(err)}`);
+    }
+    surface.viewManager.setBounds({ x: 0, y: 0, width: w, height: h });
+    applyDeviceProfileToSurface(deps, surface);
+}

package/electron-host/dist/view-manager.js

@@ -0,0 +1,254 @@
+import { EventEmitter } from "node:events";
+const DEFAULT_ACTIVE_BOUNDS = { x: 0, y: 0, width: 1280, height: 720 };
+const DEFAULT_CRASH_WINDOW_MS = 60_000;
+const DEFAULT_MAX_RESTARTS = 3;
+const OFFSCREEN_ORIGIN = { x: -10_000, y: -10_000 };
+export class ViewManager extends EventEmitter {
+    host;
+    defaultFactory;
+    factories = new Map();
+    idGenerator;
+    tabs = new Map();
+    activeTabId = null;
+    activeBounds;
+    crashWindowMs;
+    maxRestarts;
+    constructor(options) {
+        super();
+        this.host = options.hostWindow;
+        this.defaultFactory = options.viewFactory;
+        this.idGenerator = options.idGenerator ?? (() => randomTabId());
+        this.activeBounds = options.activeBounds ?? DEFAULT_ACTIVE_BOUNDS;
+        this.crashWindowMs = options.crashWindowMs ?? DEFAULT_CRASH_WINDOW_MS;
+        this.maxRestarts = options.maxRestarts ?? DEFAULT_MAX_RESTARTS;
+    }
+    registerViewFactory(kind, factory) {
+        this.factories.set(kind, factory);
+    }
+    createTab(url, options) {
+        const tabId = options?.tabId ?? this.idGenerator();
+        const factory = options?.kind ? this.factories.get(options.kind) : this.defaultFactory;
+        if (!factory) {
+            throw new Error(`ViewManager.createTab: unknown view kind "${options?.kind}"`);
+        }
+        const view = factory({ tabId, url });
+        const tab = {
+            id: tabId,
+            view,
+            url,
+            title: "",
+            isCrashed: false,
+            crashTimestamps: [],
+            detach: () => { },
+        };
+        tab.detach = this.bindWebContentsListeners(tab);
+        this.tabs.set(tabId, tab);
+        this.host.contentView.addChildView(view);
+        view.setBounds(this.offscreenBounds());
+        view.webContents.setBackgroundThrottling(false);
+        view.webContents.loadURL(url).catch(() => {
+        });
+        this.emit("tab-created", {
+            tabId,
+            url,
+            webContentsId: view.webContents.id,
+        });
+        const shouldActivate = options?.makeActive ?? this.activeTabId === null;
+        if (shouldActivate) {
+            this.setActiveTab(tabId);
+        }
+        return tabId;
+    }
+    closeTab(tabId) {
+        const tab = this.tabs.get(tabId);
+        if (!tab)
+            return;
+        tab.detach();
+        try {
+            this.host.contentView.removeChildView(tab.view);
+        }
+        catch {
+        }
+        try {
+            tab.view.webContents.close();
+        }
+        catch {
+        }
+        this.tabs.delete(tabId);
+        if (this.activeTabId === tabId) {
+            this.activeTabId = null;
+            const fallback = this.tabs.keys().next().value;
+            if (fallback)
+                this.setActiveTab(fallback);
+        }
+        this.emit("tab-closed", { tabId });
+    }
+    setActiveTab(tabId) {
+        const next = this.tabs.get(tabId);
+        if (!next) {
+            throw new Error(`ViewManager.setActiveTab: unknown tabId "${tabId}"`);
+        }
+        if (this.activeTabId === tabId)
+            return;
+        const offscreen = this.offscreenBounds();
+        for (const [id, tab] of this.tabs) {
+            if (id === tabId)
+                continue;
+            tab.view.setBounds(offscreen);
+        }
+        next.view.setBounds(this.activeBounds);
+        this.host.contentView.addChildView(next.view);
+        this.activeTabId = tabId;
+    }
+    navigate(tabId, url) {
+        const tab = this.tabs.get(tabId);
+        if (!tab) {
+            throw new Error(`ViewManager.navigate: unknown tabId "${tabId}"`);
+        }
+        tab.url = url;
+        tab.crashTimestamps = [];
+        tab.view.webContents.loadURL(url).catch(() => {
+        });
+    }
+    setBounds(rect) {
+        this.activeBounds = rect;
+        if (this.activeTabId === null)
+            return;
+        const active = this.tabs.get(this.activeTabId);
+        if (!active)
+            return;
+        active.view.setBounds(rect);
+        const offscreen = this.offscreenBounds();
+        for (const [id, tab] of this.tabs) {
+            if (id === this.activeTabId)
+                continue;
+            tab.view.setBounds(offscreen);
+        }
+    }
+    listTabs() {
+        const out = [];
+        for (const tab of this.tabs.values()) {
+            out.push({
+                id: tab.id,
+                url: tab.url,
+                title: tab.title,
+                isActive: tab.id === this.activeTabId,
+                isCrashed: tab.isCrashed,
+                webContentsId: tab.view.webContents.id,
+            });
+        }
+        return out;
+    }
+    getCaptureSourceId(tabId) {
+        const tab = this.tabs.get(tabId);
+        if (!tab)
+            return null;
+        return tab.view.webContents.id;
+    }
+    getActiveTabId() {
+        return this.activeTabId;
+    }
+    disposeAll() {
+        for (const id of [...this.tabs.keys()]) {
+            this.closeTab(id);
+        }
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    offscreenBounds() {
+        return {
+            x: OFFSCREEN_ORIGIN.x,
+            y: OFFSCREEN_ORIGIN.y,
+            width: this.activeBounds.width,
+            height: this.activeBounds.height,
+        };
+    }
+    bindWebContentsListeners(tab) {
+        const wc = tab.view.webContents;
+        const onTitle = (_e, title) => {
+            tab.title = title;
+            this.emit("tab-title-changed", { tabId: tab.id, title });
+        };
+        const navState = () => ({
+            canGoBack: wc.navigationHistory?.canGoBack() ?? false,
+            canGoForward: wc.navigationHistory?.canGoForward() ?? false,
+        });
+        const onNavigate = (_e, url) => {
+            tab.url = url;
+            this.emit("tab-navigated", { tabId: tab.id, url, inPage: false, ...navState() });
+        };
+        const onNavigateInPage = (_e, url) => {
+            tab.url = url;
+            this.emit("tab-navigated", { tabId: tab.id, url, inPage: true, ...navState() });
+        };
+        const onGone = (_e, details) => {
+            tab.isCrashed = true;
+            const now = Date.now();
+            tab.crashTimestamps = tab.crashTimestamps.filter((t) => now - t < this.crashWindowMs);
+            tab.crashTimestamps.push(now);
+            const willRestart = tab.crashTimestamps.length <= this.maxRestarts;
+            this.emit("tab-crashed", { tabId: tab.id, reason: details.reason, willRestart });
+            if (willRestart) {
+                tab.view.webContents.loadURL(tab.url).then(() => {
+                    tab.isCrashed = false;
+                }, () => {
+                });
+            }
+        };
+        const onFinishLoad = () => {
+            tab.crashTimestamps = [];
+            tab.isCrashed = false;
+            this.emit("tab-loaded", { tabId: tab.id, url: tab.url });
+        };
+        const onDomReady = () => {
+            this.emit("tab-loaded", { tabId: tab.id, url: tab.url });
+        };
+        const onFailLoad = (_e, errorCode, errorDescription, validatedURL, isMainFrame) => {
+            if (isMainFrame === false)
+                return;
+            if (errorCode === -3)
+                return;
+            this.emit("tab-load-failed", {
+                tabId: tab.id,
+                url: validatedURL || tab.url,
+                errorCode,
+                errorDescription,
+            });
+        };
+        wc.on("page-title-updated", onTitle);
+        wc.on("did-navigate", onNavigate);
+        wc.on("did-navigate-in-page", onNavigateInPage);
+        wc.on("render-process-gone", onGone);
+        wc.on("dom-ready", onDomReady);
+        wc.on("did-finish-load", onFinishLoad);
+        wc.on("did-fail-load", onFailLoad);
+        return () => {
+            wc.removeAllListeners("page-title-updated");
+            wc.removeAllListeners("did-navigate");
+            wc.removeAllListeners("did-navigate-in-page");
+            wc.removeAllListeners("render-process-gone");
+            wc.removeAllListeners("dom-ready");
+            wc.removeAllListeners("did-finish-load");
+            wc.removeAllListeners("did-fail-load");
+        };
+    }
+}
+function randomTabId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    return `tab-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+export function makeWebContentsViewFactory(deps) {
+    return (params) => {
+        const options = deps.webPreferencesFor?.(params);
+        return new deps.WebContentsView(options);
+    };
+}

package/electron-host/dist/viewer-registry.js

@@ -0,0 +1,46 @@
+import { ViewerSession } from './viewer-session.js';
+export class ViewerRegistry {
+    sessions = new Map();
+    rtcConfig;
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+        this.rtcConfig = deps.rtcConfig;
+    }
+    ensure(sessionId) {
+        const existing = this.sessions.get(sessionId);
+        if (existing)
+            return existing;
+        const create = this.deps.createSession ??
+            ((id, rtcConfig, sink) => new ViewerSession({ sessionId: id, rtcConfig, sink }));
+        const session = create(sessionId, this.rtcConfig, this.deps.sink);
+        this.sessions.set(sessionId, session);
+        return session;
+    }
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    get size() {
+        return this.sessions.size;
+    }
+    get iceServerCount() {
+        return this.rtcConfig.iceServers?.length ?? 0;
+    }
+    destroy(sessionId, reason) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        this.sessions.delete(sessionId);
+        session.close(reason);
+        this.deps.onDestroy?.(sessionId);
+    }
+    destroyAll(reason) {
+        for (const sessionId of [...this.sessions.keys()])
+            this.destroy(sessionId, reason);
+    }
+    setRtcConfig(rtcConfig) {
+        this.rtcConfig = rtcConfig;
+        for (const session of this.sessions.values())
+            session.setRtcConfig(rtcConfig);
+    }
+}