@minionry/minion 0.7.36

package/electron-host/dist/fake-peer.test-util.js

@@ -0,0 +1,105 @@
+import { vi } from 'vitest';
+export const FAKE_OFFER_SDP = 'v=0\r\nm=video 9 UDP/TLS/RTP/SAVPF 96 102\r\na=rtpmap:96 VP8/90000\r\na=rtpmap:102 H264/90000\r\n';
+export class FakeSender {
+    track = null;
+    setStreams = vi.fn();
+    replaceTrack = vi.fn(async (track) => {
+        this.track = track;
+    });
+}
+export class FakePeerConnection extends EventTarget {
+    signalingState = 'stable';
+    connectionState = 'new';
+    iceConnectionState = 'new';
+    localDescription = null;
+    remoteDescription = null;
+    addedCandidates = [];
+    restartIce = vi.fn();
+    setConfiguration = vi.fn();
+    close = vi.fn(() => {
+        this.signalingState = 'closed';
+        this.connectionState = 'closed';
+    });
+    localDescriptionArgs = [];
+    addIceCandidateError = null;
+    releaseOffer = null;
+    holdOffer = false;
+    async createOffer() {
+        return { type: 'offer', sdp: FAKE_OFFER_SDP };
+    }
+    async setLocalDescription(description) {
+        this.localDescriptionArgs.push(description);
+        if (this.holdOffer)
+            await new Promise((resolve) => (this.releaseOffer = resolve));
+        this.localDescription = description ?? { type: 'offer', sdp: FAKE_OFFER_SDP };
+        this.signalingState = 'have-local-offer';
+    }
+    finishOffer() {
+        this.releaseOffer?.();
+        this.releaseOffer = null;
+    }
+    async setRemoteDescription(description) {
+        this.remoteDescription = description;
+        this.signalingState = 'stable';
+    }
+    async addIceCandidate(candidate) {
+        if (this.addIceCandidateError !== null)
+            throw new Error(this.addIceCandidateError);
+        this.addedCandidates.push(candidate);
+    }
+    setConnectionState(state, ice = this.iceConnectionState) {
+        this.connectionState = state;
+        this.iceConnectionState = ice;
+        this.dispatchEvent(new Event('connectionstatechange'));
+    }
+    fire(type) {
+        this.dispatchEvent(new Event(type));
+    }
+    fireLocalCandidate(candidate) {
+        const event = Object.assign(new Event('icecandidate'), {
+            candidate: candidate === null ? null : { toJSON: () => candidate },
+        });
+        this.dispatchEvent(event);
+    }
+}
+export function fakePeer(opts = {}) {
+    const pc = new FakePeerConnection();
+    const videoSender = new FakeSender();
+    const audioSender = new FakeSender();
+    return {
+        pc,
+        videoSender,
+        audioSender,
+        create: () => ({
+            pc: pc,
+            videoSender: videoSender,
+            audioSender: audioSender,
+            codecPolicyApplied: opts.codecPolicyApplied ?? true,
+        }),
+    };
+}
+export function recordingSink() {
+    const sink = {
+        offers: [],
+        candidates: [],
+        states: [],
+        errors: [],
+        offer: (payload) => sink.offers.push(payload),
+        ice: (payload) => sink.candidates.push(payload),
+        state: (payload) => sink.states.push(payload),
+        error: (payload) => sink.errors.push(payload),
+    };
+    return sink;
+}
+export function fakeTrack(kind, readyState = 'live') {
+    return { kind, readyState };
+}
+export function fakeStream(opts = {}) {
+    const video = fakeTrack('video', opts.videoState ?? 'live');
+    const audio = opts.audio ? [fakeTrack('audio')] : [];
+    return { getVideoTracks: () => [video], getAudioTracks: () => audio };
+}
+export async function flushMicrotasks() {
+    for (let i = 0; i < 10; i++)
+        await Promise.resolve();
+}

package/electron-host/dist/host-log.js

@@ -0,0 +1,31 @@
+const DEBUG = typeof process !== 'undefined' && process.env?.MINIONRY_BROWSER_DEBUG === '1';
+function formatDetail(detail) {
+    if (detail === undefined || detail === '')
+        return '';
+    if (typeof detail === 'string')
+        return ` ${detail}`;
+    if (detail instanceof Error)
+        return ` ${detail.message}`;
+    try {
+        return ` ${JSON.stringify(detail)}`;
+    }
+    catch {
+        return ` ${String(detail)}`;
+    }
+}
+export function hostLog(component) {
+    const prefix = `[B:${component}]`;
+    const line = (event, detail) => `${prefix} ${event}${formatDetail(detail)}`;
+    const log = ((event, detail) => {
+        if (DEBUG)
+            console.log(line(event, detail));
+    });
+    log.info = (event, detail) => console.log(line(event, detail));
+    log.warn = (event, detail) => console.warn(line(event, detail));
+    log.error = (event, detail) => console.error(line(event, detail));
+    return log;
+}
+export const hostDebugEnabled = DEBUG;
+export function shortId(id) {
+    return id ? id.slice(0, 8) : '-';
+}

package/electron-host/dist/host-wire.js

@@ -0,0 +1,11 @@
+export function isDeviceProfileEnvelope(params) {
+    if (!params || typeof params.tabId !== "string")
+        return false;
+    const profile = params.profile;
+    if (!profile || (profile.formFactor !== "mobile" && profile.formFactor !== "desktop"))
+        return false;
+    return typeof profile.width === "number" && typeof profile.height === "number";
+}
+export const MIN_HOST_DIM = 320;
+export const MAX_HOST_DIM = 3840;
+export const AGENT_SESSION_ID = "__minionry_agent__";

package/electron-host/dist/input-router.js

@@ -0,0 +1,421 @@
+import { hostLog } from "./host-log.js";
+const MOD_ALT = 1;
+const MOD_CTRL = 2;
+const MOD_META = 4;
+const MOD_SHIFT = 8;
+const CDP_MOD_ALT = 1;
+const CDP_MOD_CTRL = 2;
+const CDP_MOD_META = 4;
+const CDP_MOD_SHIFT = 8;
+const CDP_PROTOCOL_VERSION = "1.3";
+const ilog = hostLog("input");
+const PIXELS_PER_LINE = 16;
+const DEFAULT_PAGE_HEIGHT = 720;
+export class InputRouter {
+    views;
+    pageHeight;
+    cdpAttached = new Set();
+    constructor(options) {
+        this.views = options.views;
+        this.pageHeight = options.pageHeight ?? DEFAULT_PAGE_HEIGHT;
+    }
+    forwardEvent(envelope) {
+        const data = isWireEnvelope(envelope)
+            ? envelope.data
+            : envelope;
+        const envelopeTabId = isWireEnvelope(envelope) ? envelope.tabId : undefined;
+        const view = this.resolveView(envelopeTabId);
+        if (!view) {
+            ilog("drop.no_active_view", `kind=${data.kind} envelopeTabId=${envelopeTabId ?? "-"}`);
+            return;
+        }
+        const wc = view.webContents;
+        switch (data.kind) {
+            case "mouse":
+                this.handleMouse(wc, data);
+                return;
+            case "key":
+                this.handleKey(wc, data);
+                return;
+            case "touch":
+                this.handleTouch(wc, data);
+                return;
+            case "text":
+                this.handleText(wc, data);
+                return;
+            case "ime":
+                this.handleIme(wc, data);
+                return;
+        }
+    }
+    releaseTab(webContentsId) {
+        this.cdpAttached.delete(webContentsId);
+    }
+    resolveView(tabId) {
+        if (tabId && this.views.getViewByTabId) {
+            const v = this.views.getViewByTabId(tabId);
+            if (v)
+                return v;
+        }
+        return this.views.getActiveView();
+    }
+    handleMouse(wc, data) {
+        if (data.eventType === "mouseWheel") {
+            this.handleWheel(wc, data);
+            return;
+        }
+        const type = mouseTypeFor(data.eventType);
+        if (!type) {
+            ilog("drop.unrecognized_mouse_type", `eventType=${data.eventType}`);
+            return;
+        }
+        if (type === "mouseDown") {
+            tryFocus(wc);
+            if (wc.debugger)
+                this.ensureAttached(wc, wc.debugger);
+        }
+        const event = {
+            type,
+            x: Math.round(data.x),
+            y: Math.round(data.y),
+            modifiers: modifiersFromBitfield(data.modifiers),
+        };
+        if (type === "mouseDown" || type === "mouseUp") {
+            if (data.button === "left" ||
+                data.button === "middle" ||
+                data.button === "right") {
+                event.button = data.button;
+            }
+            if (data.clickCount > 0) {
+                event.clickCount = data.clickCount;
+            }
+        }
+        wc.sendInputEvent(event);
+    }
+    handleWheel(wc, data) {
+        const rawX = data.deltaX ?? 0;
+        const rawY = data.deltaY ?? 0;
+        const deltaMode = data.deltaMode ?? 0;
+        const { deltaX, deltaY } = convertWheelDelta(rawX, rawY, deltaMode, this.pageHeight);
+        this.cdpSend(wc, "Input.dispatchMouseEvent", {
+            type: "mouseWheel",
+            x: Math.round(data.x),
+            y: Math.round(data.y),
+            deltaX,
+            deltaY,
+            modifiers: cdpModifiersFromBitfield(data.modifiers),
+        });
+    }
+    handleKey(wc, data) {
+        const type = data.eventType;
+        ilog("key.recv", `type=${type} key=${JSON.stringify(data.key)} code=${data.code} text=${JSON.stringify(data.text ?? "")} kc=${data.keyCode ?? "-"} wcId=${wc.id ?? "-"} hasDbg=${wc.debugger ? "y" : "n"}`);
+        if (type === "keyDown" || type === "rawKeyDown") {
+            tryFocus(wc);
+        }
+        const isShift = (data.modifiers & MOD_SHIFT) !== 0;
+        const text = data.text ?? "";
+        const unmodifiedText = isShift && text.length === 1 ? text.toLowerCase() : text;
+        const params = {
+            type,
+            modifiers: cdpModifiersFromBitfield(data.modifiers),
+            key: data.key,
+            code: data.code,
+            windowsVirtualKeyCode: data.keyCode ?? 0,
+            nativeVirtualKeyCode: data.keyCode ?? 0,
+            autoRepeat: false,
+            isKeypad: false,
+            isSystemKey: false,
+        };
+        if (text.length > 0) {
+            params.text = text;
+            params.unmodifiedText = unmodifiedText;
+        }
+        this.cdpSend(wc, "Input.dispatchKeyEvent", params);
+    }
+    handleText(wc, data) {
+        if (!data.text)
+            return;
+        this.cdpSend(wc, "Input.insertText", { text: data.text });
+    }
+    handleIme(wc, data) {
+        switch (data.eventType) {
+            case "start":
+            case "update": {
+                const text = data.imeText ?? "";
+                const selStart = data.selectionStart ?? text.length;
+                const selEnd = data.selectionEnd ?? selStart;
+                this.cdpSend(wc, "Input.imeSetComposition", {
+                    text,
+                    selectionStart: selStart,
+                    selectionEnd: selEnd,
+                });
+                return;
+            }
+            case "commit": {
+                const text = data.text ?? "";
+                this.cdpSend(wc, "Input.imeSetComposition", {
+                    text: "",
+                    selectionStart: 0,
+                    selectionEnd: 0,
+                });
+                if (text.length > 0) {
+                    this.cdpSend(wc, "Input.insertText", { text });
+                }
+                return;
+            }
+        }
+    }
+    handleTouch(wc, data) {
+        if (data.eventType === "touchStart") {
+            tryFocus(wc);
+        }
+        const touchPoints = data.touchPoints.map((p) => {
+            const point = {
+                x: Math.round(p.x),
+                y: Math.round(p.y),
+                id: p.id,
+            };
+            if (p.force !== undefined)
+                point.force = p.force;
+            if (p.radiusX !== undefined)
+                point.radiusX = p.radiusX;
+            if (p.radiusY !== undefined)
+                point.radiusY = p.radiusY;
+            return point;
+        });
+        this.cdpSend(wc, "Input.dispatchTouchEvent", {
+            type: data.eventType,
+            touchPoints,
+            modifiers: cdpModifiersFromBitfield(data.modifiers),
+        });
+    }
+    cdpSend(wc, method, params) {
+        const dbg = wc.debugger;
+        if (!dbg) {
+            ilog("drop.no_debugger", `method=${method}`);
+            return;
+        }
+        if (!this.ensureAttached(wc, dbg)) {
+            ilog("drop.attach_failed", `method=${method}`);
+            return;
+        }
+        try {
+            ilog("cdp.send", `method=${method}`);
+            const p = dbg.sendCommand(method, params);
+            if (p && typeof p.then === "function") {
+                p
+                    .then(() => {
+                    ilog("cdp.ok", `method=${method}`);
+                })
+                    .catch((err) => {
+                    const msg = errMessage(err);
+                    if (/wasn't found|not found|doesn't exist|Unknown method/i.test(msg)) {
+                        console.warn(`[B:input] cdp.unsupported method=${method} err=${msg}`);
+                    }
+                    ilog("cdp.error", `method=${method} err=${msg}`);
+                });
+            }
+        }
+        catch (err) {
+            ilog("cdp.throw", `method=${method} err=${errMessage(err)}`);
+        }
+    }
+    ensureAttached(wc, dbg) {
+        const id = wc.id;
+        if (id !== undefined && this.cdpAttached.has(id)) {
+            return true;
+        }
+        try {
+            if (!dbg.isAttached()) {
+                dbg.attach(CDP_PROTOCOL_VERSION);
+            }
+            if (id !== undefined) {
+                this.cdpAttached.add(id);
+            }
+            this.enableFocusEmulation(dbg);
+            return true;
+        }
+        catch (err) {
+            ilog("attach.error", errMessage(err));
+            return false;
+        }
+    }
+    enableFocusEmulation(dbg) {
+        try {
+            ilog("focus_emulation.send", "");
+            const p = dbg.sendCommand("Emulation.setFocusEmulationEnabled", {
+                enabled: true,
+            });
+            if (p && typeof p.then === "function") {
+                p
+                    .then(() => {
+                    ilog("focus_emulation.ok", "page now treated as focused+active");
+                })
+                    .catch((err) => {
+                    const msg = errMessage(err);
+                    console.warn(`[B:input] focus_emulation FAILED — keyboard into focused inputs will not work: ${msg}`);
+                    ilog("focus_emulation.error", msg);
+                });
+            }
+        }
+        catch (err) {
+            ilog("focus_emulation.throw", errMessage(err));
+        }
+    }
+}
+export function modifiersFromBitfield(bitfield) {
+    const out = [];
+    if (bitfield & MOD_SHIFT)
+        out.push("shift");
+    if (bitfield & MOD_CTRL)
+        out.push("control");
+    if (bitfield & MOD_ALT)
+        out.push("alt");
+    if (bitfield & MOD_META)
+        out.push("meta");
+    return out;
+}
+export function cdpModifiersFromBitfield(bitfield) {
+    let m = 0;
+    if (bitfield & MOD_ALT)
+        m |= CDP_MOD_ALT;
+    if (bitfield & MOD_CTRL)
+        m |= CDP_MOD_CTRL;
+    if (bitfield & MOD_META)
+        m |= CDP_MOD_META;
+    if (bitfield & MOD_SHIFT)
+        m |= CDP_MOD_SHIFT;
+    return m;
+}
+function mouseTypeFor(et) {
+    switch (et) {
+        case "mousePressed":
+            return "mouseDown";
+        case "mouseReleased":
+            return "mouseUp";
+        case "mouseMoved":
+            return "mouseMove";
+        case "mouseWheel":
+            return null;
+    }
+}
+export function convertWheelDelta(deltaX, deltaY, deltaMode, pageHeight) {
+    let pxX = deltaX;
+    let pxY = deltaY;
+    if (deltaMode === 1) {
+        pxX *= PIXELS_PER_LINE;
+        pxY *= PIXELS_PER_LINE;
+    }
+    else if (deltaMode === 2) {
+        pxX *= pageHeight;
+        pxY *= pageHeight;
+    }
+    return { deltaX: Math.round(pxX), deltaY: Math.round(pxY) };
+}
+export function acceleratorFromDom(code, key) {
+    if (MODIFIER_ONLY_CODES.has(code))
+        return null;
+    if (code === "ContextMenu")
+        return null;
+    const letter = rangedCode(code, "Key", 0x41  , 0x5a  );
+    if (letter)
+        return letter;
+    const digit = rangedCode(code, "Digit", 0x30  , 0x39  );
+    if (digit)
+        return digit;
+    const numpad = rangedCode(code, "Numpad", 0x30, 0x39);
+    if (numpad)
+        return `num${numpad}`;
+    const direct = ACCELERATOR_LOOKUP[code];
+    if (direct)
+        return direct;
+    if (/^F\d{1,2}$/.test(code)) {
+        const n = Number(code.slice(1));
+        if (n >= 1 && n <= 24)
+            return code;
+    }
+    if (key && key.length === 1) {
+        return key.toUpperCase();
+    }
+    return ACCELERATOR_LOOKUP[key] ?? null;
+}
+function rangedCode(code, prefix, lo, hi) {
+    if (code.length !== prefix.length + 1 || !code.startsWith(prefix))
+        return null;
+    const c = code.charCodeAt(prefix.length);
+    return c >= lo && c <= hi ? code.slice(prefix.length) : null;
+}
+const MODIFIER_ONLY_CODES = new Set([
+    "ControlLeft",
+    "ControlRight",
+    "ShiftLeft",
+    "ShiftRight",
+    "AltLeft",
+    "AltRight",
+    "MetaLeft",
+    "MetaRight",
+    "OSLeft",
+    "OSRight",
+]);
+const ACCELERATOR_LOOKUP = {
+    NumpadDecimal: "numdec",
+    NumpadAdd: "numadd",
+    NumpadSubtract: "numsub",
+    NumpadMultiply: "nummult",
+    NumpadDivide: "numdiv",
+    NumpadEnter: "Enter",
+    Enter: "Enter",
+    Tab: "Tab",
+    Backspace: "Backspace",
+    Delete: "Delete",
+    Insert: "Insert",
+    Escape: "Escape",
+    Space: "Space",
+    ArrowUp: "Up",
+    ArrowDown: "Down",
+    ArrowLeft: "Left",
+    ArrowRight: "Right",
+    Home: "Home",
+    End: "End",
+    PageUp: "PageUp",
+    PageDown: "PageDown",
+    CapsLock: "Capslock",
+    NumLock: "Numlock",
+    ScrollLock: "Scrolllock",
+    PrintScreen: "PrintScreen",
+    AudioVolumeUp: "VolumeUp",
+    AudioVolumeDown: "VolumeDown",
+    AudioVolumeMute: "VolumeMute",
+    MediaTrackNext: "MediaNextTrack",
+    MediaTrackPrevious: "MediaPreviousTrack",
+    MediaStop: "MediaStop",
+    MediaPlayPause: "MediaPlayPause",
+    Minus: "-",
+    Equal: "=",
+    BracketLeft: "[",
+    BracketRight: "]",
+    Backslash: "\\",
+    Semicolon: ";",
+    Quote: '"',
+    Comma: ",",
+    Period: ".",
+    Slash: "/",
+    Backquote: "`",
+};
+function isWireEnvelope(e) {
+    return e.type === "browser_input";
+}
+function tryFocus(wc) {
+    if (process.platform === "darwin")
+        return;
+    if (!wc.focus)
+        return;
+    try {
+        wc.focus();
+    }
+    catch {
+    }
+}
+function errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/electron-host/dist/ipc-protocol.js

@@ -0,0 +1,89 @@
+export const JsonRpcErrorCode = {
+    ParseError: -32700,
+    InvalidRequest: -32600,
+    MethodNotFound: -32601,
+    InvalidParams: -32602,
+    InternalError: -32603,
+};
+export class JsonRpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.name = "JsonRpcError";
+        this.code = code;
+        this.data = data;
+    }
+    toBody() {
+        const body = { code: this.code, message: this.message };
+        if (this.data !== undefined)
+            body.data = this.data;
+        return body;
+    }
+}
+const HEADER_SEPARATOR = Buffer.from("\r\n\r\n");
+const CONTENT_LENGTH_RE = /^Content-Length:\s*(\d+)\s*$/i;
+export const MAX_FRAME_BYTES = 256 * 1024 * 1024;
+export function encodeFrame(payload) {
+    const body = Buffer.from(JSON.stringify(payload), "utf8");
+    const header = Buffer.from(`Content-Length: ${body.byteLength}\r\n\r\n`, "ascii");
+    return Buffer.concat([header, body]);
+}
+export class FrameParser {
+    buffer = Buffer.alloc(0);
+    expectedBodyBytes = null;
+    push(chunk, onMessage) {
+        this.buffer =
+            this.buffer.length === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+        while (true) {
+            if (this.expectedBodyBytes === null) {
+                const sepIdx = this.buffer.indexOf(HEADER_SEPARATOR);
+                if (sepIdx === -1)
+                    return;
+                const headerText = this.buffer.subarray(0, sepIdx).toString("ascii");
+                this.buffer = this.buffer.subarray(sepIdx + HEADER_SEPARATOR.length);
+                this.expectedBodyBytes = this.parseContentLength(headerText);
+            }
+            if (this.expectedBodyBytes === null)
+                return;
+            if (this.buffer.length < this.expectedBodyBytes)
+                return;
+            const body = this.buffer.subarray(0, this.expectedBodyBytes);
+            this.buffer = this.buffer.subarray(this.expectedBodyBytes);
+            this.expectedBodyBytes = null;
+            onMessage(body.toString("utf8"));
+        }
+    }
+    parseContentLength(headerText) {
+        let length = null;
+        for (const line of headerText.split(/\r?\n/)) {
+            if (!line)
+                continue;
+            const match = CONTENT_LENGTH_RE.exec(line);
+            if (match) {
+                length = Number(match[1]);
+                break;
+            }
+        }
+        if (length === null || !Number.isFinite(length) || length < 0) {
+            throw new JsonRpcError(JsonRpcErrorCode.ParseError, "Missing or invalid Content-Length header");
+        }
+        if (length > MAX_FRAME_BYTES) {
+            throw new JsonRpcError(JsonRpcErrorCode.ParseError, `Content-Length ${length} exceeds the ${MAX_FRAME_BYTES}-byte frame limit`);
+        }
+        return length;
+    }
+}
+export function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function extractId(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    if (!("id" in value))
+        return undefined;
+    const id = value.id;
+    if (id === null || typeof id === "string" || typeof id === "number")
+        return id;
+    return undefined;
+}