@minionry/minion 0.7.36

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

@@ -0,0 +1,159 @@
+import { TabAlreadyLeasedError } from './agent-lease.js';
+import { DomDriverError } from './dom-driver.js';
+import { requireTabIdParams, validateBufferReadParams, validateClickParams, validateDragDropParams, validateEvaluateParams, validateFileUploadParams, validateFillFormParams, validateHandleDialogParams, validateHeartbeatParams, validateHoverParams, validateLeaseParams, validateListParams, validatePlanReleaseParams, validatePressKeyParams, validateReleaseParams, validateScreenshotParams, validateSelectOptionParams, validateTypeParams, validateWaitForParams, } from './domain-validators.js';
+import { JsonRpcError } from './ipc-server.js';
+import { TabNotFoundError } from './js-driver.js';
+const AppErrorCode = {
+    TabAlreadyLeased: -32010,
+    TabNotFound: -32011,
+    RefStale: -32012,
+    DomTimeout: -32013,
+    NavigationInProgress: -32014,
+    ArbitrationUserActive: -32015,
+};
+export function registerDomainMethods(deps) {
+    const { ipcServer, leaseRegistry, domDriver, jsDriver } = deps;
+    ipcServer.register("agent.tab.lease", async (params) => {
+        const p = validateLeaseParams(params);
+        try {
+            return leaseRegistry.lease(p);
+        }
+        catch (err) {
+            if (err instanceof TabAlreadyLeasedError) {
+                throw new JsonRpcError(AppErrorCode.TabAlreadyLeased, err.message, { code: err.code, currentOwner: err.currentOwner });
+            }
+            throw err;
+        }
+    });
+    ipcServer.register("agent.tab.release", async (params) => {
+        const p = validateReleaseParams(params);
+        return { released: leaseRegistry.release(p.tabId, p.agentId) };
+    });
+    ipcServer.register("agent.tab.heartbeat", async (params) => {
+        const p = validateHeartbeatParams(params);
+        return leaseRegistry.heartbeat(p);
+    });
+    ipcServer.register("agent.tab.list", async (params) => {
+        const p = validateListParams(params);
+        return leaseRegistry.list(p);
+    });
+    ipcServer.register("agent.plan.release", async (params) => {
+        const p = validatePlanReleaseParams(params);
+        return { released: leaseRegistry.releasePlan(p.planId) };
+    });
+    ipcServer.register("dom.snapshot", (params) => runDom(() => domDriver.snapshot(requireTabIdParams(params, "dom.snapshot"))));
+    ipcServer.register("dom.click", (params) => runDom(async () => {
+        await domDriver.click(validateClickParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.type", (params) => runDom(async () => {
+        await domDriver.type(validateTypeParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.hover", (params) => runDom(async () => {
+        await domDriver.hover(validateHoverParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.press_key", (params) => runDom(async () => {
+        await domDriver.press_key(validatePressKeyParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.select_option", (params) => runDom(async () => {
+        await domDriver.select_option(validateSelectOptionParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.fill_form", (params) => runDom(async () => {
+        await domDriver.fill_form(validateFillFormParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.drag_drop", (params) => runDom(async () => {
+        await domDriver.drag_drop(validateDragDropParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.file_upload", (params) => runDom(async () => {
+        await domDriver.file_upload(validateFileUploadParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.handle_dialog", (params) => runDom(async () => {
+        await domDriver.handle_dialog(validateHandleDialogParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.wait_for", (params) => runDom(async () => {
+        await domDriver.wait_for(validateWaitForParams(params));
+        return null;
+    }));
+    ipcServer.register("dom.screenshot", (params) => runDom(async () => {
+        const out = await domDriver.screenshot(validateScreenshotParams(params));
+        const wire = {
+            format: out.format,
+            data: out.data.toString("base64"),
+        };
+        return wire;
+    }));
+    ipcServer.register("dom.console", (params) => {
+        const p = validateBufferReadParams(params, "dom.console");
+        return runDomSync(() => domDriver.console(p));
+    });
+    ipcServer.register("dom.network", (params) => {
+        const p = validateBufferReadParams(params, "dom.network");
+        return runDomSync(() => domDriver.network(p));
+    });
+    ipcServer.register("js.evaluate", async (params) => {
+        const p = validateEvaluateParams(params);
+        try {
+            return await jsDriver.evaluate(p);
+        }
+        catch (err) {
+            if (err instanceof TabNotFoundError) {
+                throw new JsonRpcError(AppErrorCode.TabNotFound, err.message, {
+                    code: err.code,
+                    tabId: err.tabId,
+                });
+            }
+            throw err;
+        }
+    });
+    const onLeaseExpired = (payload) => {
+        void ipcServer.notify("lease.expired", payload);
+    };
+    leaseRegistry.on("lease-expired", onLeaseExpired);
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        leaseRegistry.off("lease-expired", onLeaseExpired);
+    };
+}
+async function runDom(fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        throw translateDomError(err);
+    }
+}
+function runDomSync(fn) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        throw translateDomError(err);
+    }
+}
+function translateDomError(err) {
+    if (err instanceof DomDriverError) {
+        const codeMap = {
+            tab_not_found: AppErrorCode.TabNotFound,
+            ref_stale: AppErrorCode.RefStale,
+            timeout: AppErrorCode.DomTimeout,
+            navigation_in_progress: AppErrorCode.NavigationInProgress,
+            arbitration_user_active: AppErrorCode.ArbitrationUserActive,
+        };
+        return new JsonRpcError(codeMap[err.code], err.message, {
+            code: err.code,
+            ...(err.details ?? {}),
+        });
+    }
+    return err;
+}

package/electron-host/dist/domain-validators.js

@@ -0,0 +1,308 @@
+import { JsonRpcError, JsonRpcErrorCode } from './ipc-server.js';
+function asObj(value, method) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${method}: params must be an object`);
+    }
+    return value;
+}
+function asString(v, method, field) {
+    if (typeof v !== "string" || v.length === 0) {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${method}: ${field} must be a non-empty string`);
+    }
+    return v;
+}
+function optString(v, method, field) {
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== "string") {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${method}: ${field} must be a string when present`);
+    }
+    return v;
+}
+function optNumber(v, method, field) {
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== "number" || !Number.isFinite(v)) {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${method}: ${field} must be a finite number when present`);
+    }
+    return v;
+}
+function optBoolean(v, method, field) {
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== "boolean") {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${method}: ${field} must be a boolean when present`);
+    }
+    return v;
+}
+function asStringArray(v, method, field) {
+    if (!Array.isArray(v) || v.some((x) => typeof x !== "string")) {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${method}: ${field} must be a string[]`);
+    }
+    return v;
+}
+export function validateLeaseParams(value) {
+    const m = "agent.tab.lease";
+    const o = asObj(value, m);
+    const tabId = asString(o.tabId, m, "tabId");
+    const agentId = asString(o.agentId, m, "agentId");
+    const planId = optString(o.planId, m, "planId");
+    const ttlMs = optNumber(o.ttlMs, m, "ttlMs");
+    return {
+        tabId,
+        agentId,
+        ...(planId !== undefined ? { planId } : {}),
+        ...(ttlMs !== undefined ? { ttlMs } : {}),
+    };
+}
+export function validateReleaseParams(value) {
+    const m = "agent.tab.release";
+    const o = asObj(value, m);
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        agentId: asString(o.agentId, m, "agentId"),
+    };
+}
+export function validateHeartbeatParams(value) {
+    const m = "agent.tab.heartbeat";
+    const o = asObj(value, m);
+    const agentId = asString(o.agentId, m, "agentId");
+    const tabIds = asStringArray(o.tabIds, m, "tabIds");
+    const ttlMs = optNumber(o.ttlMs, m, "ttlMs");
+    return {
+        agentId,
+        tabIds,
+        ...(ttlMs !== undefined ? { ttlMs } : {}),
+    };
+}
+export function validateListParams(value) {
+    if (value === undefined || value === null)
+        return {};
+    const m = "agent.tab.list";
+    const o = asObj(value, m);
+    const agentId = optString(o.agentId, m, "agentId");
+    const planId = optString(o.planId, m, "planId");
+    return {
+        ...(agentId !== undefined ? { agentId } : {}),
+        ...(planId !== undefined ? { planId } : {}),
+    };
+}
+export function validatePlanReleaseParams(value) {
+    const m = "agent.plan.release";
+    const o = asObj(value, m);
+    return { planId: asString(o.planId, m, "planId") };
+}
+export function requireTabIdParams(value, method) {
+    const o = asObj(value, method);
+    return { tabId: asString(o.tabId, method, "tabId") };
+}
+export function validateClickParams(value) {
+    const m = "dom.click";
+    const o = asObj(value, m);
+    const tabId = asString(o.tabId, m, "tabId");
+    const ref = asString(o.ref, m, "ref");
+    const button = optString(o.button, m, "button");
+    if (button !== undefined && button !== "left" && button !== "middle" && button !== "right") {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: button must be 'left' | 'middle' | 'right'`);
+    }
+    const clickCount = optNumber(o.clickCount, m, "clickCount");
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId,
+        ref,
+        ...(button !== undefined ? { button: button } : {}),
+        ...(clickCount !== undefined ? { clickCount } : {}),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateTypeParams(value) {
+    const m = "dom.type";
+    const o = asObj(value, m);
+    const tabId = asString(o.tabId, m, "tabId");
+    const ref = asString(o.ref, m, "ref");
+    if (typeof o.text !== "string") {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: text must be a string`);
+    }
+    const submit = optBoolean(o.submit, m, "submit");
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId,
+        ref,
+        text: o.text,
+        ...(submit !== undefined ? { submit } : {}),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateHoverParams(value) {
+    const m = "dom.hover";
+    const o = asObj(value, m);
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        ref: asString(o.ref, m, "ref"),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validatePressKeyParams(value) {
+    const m = "dom.press_key";
+    const o = asObj(value, m);
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        key: asString(o.key, m, "key"),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateSelectOptionParams(value) {
+    const m = "dom.select_option";
+    const o = asObj(value, m);
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        ref: asString(o.ref, m, "ref"),
+        values: asStringArray(o.values, m, "values"),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateFillFormParams(value) {
+    const m = "dom.fill_form";
+    const o = asObj(value, m);
+    if (!Array.isArray(o.fields)) {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: fields must be an array`);
+    }
+    const fields = o.fields.map((raw, i) => {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: fields[${i}] must be an object`);
+        }
+        const f = raw;
+        return {
+            ref: asString(f.ref, m, `fields[${i}].ref`),
+            value: asString(f.value, m, `fields[${i}].value`),
+        };
+    });
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        fields,
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateDragDropParams(value) {
+    const m = "dom.drag_drop";
+    const o = asObj(value, m);
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        fromRef: asString(o.fromRef, m, "fromRef"),
+        toRef: asString(o.toRef, m, "toRef"),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateFileUploadParams(value) {
+    const m = "dom.file_upload";
+    const o = asObj(value, m);
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        ref: asString(o.ref, m, "ref"),
+        paths: asStringArray(o.paths, m, "paths"),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateHandleDialogParams(value) {
+    const m = "dom.handle_dialog";
+    const o = asObj(value, m);
+    if (typeof o.accept !== "boolean") {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: accept must be a boolean`);
+    }
+    const promptText = optString(o.promptText, m, "promptText");
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        accept: o.accept,
+        ...(promptText !== undefined ? { promptText } : {}),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateWaitForParams(value) {
+    const m = "dom.wait_for";
+    const o = asObj(value, m);
+    if (typeof o.timeoutMs !== "number" || !Number.isFinite(o.timeoutMs)) {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: timeoutMs must be a finite number`);
+    }
+    const cond = asObj(o.condition, `${m}.condition`);
+    let condition;
+    if (cond.type === "expression") {
+        condition = {
+            type: "expression",
+            expr: asString(cond.expr, m, "condition.expr"),
+        };
+    }
+    else if (cond.type === "navigation") {
+        condition = { type: "navigation" };
+    }
+    else {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: condition.type must be 'expression' | 'navigation'`);
+    }
+    const pollIntervalMs = optNumber(o.pollIntervalMs, m, "pollIntervalMs");
+    const agentId = optString(o.agentId, m, "agentId");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        timeoutMs: o.timeoutMs,
+        condition,
+        ...(pollIntervalMs !== undefined ? { pollIntervalMs } : {}),
+        ...(agentId !== undefined ? { agentId } : {}),
+    };
+}
+export function validateScreenshotParams(value) {
+    const m = "dom.screenshot";
+    const o = asObj(value, m);
+    const tabId = asString(o.tabId, m, "tabId");
+    const fullPage = optBoolean(o.fullPage, m, "fullPage");
+    const format = optString(o.format, m, "format");
+    if (format !== undefined && format !== "png" && format !== "jpeg") {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: format must be 'png' | 'jpeg'`);
+    }
+    const quality = optNumber(o.quality, m, "quality");
+    let clip;
+    if (o.clip !== undefined) {
+        const c = asObj(o.clip, `${m}.clip`);
+        if (typeof c.x !== "number" ||
+            typeof c.y !== "number" ||
+            typeof c.width !== "number" ||
+            typeof c.height !== "number") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: clip requires numeric { x, y, width, height }`);
+        }
+        clip = { x: c.x, y: c.y, width: c.width, height: c.height };
+    }
+    return {
+        tabId,
+        ...(fullPage !== undefined ? { fullPage } : {}),
+        ...(clip !== undefined ? { clip } : {}),
+        ...(format !== undefined ? { format: format } : {}),
+        ...(quality !== undefined ? { quality } : {}),
+    };
+}
+export function validateBufferReadParams(value, method) {
+    const o = asObj(value, method);
+    const since = optNumber(o.since, method, "since");
+    return {
+        tabId: asString(o.tabId, method, "tabId"),
+        ...(since !== undefined ? { since } : {}),
+    };
+}
+export function validateEvaluateParams(value) {
+    const m = "js.evaluate";
+    const o = asObj(value, m);
+    const world = asString(o.world, m, "world");
+    if (world !== "main" && world !== "isolated") {
+        throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `${m}: world must be 'main' | 'isolated'`);
+    }
+    const timeoutMs = optNumber(o.timeoutMs, m, "timeoutMs");
+    return {
+        tabId: asString(o.tabId, m, "tabId"),
+        expr: asString(o.expr, m, "expr"),
+        world: world,
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    };
+}

package/electron-host/dist/editable-focus-reporter.js

@@ -0,0 +1,143 @@
+import { hostLog } from "./host-log.js";
+const FOCUS_DEBOUNCE_MS = 80;
+const CDP_PROTOCOL_VERSION = "1.3";
+const BINDING_NAME = "__minionryEditableFocus";
+const INSTALLER_SOURCE = `(() => {
+  if (window.${BINDING_NAME}__installed) return;
+  window.${BINDING_NAME}__installed = true;
+  const isEditable = (el) => {
+    if (!el) return false;
+    const tag = el.tagName;
+    if (tag === 'TEXTAREA' || tag === 'SELECT') return true;
+    if (tag === 'INPUT') {
+      const t = (el.getAttribute('type') || 'text').toLowerCase();
+      // Non-text inputs (button/checkbox/radio/submit/…) don't summon a keyboard.
+      return !['button','checkbox','radio','submit','reset','file','image','range','color'].includes(t);
+    }
+    return el.isContentEditable === true;
+  };
+  const report = () => {
+    try {
+      if (typeof window.${BINDING_NAME} === 'function') {
+        window.${BINDING_NAME}(isEditable(document.activeElement) ? '1' : '0');
+      }
+    } catch (_e) { /* binding not yet available */ }
+  };
+  document.addEventListener('focusin', report, true);
+  document.addEventListener('focusout', () => {
+    // After blur the activeElement settles on the next microtask; defer so we
+    // read the post-blur target (focus moving input->input stays '1').
+    setTimeout(report, 0);
+  }, true);
+  if (window.top === window && document.readyState === 'loading') report();
+})();`;
+const flog = hostLog("focus");
+export class EditableFocusReporter {
+    dbg;
+    onFocusChange;
+    setTimeoutFn;
+    clearTimeoutFn;
+    started = false;
+    disposed = false;
+    lastEmitted = false;
+    debounceTimer = null;
+    onMessage;
+    constructor(options) {
+        this.dbg = options.debugger;
+        this.onFocusChange = options.onFocusChange;
+        this.setTimeoutFn = options.timers?.setTimeout ?? setTimeout;
+        this.clearTimeoutFn = options.timers?.clearTimeout ?? clearTimeout;
+        this.onMessage = (_event, method, params) => this.handleCdpMessage(method, params);
+    }
+    start() {
+        if (this.started || this.disposed)
+            return;
+        this.started = true;
+        try {
+            if (!this.dbg.isAttached()) {
+                this.dbg.attach(CDP_PROTOCOL_VERSION);
+            }
+        }
+        catch (err) {
+            flog("attach_race", errMessage(err));
+        }
+        this.dbg.on("message", this.onMessage);
+        void this.send("Runtime.enable");
+        void this.send("Page.enable");
+        void this.send("Runtime.addBinding", { name: BINDING_NAME });
+        void this.send("Page.addScriptToEvaluateOnNewDocument", {
+            source: INSTALLER_SOURCE,
+        });
+        void this.send("Runtime.evaluate", {
+            expression: INSTALLER_SOURCE,
+            includeCommandLineAPI: false,
+        });
+        flog("start", `binding=${BINDING_NAME}`);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        try {
+            this.dbg.off("message", this.onMessage);
+        }
+        catch (err) {
+            flog("dispose.offFailed", errMessage(err));
+        }
+        if (this.debounceTimer) {
+            this.clearTimeoutFn(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+    }
+    send(method, params) {
+        try {
+            const p = this.dbg.sendCommand(method, params);
+            if (p && typeof p.then === "function") {
+                return p.catch((err) => {
+                    const msg = errMessage(err);
+                    if (/wasn't found|not found|doesn't exist|Unknown method/i.test(msg)) {
+                        console.warn(`[B:focus] cdp.unsupported method=${method} err=${msg}`);
+                    }
+                    flog("cdp.error", `method=${method} err=${msg}`);
+                });
+            }
+            return Promise.resolve(p);
+        }
+        catch (err) {
+            flog("cdp.throw", `method=${method} err=${errMessage(err)}`);
+            return Promise.resolve();
+        }
+    }
+    handleCdpMessage(method, params) {
+        if (this.disposed)
+            return;
+        if (method !== "Runtime.bindingCalled")
+            return;
+        if (params.name !== BINDING_NAME)
+            return;
+        const focused = params.payload === "1";
+        this.scheduleEmit(focused);
+    }
+    scheduleEmit(focused) {
+        if (this.debounceTimer)
+            this.clearTimeoutFn(this.debounceTimer);
+        this.debounceTimer = this.setTimeoutFn(() => {
+            this.debounceTimer = null;
+            if (this.disposed)
+                return;
+            if (this.lastEmitted === focused)
+                return;
+            this.lastEmitted = focused;
+            flog("emit", `focused=${focused}`);
+            try {
+                this.onFocusChange(focused);
+            }
+            catch (err) {
+                flog("emit.callbackThrew", errMessage(err));
+            }
+        }, FOCUS_DEBOUNCE_MS);
+    }
+}
+function errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}