@minionry/minion 0.7.36

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

@@ -0,0 +1,193 @@
+import { EventEmitter } from "node:events";
+import { encodeFrame, extractId, FrameParser, isPlainObject, JsonRpcError, JsonRpcErrorCode, } from "./ipc-protocol.js";
+export { JsonRpcError, JsonRpcErrorCode, };
+export class IpcServer extends EventEmitter {
+    transport;
+    onError;
+    onDisconnect;
+    handlers = new Map();
+    unknownNotifications = new Set();
+    parser = new FrameParser();
+    writeChain = Promise.resolve();
+    started = false;
+    stopped = false;
+    boundOnData = (chunk) => this.handleChunk(chunk);
+    boundOnEnd = () => this.handleEnd();
+    boundOnError = (err) => this.onError(err);
+    constructor(opts) {
+        super();
+        this.transport = opts.transport;
+        this.onError =
+            opts.onError ??
+                ((err) => {
+                    console.error("[ipc-server]", err);
+                });
+        this.onDisconnect = opts.onDisconnect;
+    }
+    start() {
+        if (this.started)
+            return;
+        if (this.stopped)
+            throw new Error("IpcServer cannot be restarted after stop()");
+        this.started = true;
+        this.transport.readable.on("data", this.boundOnData);
+        this.transport.readable.on("end", this.boundOnEnd);
+        this.transport.readable.on("error", this.boundOnError);
+        this.transport.writable.on("error", this.boundOnError);
+    }
+    async stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.started = false;
+        this.transport.readable.off("data", this.boundOnData);
+        this.transport.readable.off("end", this.boundOnEnd);
+        this.transport.readable.off("error", this.boundOnError);
+        this.transport.writable.off("error", this.boundOnError);
+        try {
+            await this.writeChain;
+        }
+        catch {
+        }
+    }
+    register(method, handler) {
+        if (this.handlers.has(method)) {
+            throw new Error(`IpcServer: handler already registered for "${method}"`);
+        }
+        this.handlers.set(method, handler);
+    }
+    notify(event, payload) {
+        const message = {
+            jsonrpc: "2.0",
+            method: event,
+            ...(payload === undefined ? {} : { params: payload }),
+        };
+        return this.send(message);
+    }
+    handleChunk(chunk) {
+        try {
+            this.parser.push(chunk, (json) => this.handleMessage(json));
+        }
+        catch (err) {
+            this.onError(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    handleEnd() {
+        this.onDisconnect?.();
+    }
+    handleMessage(json) {
+        let parsed;
+        try {
+            parsed = JSON.parse(json);
+        }
+        catch (err) {
+            this.sendError(null, JsonRpcErrorCode.ParseError, "Failed to parse JSON", {
+                cause: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        if (!isPlainObject(parsed) || parsed.jsonrpc !== "2.0") {
+            this.sendError(extractId(parsed), JsonRpcErrorCode.InvalidRequest, "Not a JSON-RPC 2.0 message");
+            return;
+        }
+        if ("result" in parsed || "error" in parsed) {
+            return;
+        }
+        const method = parsed.method;
+        if (typeof method !== "string" || method.length === 0) {
+            this.sendError(extractId(parsed), JsonRpcErrorCode.InvalidRequest, "Missing or invalid method");
+            return;
+        }
+        const params = parsed.params;
+        const hasId = "id" in parsed;
+        const rawId = hasId ? parsed.id : undefined;
+        const id = hasId
+            ? rawId === null || typeof rawId === "string" || typeof rawId === "number"
+                ? rawId
+                : null
+            : undefined;
+        this.dispatch(method, params, id);
+    }
+    dispatch(method, params, id) {
+        const handler = this.handlers.get(method);
+        if (!handler) {
+            if (id !== undefined) {
+                this.sendError(id, JsonRpcErrorCode.MethodNotFound, `Method not found: ${method}`);
+            }
+            else if (!this.unknownNotifications.has(method)) {
+                this.unknownNotifications.add(method);
+                console.log(`[B:ipc-server] notification.unhandled method=${method} — no handler registered; dropped (reported once)`);
+            }
+            return;
+        }
+        Promise.resolve()
+            .then(() => handler(params))
+            .then((result) => {
+            if (id === undefined)
+                return;
+            const response = {
+                jsonrpc: "2.0",
+                id,
+                result: result === undefined ? null : result,
+            };
+            void this.send(response);
+        }, (err) => {
+            if (id === undefined) {
+                this.onError(err instanceof Error ? err : new Error(String(err)));
+                return;
+            }
+            const body = err instanceof JsonRpcError
+                ? err.toBody()
+                : {
+                    code: JsonRpcErrorCode.InternalError,
+                    message: err instanceof Error ? err.message : String(err),
+                };
+            void this.send({ jsonrpc: "2.0", id, error: body });
+        });
+    }
+    sendError(id, code, message, data) {
+        if (id === undefined)
+            return;
+        const error = { code, message };
+        if (data !== undefined)
+            error.data = data;
+        void this.send({ jsonrpc: "2.0", id, error });
+    }
+    send(message) {
+        if (this.stopped)
+            return Promise.resolve();
+        const frame = encodeFrame(message);
+        const next = this.writeChain.then(() => this.writeOne(frame), () => this.writeOne(frame));
+        this.writeChain = next.catch(() => undefined);
+        return next;
+    }
+    writeOne(frame) {
+        return new Promise((resolve, reject) => {
+            const writable = this.transport.writable;
+            if (writable.writableEnded || writable.destroyed) {
+                reject(new Error("IpcServer: transport writable is closed"));
+                return;
+            }
+            let settled = false;
+            const ok = writable.write(frame, (err) => {
+                if (err && !settled) {
+                    settled = true;
+                    reject(err);
+                }
+            });
+            if (ok) {
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+                return;
+            }
+            writable.once("drain", () => {
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            });
+        });
+    }
+}

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

@@ -0,0 +1,216 @@
+export class TabNotFoundError extends Error {
+    code = "tab_not_found";
+    tabId;
+    constructor(tabId) {
+        super(`tab_not_found: ${tabId}`);
+        this.name = "TabNotFoundError";
+        this.tabId = tabId;
+    }
+}
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_PROTOCOL_VERSION = "1.3";
+const DEFAULT_ISOLATED_WORLD_NAME = "minionry-isolated";
+export class JsDriver {
+    resolveTab;
+    defaultTimeoutMs;
+    protocolVersion;
+    isolatedWorldName;
+    isolatedContexts = new Map();
+    debuggerListenersBound = new WeakSet();
+    constructor(options) {
+        this.resolveTab = options.resolveTab;
+        this.defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.protocolVersion = options.protocolVersion ?? DEFAULT_PROTOCOL_VERSION;
+        this.isolatedWorldName = options.isolatedWorldName ?? DEFAULT_ISOLATED_WORLD_NAME;
+    }
+    async evaluate(params) {
+        const wc = this.resolveTab(params.tabId);
+        if (!wc)
+            throw new TabNotFoundError(params.tabId);
+        const timeoutMs = params.timeoutMs ?? this.defaultTimeoutMs;
+        const work = params.world === "main"
+            ? this.evalMain(wc, params.expr)
+            : this.evalIsolated(params.tabId, wc, params.expr);
+        try {
+            return await withTimeout(work, timeoutMs);
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    }
+    invalidate(tabId) {
+        this.isolatedContexts.delete(tabId);
+    }
+    async evalMain(wc, expr) {
+        const value = await wc.executeJavaScript(expr, true);
+        return normalizeValue(value);
+    }
+    async evalIsolated(tabId, wc, expr) {
+        const ctx = await this.ensureIsolatedContext(tabId, wc);
+        let response;
+        try {
+            response = (await wc.debugger.sendCommand("Runtime.evaluate", {
+                expression: expr,
+                contextId: ctx.contextId,
+                returnByValue: true,
+                awaitPromise: true,
+            }));
+        }
+        catch (err) {
+            this.isolatedContexts.delete(tabId);
+            const fresh = await this.ensureIsolatedContext(tabId, wc);
+            try {
+                response = (await wc.debugger.sendCommand("Runtime.evaluate", {
+                    expression: expr,
+                    contextId: fresh.contextId,
+                    returnByValue: true,
+                    awaitPromise: true,
+                }));
+            }
+            catch (_retryErr) {
+                return errorResult(err);
+            }
+        }
+        if (response.exceptionDetails) {
+            const ex = response.exceptionDetails;
+            const msg = ex.exception?.description ?? ex.text ?? "evaluation threw";
+            return { value: undefined, type: "error", error: String(msg) };
+        }
+        const remote = response.result;
+        if (!remote)
+            return { value: undefined, type: "undefined" };
+        return normalizeRemote(remote);
+    }
+    async ensureIsolatedContext(tabId, wc) {
+        const cached = this.isolatedContexts.get(tabId);
+        if (cached)
+            return cached;
+        if (!wc.debugger.isAttached()) {
+            wc.debugger.attach(this.protocolVersion);
+        }
+        this.bindDebuggerListeners(tabId, wc.debugger);
+        await wc.debugger.sendCommand("Page.enable");
+        const tree = (await wc.debugger.sendCommand("Page.getFrameTree"));
+        const frameId = tree?.frameTree?.frame?.id;
+        if (typeof frameId !== "string" || frameId.length === 0) {
+            throw new Error("could not resolve main frameId for isolated world");
+        }
+        const created = (await wc.debugger.sendCommand("Page.createIsolatedWorld", {
+            frameId,
+            worldName: this.isolatedWorldName,
+            grantUniveralAccess: false,
+        }));
+        const contextId = created?.executionContextId;
+        if (typeof contextId !== "number") {
+            throw new Error("Page.createIsolatedWorld did not return an executionContextId");
+        }
+        const ctx = { contextId, frameId };
+        this.isolatedContexts.set(tabId, ctx);
+        return ctx;
+    }
+    bindDebuggerListeners(tabId, dbg) {
+        if (this.debuggerListenersBound.has(dbg))
+            return;
+        this.debuggerListenersBound.add(dbg);
+        dbg.on("detach", () => {
+            this.isolatedContexts.delete(tabId);
+        });
+        dbg.on("message", (...args) => {
+            const method = args[1];
+            const params = args[2];
+            if (typeof method !== "string")
+                return;
+            if (method === "Runtime.executionContextDestroyed") {
+                const cached = this.isolatedContexts.get(tabId);
+                if (cached && params?.executionContextId === cached.contextId) {
+                    this.isolatedContexts.delete(tabId);
+                }
+                return;
+            }
+            if (method === "Page.frameNavigated") {
+                this.isolatedContexts.delete(tabId);
+            }
+        });
+    }
+}
+function normalizeValue(value) {
+    if (value === null)
+        return { value: null, type: "object" };
+    const t = typeof value;
+    if (t === "undefined")
+        return { value: undefined, type: "undefined" };
+    if (t === "function")
+        return { value: undefined, type: "function" };
+    if (t === "string" || t === "number" || t === "boolean") {
+        return { value, type: t };
+    }
+    if (t === "object") {
+        try {
+            JSON.stringify(value);
+        }
+        catch (err) {
+            return {
+                value: undefined,
+                type: "error",
+                error: `result not JSON-serializable: ${err.message}`,
+            };
+        }
+        return { value, type: "object" };
+    }
+    return {
+        value: undefined,
+        type: "error",
+        error: `unsupported result type: ${t}`,
+    };
+}
+function normalizeRemote(remote) {
+    switch (remote.type) {
+        case "undefined":
+            return { value: undefined, type: "undefined" };
+        case "string":
+            return { value: remote.value, type: "string" };
+        case "number":
+            return { value: remote.value, type: "number" };
+        case "boolean":
+            return { value: remote.value, type: "boolean" };
+        case "function":
+            return { value: undefined, type: "function" };
+        case "object": {
+            if (remote.subtype === "null")
+                return { value: null, type: "object" };
+            if (remote.value === undefined) {
+                return {
+                    value: undefined,
+                    type: "error",
+                    error: `result not JSON-serializable${remote.description ? `: ${remote.description}` : ""}`,
+                };
+            }
+            return { value: remote.value, type: "object" };
+        }
+        default:
+            return {
+                value: undefined,
+                type: "error",
+                error: `unsupported remote type: ${remote.type}${remote.unserializableValue ? ` (${remote.unserializableValue})` : ""}`,
+            };
+    }
+}
+function errorResult(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { value: undefined, type: "error", error: msg };
+}
+async function withTimeout(p, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            p,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`evaluate timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/electron-host/dist/main-guards.js

@@ -0,0 +1,70 @@
+import { JsonRpcError, JsonRpcErrorCode } from './ipc-server.js';
+export function requireId(params) {
+    if (!params ||
+        typeof params !== "object" ||
+        typeof params.id !== "string") {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "missing id");
+    }
+    return params.id;
+}
+export function isRect(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const r = value;
+    return (typeof r.x === "number" &&
+        typeof r.y === "number" &&
+        typeof r.width === "number" &&
+        typeof r.height === "number");
+}
+export function isOfferPayload(v) {
+    if (!v || typeof v !== "object")
+        return false;
+    const r = v;
+    return (typeof r.sessionId === "string" &&
+        typeof r.sdp === "string" &&
+        r.sdpType === "offer");
+}
+export function isLocalIcePayload(v) {
+    if (!v || typeof v !== "object")
+        return false;
+    const r = v;
+    if (typeof r.sessionId !== "string")
+        return false;
+    if (r.candidate === null)
+        return true;
+    return typeof r.candidate === "object";
+}
+export function isIceCandidateInit(v) {
+    if (!v || typeof v !== "object")
+        return false;
+    const r = v;
+    if (r.candidate !== undefined && typeof r.candidate !== "string")
+        return false;
+    if (r.sdpMLineIndex !== undefined &&
+        r.sdpMLineIndex !== null &&
+        typeof r.sdpMLineIndex !== "number") {
+        return false;
+    }
+    if (r.sdpMid !== undefined &&
+        r.sdpMid !== null &&
+        typeof r.sdpMid !== "string") {
+        return false;
+    }
+    if (r.usernameFragment !== undefined &&
+        r.usernameFragment !== null &&
+        typeof r.usernameFragment !== "string") {
+        return false;
+    }
+    return true;
+}
+export function isConnectionStatePayload(v) {
+    if (!v || typeof v !== "object")
+        return false;
+    const r = v;
+    if (typeof r.sessionId !== "string" || typeof r.state !== "string")
+        return false;
+    return (r.state === "negotiating" ||
+        r.state === "connected" ||
+        r.state === "failed" ||
+        r.state === "closed");
+}