@minionry/minion 0.7.36

package/dist/server/services/browser/host-mock.js

@@ -0,0 +1,334 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { EventEmitter } from 'node:events';
+import { AgentLeaseRegistry, } from '../../../electron-host/agent-lease.js';
+import { DEFAULT_INITIAL_URL, DEFAULT_VIEWPORT, LIFECYCLE_EVENTS, TabInfoCache, } from './host-internal.js';
+export { TabAlreadyLeasedError } from '../../../electron-host/agent-lease.js';
+export class MockBrowserHost extends EventEmitter {
+    state = 'idle';
+    url = null;
+    viewport = null;
+    nextTabId = 1;
+    currentTabId = null;
+    lastCrashReason = null;
+    agentTabAliases = new Map();
+    leaseRegistry;
+    tabInfoCache = new TabInfoCache();
+    calls = {
+        navigateCalls: [],
+        setBoundsCalls: [],
+        setTabDeviceProfileCalls: [],
+        forwardInputCalls: [],
+        signalCalls: [],
+        openTabCalls: [],
+        closeTabCalls: [],
+        switchTabCalls: [],
+        switchViewerTabCalls: [],
+        startCalls: [],
+        stopCalls: 0,
+        restartCalls: 0,
+        recoverCalls: 0,
+        setIceConfigCalls: [],
+        startCaptureCalls: [],
+        closeCaptureForCalls: [],
+        goBackCalls: [],
+        goForwardCalls: [],
+        reloadCalls: [],
+        stopLoadingCalls: [],
+        leaseCalls: [],
+        releaseTabCalls: [],
+        heartbeatCalls: [],
+        listLeasesCalls: [],
+        releasePlanCalls: [],
+        domCalls: [],
+        jsEvaluateCalls: [],
+        sdkDeliverCalls: [],
+    };
+    dom;
+    js;
+    sdk;
+    constructor(options = {}) {
+        super();
+        this.leaseRegistry = new AgentLeaseRegistry({
+            ...(options.nowMs ? { nowMs: options.nowMs } : {}),
+            ...(options.defaultLeaseTtlMs !== undefined
+                ? { defaultTtlMs: options.defaultLeaseTtlMs }
+                : {}),
+            ...(options.leaseGracePeriodMs !== undefined
+                ? { gracePeriodMs: options.leaseGracePeriodMs }
+                : {}),
+        });
+        this.leaseRegistry.on('lease-expired', (event) => {
+            this.emit('leaseExpired', event);
+        });
+        this.dom = this.buildDomSurface();
+        this.js = this.buildJsSurface();
+        this.sdk = this.buildSdkSurface();
+    }
+    emit(event, ...args) {
+        const result = super.emit(event, ...args);
+        if (LIFECYCLE_EVENTS.has(event)) {
+            super.emit('status', this.getStatus());
+        }
+        return result;
+    }
+    async start(opts) {
+        this.calls.startCalls.push(opts);
+        this.state = 'starting';
+        this.viewport = opts.viewport ?? DEFAULT_VIEWPORT;
+        this.url = opts.initialUrl ?? DEFAULT_INITIAL_URL;
+        this.state = 'ready';
+        this.emit('ready');
+    }
+    async stop() {
+        this.calls.stopCalls += 1;
+        this.state = 'stopped';
+        this.emit('stopped');
+    }
+    async restart(opts) {
+        this.calls.restartCalls += 1;
+        this.state = 'restarting';
+        this.emit('restarting');
+        await this.stop();
+        await this.start(opts ?? { orchestraId: 'mock' });
+    }
+    async recover(opts) {
+        this.calls.recoverCalls += 1;
+        if (this.state === 'ready' || this.state === 'starting' || this.state === 'restarting') {
+            return;
+        }
+        this.emit('recovering', { prevAttempts: 0 });
+        await this.start(opts ?? { orchestraId: 'mock' });
+    }
+    async navigate(url, tabId) {
+        this.calls.navigateCalls.push({ url, tabId });
+        this.url = url;
+    }
+    async setBounds(bounds, sessionId) {
+        this.calls.setBoundsCalls.push({ ...bounds, sessionId });
+        this.viewport = { width: bounds.width, height: bounds.height };
+    }
+    async setTabDeviceProfile(tabId, profile) {
+        this.calls.setTabDeviceProfileCalls.push({ tabId, profile });
+        this.tabInfoCache.upsert(tabId, { deviceProfile: profile });
+        this.emitTabs();
+    }
+    async forwardInput(ev, sessionId, tabId) {
+        this.calls.forwardInputCalls.push({ ev, sessionId, ...(tabId ? { tabId } : {}) });
+    }
+    async goBack(tabId) {
+        this.calls.goBackCalls.push(tabId);
+    }
+    async goForward(tabId) {
+        this.calls.goForwardCalls.push(tabId);
+    }
+    async reload(tabId) {
+        this.calls.reloadCalls.push(tabId);
+    }
+    async stopLoading(tabId) {
+        this.calls.stopLoadingCalls.push(tabId);
+    }
+    async signal(envelope) {
+        this.calls.signalCalls.push(envelope);
+    }
+    async setIceConfig(iceServers) {
+        this.calls.setIceConfigCalls.push(iceServers);
+    }
+    async startCapture(sessionId, tabId) {
+        this.calls.startCaptureCalls.push({ sessionId, tabId });
+    }
+    async closeCaptureFor(sessionId) {
+        this.calls.closeCaptureForCalls.push(sessionId);
+    }
+    async openTab(url) {
+        this.calls.openTabCalls.push(url);
+        const id = `mock-tab-${this.nextTabId++}`;
+        this.tabInfoCache.upsert(id, { url, title: '' });
+        this.currentTabId = id;
+        this.emitTabs();
+        return { id };
+    }
+    async closeTab(id) {
+        this.calls.closeTabCalls.push(id);
+        if (!this.tabInfoCache.get(id))
+            return;
+        this.tabInfoCache.delete(id);
+        if (this.currentTabId === id) {
+            const next = this.tabInfoCache.entries()[0]?.id ?? null;
+            this.currentTabId = next;
+        }
+        this.emitTabs();
+    }
+    async switchTab(id) {
+        this.calls.switchTabCalls.push(id);
+        if (this.tabInfoCache.get(id) && this.currentTabId !== id) {
+            this.currentTabId = id;
+            this.emitTabs();
+        }
+    }
+    async switchViewerTab(sessionId, tabId) {
+        this.calls.switchViewerTabCalls.push({ sessionId, tabId });
+    }
+    buildTabsSnapshot() {
+        const entries = this.tabInfoCache.entries();
+        const tabs = entries.map((e) => ({
+            id: e.id,
+            url: e.url,
+            title: e.title,
+            ...(e.faviconUrl !== undefined ? { favicon: e.faviconUrl } : {}),
+            isLoading: false,
+            canGoBack: e.canGoBack ?? false,
+            canGoForward: e.canGoForward ?? false,
+            ...(e.deviceProfile !== undefined ? { deviceProfile: e.deviceProfile } : {}),
+        }));
+        const focused = this.currentTabId && this.tabInfoCache.get(this.currentTabId)
+            ? this.currentTabId
+            : null;
+        return { tabs, currentTabId: focused };
+    }
+    emitTabs() {
+        this.emit('tabs', this.buildTabsSnapshot());
+    }
+    getTabsSnapshot() {
+        return this.buildTabsSnapshot();
+    }
+    resolveAgentTabId(tabId) {
+        if (this.tabInfoCache.get(tabId))
+            return tabId;
+        const aliased = this.agentTabAliases.get(tabId);
+        if (aliased && this.tabInfoCache.get(aliased))
+            return aliased;
+        const current = this.currentTabId;
+        if (current && this.tabInfoCache.get(current)) {
+            this.agentTabAliases.set(tabId, current);
+            return current;
+        }
+        return tabId;
+    }
+    async leaseTab(req) {
+        const tabId = this.resolveAgentTabId(req.tabId);
+        const resolved = tabId === req.tabId ? req : { ...req, tabId };
+        this.calls.leaseCalls.push(resolved);
+        return this.leaseRegistry.lease(resolved);
+    }
+    async releaseTab(req) {
+        const tabId = this.resolveAgentTabId(req.tabId);
+        const resolved = tabId === req.tabId ? req : { ...req, tabId };
+        this.calls.releaseTabCalls.push(resolved);
+        return { released: this.leaseRegistry.release(resolved.tabId, resolved.agentId) };
+    }
+    async heartbeat(req) {
+        const tabIds = req.tabIds.map((id) => this.resolveAgentTabId(id));
+        const resolved = tabIds.some((id, i) => id !== req.tabIds[i]) ? { ...req, tabIds } : req;
+        this.calls.heartbeatCalls.push(resolved);
+        return this.leaseRegistry.heartbeat(resolved);
+    }
+    async listLeases(filter) {
+        this.calls.listLeasesCalls.push(filter);
+        return this.leaseRegistry.list(filter ?? {});
+    }
+    async releasePlan(planId) {
+        this.calls.releasePlanCalls.push(planId);
+        return { released: this.leaseRegistry.releasePlan(planId) };
+    }
+    getTabInfo(tabId) {
+        return this.tabInfoCache.get(tabId);
+    }
+    seedTabInfo(tabId, info) {
+        this.tabInfoCache.upsert(tabId, info);
+    }
+    setScreenshotResult(result) {
+        this.screenshotResult = result;
+    }
+    screenshotResult = { format: 'png', data: '' };
+    buildDomSurface() {
+        const record = (method, args, result) => {
+            const tabId = this.resolveAgentTabId(args.tabId);
+            const resolved = tabId === args.tabId ? args : { ...args, tabId };
+            this.calls.domCalls.push({ method, args: resolved });
+            return Promise.resolve(result);
+        };
+        const snapshotResult = () => ({
+            url: this.url ?? DEFAULT_INITIAL_URL,
+            title: 'mock',
+            epoch: 1,
+            root: { ref: 'e1n0', role: 'WebArea', children: [] },
+        });
+        return {
+            snapshot: (args) => record('snapshot', args, snapshotResult()),
+            click: (args) => record('click', args, undefined),
+            type: (args) => record('type', args, undefined),
+            hover: (args) => record('hover', args, undefined),
+            pressKey: (args) => record('pressKey', args, undefined),
+            selectOption: (args) => record('selectOption', args, undefined),
+            fillForm: (args) => record('fillForm', args, undefined),
+            dragDrop: (args) => record('dragDrop', args, undefined),
+            fileUpload: (args) => record('fileUpload', args, undefined),
+            handleDialog: (args) => record('handleDialog', args, undefined),
+            waitFor: (args) => record('waitFor', args, undefined),
+            screenshot: (args) => record('screenshot', args, this.screenshotResult),
+            console: (args) => record('console', args, []),
+            network: (args) => record('network', args, []),
+        };
+    }
+    buildJsSurface() {
+        return {
+            evaluate: (args) => {
+                const tabId = this.resolveAgentTabId(args.tabId);
+                const resolved = tabId === args.tabId ? args : { ...args, tabId };
+                this.calls.jsEvaluateCalls.push(resolved);
+                const result = { value: undefined, type: 'undefined' };
+                return Promise.resolve(result);
+            },
+        };
+    }
+    buildSdkSurface() {
+        return {
+            deliver: (args) => {
+                this.calls.sdkDeliverCalls.push(args);
+                return Promise.resolve();
+            },
+        };
+    }
+    getStatus() {
+        return {
+            state: this.state,
+            url: this.url,
+            viewport: this.viewport,
+            ...(this.state === 'crashed' && this.lastCrashReason
+                ? { reason: this.lastCrashReason }
+                : {}),
+        };
+    }
+    emitCrashed(info = {}) {
+        const reason = info.reason ?? 'mock crash';
+        this.state = 'crashed';
+        this.lastCrashReason = reason;
+        this.emit('crashed', {
+            code: info.code ?? null,
+            signal: info.signal ?? null,
+            reason,
+        });
+    }
+    emitReady() {
+        this.state = 'ready';
+        this.lastCrashReason = null;
+        this.emit('ready');
+    }
+    emitStopped() {
+        this.state = 'stopped';
+        this.emit('stopped');
+    }
+    emitSignal(envelope) {
+        this.emit('signal', envelope);
+    }
+    emitInputFocus(event) {
+        this.emit('inputFocus', event);
+    }
+    sweepExpiredLeases() {
+        return this.leaseRegistry.sweepExpired();
+    }
+    snapshotLeases(filter = {}) {
+        return this.leaseRegistry.list(filter);
+    }
+}

package/dist/server/services/browser/host-types.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export {};