@minionry/minion 0.7.36

package/dist/server/services/websocket/sdk-browser-host.js

@@ -0,0 +1,459 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { deviceProfileFor } from '@minionry/browser-types';
+import { getBrowserDriverState } from '../browser/driver-state.js';
+import { setSdkBrowserHost } from '../sdk/browser.js';
+import { SdkMethodError } from '../sdk/registry.js';
+import { resolveProposal, startBrowserAgentRun } from './browser-agent-runtime.js';
+import { ensureTurnCredentials, getAppliedIceServers } from './browser-handlers.js';
+import { passThroughInputEnvelope } from './browser-payloads.js';
+import { MAX_HUMAN_SURFACES, viewers } from './browser-viewer-registry.js';
+import { openBrowserCompanionTab } from './sdk-agent-host.js';
+export function installSdkBrowserHost(ctx) {
+    const host = {
+        getTabsSnapshot: () => withOwners(getEmptyOr(ctx, (h) => h.getTabsSnapshot())),
+        subscribeTabs: (cb) => {
+            const browserHost = ctx.getBrowserHost();
+            if (!browserHost)
+                return () => { };
+            const listener = (payload) => cb(withOwners(payload));
+            browserHost.on('tabs', listener);
+            return () => browserHost.off('tabs', listener);
+        },
+        navigate: async ({ url, tabId }) => {
+            await (await ensureReady(ctx)).navigate(url, tabId);
+        },
+        open: async ({ url, reuseOrigin }) => {
+            const live = await ensureReady(ctx);
+            if (reuseOrigin) {
+                const match = live.getTabsSnapshot().tabs.find((t) => sameOrigin(t.url, reuseOrigin));
+                if (match) {
+                    await live.switchTab(match.id);
+                    return { tabId: match.id };
+                }
+            }
+            const tab = await live.openTab(url);
+            return { tabId: tab.id };
+        },
+        close: async ({ tabId }) => {
+            await (await ensureReady(ctx)).closeTab(tabId);
+        },
+        select: async ({ tabId }) => {
+            await (await ensureReady(ctx)).switchTab(tabId);
+        },
+        snapshot: async ({ tabId }) => (await ensureReady(ctx)).dom.snapshot({ tabId }),
+        screenshot: async ({ tabId, fullPage, format, quality }) => (await ensureReady(ctx)).dom.screenshot({
+            tabId,
+            ...(fullPage ? { fullPage: true } : {}),
+            ...(format ? { format } : {}),
+            ...(quality !== undefined ? { quality } : {}),
+        }),
+        evaluate: async ({ tabId, expr, world, timeoutMs }) => (await ensureReady(ctx)).js.evaluate({
+            tabId,
+            expr,
+            world: world ?? 'isolated',
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        }),
+        automate: async ({ task, taskId, engine, model, tabId, workingDir, initiator, onSession, onEvent }) => {
+            const live = await ensureReady(ctx);
+            const companion = initiator ? openCompanionTab(ctx, { workingDir, initiator, task, engine, model }) : null;
+            if (companion)
+                onSession?.({ sessionId: companion.sessionId, name: companion.name });
+            const payload = {
+                task,
+                taskId,
+                engine,
+                ...(model ? { model } : {}),
+                ...(tabId ? { tabId } : {}),
+            };
+            const run = startBrowserAgentRun(live, payload, {
+                emit: (response) => {
+                    const event = toAutomationEvent(response);
+                    if (!event)
+                        return;
+                    mirrorToCompanion(companion, event);
+                    onEvent(event);
+                },
+                broadcastToAll: (response) => ctx.broadcastToAll(response),
+            });
+            return {
+                agentId: run.agentId,
+                approve: (verdict) => resolveProposal(verdict),
+                cancel: () => {
+                    companion?.settle('Task stopped.');
+                    run.cancel();
+                },
+            };
+        },
+        back: async ({ tabId }) => {
+            await (await ensureReady(ctx)).goBack(tabId);
+        },
+        forward: async ({ tabId }) => {
+            await (await ensureReady(ctx)).goForward(tabId);
+        },
+        reload: async ({ tabId }) => {
+            await (await ensureReady(ctx)).reload(tabId);
+        },
+        stop: async ({ tabId }) => {
+            await (await ensureReady(ctx)).stopLoading(tabId);
+        },
+        attachView: (attach) => attachSdkView(ctx, attach),
+        preflight: () => runSdkPreflight(ctx),
+        resumeDriver: async ({ tabId }) => {
+            await ensureReady(ctx);
+            getBrowserDriverState().resume(tabId);
+        },
+        setDeviceProfile: async ({ tabId, formFactor }) => {
+            await (await ensureReady(ctx)).setTabDeviceProfile(tabId, deviceProfileFor(formFactor));
+        },
+    };
+    setSdkBrowserHost(host);
+}
+async function runSdkPreflight(ctx) {
+    const { preflight, toBrowserPreflightPayload } = await import('../browser/preflight.js');
+    let result;
+    try {
+        result = await preflight();
+    }
+    catch (err) {
+        return { ok: false, message: err instanceof Error ? err.message : String(err) };
+    }
+    if (result.checks.some((c) => c.id === 'electron' && !c.ok)) {
+        const { ensureElectronProvisioned } = await import('../browser/electron-provision.js');
+        void ensureElectronProvisioned().catch(() => { });
+        return toBrowserPreflightPayload(result, { chromiumInstalling: true });
+    }
+    const live = ctx.getBrowserHost();
+    if (live && result.ok && live.getStatus().state === 'crashed') {
+        void live.recover().catch(() => {
+        });
+    }
+    return toBrowserPreflightPayload(result, { chromiumInstalling: false });
+}
+function withOwners(payload) {
+    const driverState = getBrowserDriverState();
+    return {
+        currentTabId: payload.currentTabId,
+        tabs: payload.tabs.map((tab) => {
+            const owner = driverState.getOwner(tab.id);
+            if (!owner)
+                return tab;
+            return {
+                ...tab,
+                owner: {
+                    agentId: owner.ownerAgentId,
+                    label: owner.ownerAgentLabel ?? owner.ownerAgentId,
+                    ...(owner.ownerSessionId ? { sessionId: owner.ownerSessionId } : {}),
+                },
+            };
+        }),
+    };
+}
+function openCompanionTab(ctx, args) {
+    try {
+        return openBrowserCompanionTab(ctx, {
+            workingDir: args.workingDir,
+            initiator: args.initiator,
+            task: args.task,
+            engine: args.engine,
+            ...(args.model ? { model: args.model } : {}),
+        });
+    }
+    catch (error) {
+        console.error('[SdkBrowser] companion Agent tab could not be opened:', error);
+        return null;
+    }
+}
+function mirrorToCompanion(companion, event) {
+    if (!companion)
+        return;
+    if (event.kind === 'step') {
+        if (event.phase === 'observe')
+            return;
+        companion.step(event.detail);
+        return;
+    }
+    if (event.kind !== 'done')
+        return;
+    const result = event.result?.trim();
+    if (event.status === 'success') {
+        companion.settle(result || 'Task complete.');
+        return;
+    }
+    if (event.status === 'cancelled') {
+        companion.settle(result ? `Stopped — ${result}` : 'Task stopped.');
+        return;
+    }
+    companion.settle(`Task failed${event.error ? ` — ${event.error}` : ''}.`, true);
+}
+async function attachSdkView(ctx, attach) {
+    const live = await ensureReady(ctx);
+    const tabId = attach.tabId ?? live.getTabsSnapshot().currentTabId;
+    if (!tabId) {
+        throw new SdkMethodError('BAD_REQUEST', 'browser.view.attach: no tabId supplied and no tab is open');
+    }
+    if (!viewers.getByViewer(attach.viewerKey) && viewers.size() >= MAX_HUMAN_SURFACES) {
+        throw new SdkMethodError('QUOTA_EXCEEDED', `browser.view.attach: viewer limit reached (max ${MAX_HUMAN_SURFACES} live views per Space) — detach an existing view first`);
+    }
+    let active = true;
+    const emit = (event) => {
+        if (!active)
+            return;
+        attach.onEvent(event);
+    };
+    const viewer = viewers.attachSdk({
+        key: attach.viewerKey,
+        tabId,
+        ...(attach.ownerViewerId ? { ownerViewerId: attach.ownerViewerId } : {}),
+        sink: (event) => {
+            if (event.kind === 'signal') {
+                const translated = toViewSignalEvent(event.envelope);
+                if (translated)
+                    emit(translated);
+                return;
+            }
+            if (event.kind === 'inputFocus') {
+                emit({ kind: 'inputFocus', focused: event.focused });
+                return;
+            }
+            emit({ kind: 'closed', reason: event.reason });
+            active = false;
+        },
+    });
+    const driverState = getBrowserDriverState();
+    const onDriverChange = (payload) => {
+        if (payload.tabId !== viewer.tabId)
+            return;
+        emit({ kind: 'driverState', snapshot: toDriverSnapshot(payload) });
+    };
+    driverState.on('change', onDriverChange);
+    let lastNav = '';
+    const onTabs = (payload) => {
+        const tab = payload.tabs.find((candidate) => candidate.id === viewer.tabId);
+        if (!tab)
+            return;
+        const event = toNavigationEvent(tab);
+        const key = `${tab.url}|${tab.title}|${tab.isLoading}|${tab.canGoBack}|${tab.canGoForward}`;
+        if (key === lastNav)
+            return;
+        lastNav = key;
+        emit(event);
+    };
+    live.on('tabs', onTabs);
+    const release = () => {
+        if (!active)
+            return;
+        active = false;
+        driverState.off('change', onDriverChange);
+        live.off('tabs', onTabs);
+        viewers.detach(viewer.sessionId);
+        driverState.releaseHeldInput(viewer.tabId);
+        void live.closeCaptureFor(viewer.sessionId).catch(() => {
+        });
+    };
+    if (attach.bounds) {
+        await live.setBounds({ x: attach.bounds.x ?? 0, y: attach.bounds.y ?? 0, ...attach.bounds }, viewer.sessionId);
+    }
+    await ensureTurnCredentials(live);
+    try {
+        await live.startCapture(viewer.sessionId, viewer.tabId);
+    }
+    catch (err) {
+        release();
+        throw new SdkMethodError('INTERNAL', err instanceof Error ? err.message : String(err));
+    }
+    return {
+        sessionId: viewer.sessionId,
+        tabId: viewer.tabId,
+        answer: async (sdp) => {
+            await live.signal({ kind: 'answer', sessionId: viewer.sessionId, sdp });
+        },
+        ice: async (candidate) => {
+            await live.signal({ kind: 'ice', sessionId: viewer.sessionId, candidate });
+        },
+        state: async (state, reason) => {
+            await live.signal({
+                kind: 'state',
+                sessionId: viewer.sessionId,
+                state,
+                ...(reason !== undefined ? { reason } : {}),
+            });
+        },
+        input: (envelopes) => forwardSdkInput(live, viewer.sessionId, viewer.tabId, envelopes),
+        bounds: async (bounds) => {
+            await live.setBounds({ x: bounds.x ?? 0, y: bounds.y ?? 0, ...bounds }, viewer.sessionId);
+        },
+        detach: release,
+    };
+}
+async function forwardSdkInput(live, sessionId, tabId, envelopes) {
+    const validated = [];
+    for (const raw of envelopes) {
+        const envelope = passThroughInputEnvelope(raw);
+        if (!envelope) {
+            return { delivered: false, reason: 'malformed', inputKind: 'unknown', message: 'invalid input envelope' };
+        }
+        validated.push(envelope);
+    }
+    const driverState = getBrowserDriverState();
+    for (const envelope of validated) {
+        const kind = envelope.kind;
+        try {
+            await live.forwardInput(envelope, sessionId);
+        }
+        catch (err) {
+            return {
+                delivered: false,
+                reason: 'host_not_ready',
+                inputKind: kind,
+                message: err instanceof Error ? err.message : String(err),
+            };
+        }
+        if (live.getTabInfo(tabId))
+            driverState.recordViewInput(tabId, envelope);
+    }
+    return { delivered: true };
+}
+function toViewSignalEvent(envelope) {
+    switch (envelope.kind) {
+        case 'offer': {
+            const iceServers = getAppliedIceServers();
+            return {
+                kind: 'offer',
+                sdp: envelope.sdp,
+                ...(iceServers && iceServers.length > 0 ? { iceServers } : {}),
+            };
+        }
+        case 'ice':
+            return { kind: 'ice', candidate: envelope.candidate };
+        case 'state':
+            return {
+                kind: 'connectionState',
+                state: envelope.state,
+                ...(envelope.reason !== undefined ? { reason: envelope.reason } : {}),
+            };
+        default:
+            return null;
+    }
+}
+function toNavigationEvent(tab) {
+    return {
+        kind: 'navigationState',
+        tabId: tab.id,
+        url: tab.url,
+        title: tab.title,
+        isLoading: tab.isLoading,
+        canGoBack: tab.canGoBack,
+        canGoForward: tab.canGoForward,
+    };
+}
+function toDriverSnapshot(payload) {
+    return {
+        tabId: payload.tabId,
+        state: payload.state,
+        since: payload.since,
+        ...(payload.mode !== undefined ? { mode: payload.mode } : {}),
+        ...(payload.pendingResume !== undefined ? { pendingResume: payload.pendingResume } : {}),
+        ...(payload.parkedReason !== undefined ? { parkedReason: payload.parkedReason } : {}),
+        ...(payload.lastInputAt !== undefined ? { lastInputAt: payload.lastInputAt } : {}),
+        ...(payload.lastInputActor !== undefined ? { lastInputActor: payload.lastInputActor } : {}),
+        ...(payload.ownerAgentId !== undefined ? { ownerAgentId: payload.ownerAgentId } : {}),
+        ...(payload.ownerAgentLabel !== undefined ? { ownerAgentLabel: payload.ownerAgentLabel } : {}),
+    };
+}
+function toAutomationEvent(response) {
+    const frame = response;
+    switch (frame.type) {
+        case 'browser_agent_proposed': {
+            const data = frame.data;
+            return { kind: 'proposed', proposalId: data.proposalId, summary: data.summary };
+        }
+        case 'browser_agent_step': {
+            const data = frame.data;
+            return {
+                kind: 'step',
+                phase: data.phase,
+                detail: data.detail,
+                ...(data.proposalId ? { proposalId: data.proposalId } : {}),
+                ...(data.engine ? { engine: data.engine } : {}),
+                ...(data.model ? { model: data.model } : {}),
+            };
+        }
+        case 'browser_agent_done': {
+            const data = frame.data;
+            return {
+                kind: 'done',
+                status: data.status,
+                ...(data.result !== undefined ? { result: data.result } : {}),
+                ...(data.error !== undefined ? { error: data.error } : {}),
+            };
+        }
+        default:
+            return null;
+    }
+}
+function getEmptyOr(ctx, read) {
+    const host = ctx.getBrowserHost();
+    return host ? read(host) : { tabs: [], currentTabId: null };
+}
+const startInFlight = new WeakMap();
+async function ensureReady(ctx) {
+    const host = ctx.getBrowserHost();
+    if (!host) {
+        throw new SdkMethodError('INTERNAL', 'the browser is not running — start the Browser view first');
+    }
+    if (host.getStatus().state === 'ready')
+        return host;
+    let attempt = startInFlight.get(host);
+    let owner = false;
+    if (!attempt) {
+        const state = host.getStatus().state;
+        if (state === 'ready')
+            return host;
+        attempt = attemptStart(host, state);
+        startInFlight.set(host, attempt);
+        owner = true;
+    }
+    try {
+        await attempt;
+    }
+    catch (err) {
+        if (err instanceof SdkMethodError)
+            throw err;
+        throw new SdkMethodError('BROWSER_HOST_FAILED', err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        if (owner && startInFlight.get(host) === attempt)
+            startInFlight.delete(host);
+    }
+    const finalState = host.getStatus().state;
+    if (finalState !== 'ready') {
+        throw new SdkMethodError('BROWSER_HOST_FAILED', `the browser did not become ready (state=${finalState}); please retry`);
+    }
+    return host;
+}
+async function attemptStart(host, state) {
+    if (state !== 'starting') {
+        const { preflight } = await import('../browser/preflight.js');
+        const result = await preflight();
+        const blocker = result.checks.find((c) => !c.ok && !c.advisory);
+        if (blocker) {
+            const fix = blocker.fixCommands.length > 0 ? blocker.fixCommands.join(' && ') : 'see the Browser view setup instructions';
+            throw new SdkMethodError('BROWSER_NOT_PROVISIONED', `the browser cannot start — ${blocker.label} is missing (${blocker.reason ?? 'unmet dependency'}). Fix: ${fix}`);
+        }
+    }
+    if (state === 'crashed') {
+        await host.recover();
+    }
+    else {
+        await host.start({ orchestraId: 'default' });
+    }
+}
+function sameOrigin(tabUrl, origin) {
+    try {
+        return new URL(tabUrl).origin === origin;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/server/services/websocket/sdk-composer-host.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { setSdkComposerHost } from '../sdk/composer.js';
+export function installSdkComposerHost(ctx) {
+    const host = {
+        autocomplete: (workingDir, query) => ctx.autocompleteService.complete(query, workingDir, { sandboxed: true }).then((r) => r.completions),
+        snippets: () => ctx.snippetRegistry?.list() ?? [],
+    };
+    setSdkComposerHost(host);
+}

package/dist/server/services/websocket/sdk-git-host.js

@@ -0,0 +1,115 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { join } from 'node:path';
+import { setSdkGitHost } from '../sdk/git.js';
+import { hasScopeBinding, resolveScopeDir, scopeRepoPath, scopeWorktreePath, setScopeWorktree } from './handler-context.js';
+import { restoreWorktreeFromRegistry } from './session-handlers.js';
+const branchListeners = new Set();
+const worktreeListeners = new Set();
+const commitSuggestionListeners = new Set();
+export function notifySdkGitBranchChanged(worktreePath, branch) {
+    for (const listener of [...branchListeners]) {
+        try {
+            listener({ worktreePath, branch });
+        }
+        catch {
+        }
+    }
+    notifySdkGitWorktreesChanged();
+}
+export function notifySdkGitWorktreesChanged() {
+    for (const listener of [...worktreeListeners]) {
+        try {
+            listener();
+        }
+        catch {
+        }
+    }
+}
+export function notifySdkGitCommitSuggestion(suggestion) {
+    for (const listener of [...commitSuggestionListeners]) {
+        try {
+            listener(suggestion);
+        }
+        catch {
+        }
+    }
+}
+export function resetSdkGitNotifications() {
+    branchListeners.clear();
+    worktreeListeners.clear();
+    commitSuggestionListeners.clear();
+}
+export function installSdkGitHost(ctx) {
+    const hydrate = (tabId, workingDir) => {
+        if (!hasScopeBinding(ctx, tabId)) {
+            restoreWorktreeFromRegistry(ctx, ctx.getRegistry(workingDir), tabId);
+        }
+    };
+    const host = {
+        activeGitDir: (tabId, workingDir) => {
+            hydrate(tabId, workingDir);
+            return resolveScopeDir(ctx, tabId, workingDir);
+        },
+        activeWorktreePath: (tabId, workingDir) => {
+            hydrate(tabId, workingDir);
+            return scopeWorktreePath(ctx, tabId) ?? null;
+        },
+        repoDir: (tabId, workingDir) => {
+            hydrate(tabId, workingDir);
+            return scopeRepoPath(ctx, tabId) ?? workingDir;
+        },
+        subscribeBranchChanged: (cb) => {
+            branchListeners.add(cb);
+            return () => branchListeners.delete(cb);
+        },
+        subscribeWorktreesChanged: (cb) => {
+            worktreeListeners.add(cb);
+            return () => worktreeListeners.delete(cb);
+        },
+        subscribeCommitSuggestion: (cb) => {
+            commitSuggestionListeners.add(cb);
+            return () => commitSuggestionListeners.delete(cb);
+        },
+        commitSuggestionForStatus: (dir, headSha, porcelainStatus) => ctx.commitSuggestions?.getSuggestionForStatus(dir, headSha, porcelainStatus) ?? null,
+        setActiveWorktree: (tabId, workingDir, worktreePath, branch) => {
+            const registry = ctx.getRegistry(workingDir);
+            if (worktreePath === null) {
+                setScopeWorktree(ctx, tabId, null);
+                ctx.gitBranches.delete(tabId);
+                registry.updateTabWorktree(tabId, null, null);
+                ctx.broadcastToAll({
+                    type: 'tabWorktreeSwitched',
+                    tabId,
+                    data: { tabId, worktreePath: null, branch: null, repoPath: scopeRepoPath(ctx, tabId) ?? null },
+                });
+                return;
+            }
+            setScopeWorktree(ctx, tabId, worktreePath);
+            if (branch)
+                ctx.gitBranches.set(tabId, branch);
+            else
+                ctx.gitBranches.delete(tabId);
+            registry.updateTabWorktree(tabId, worktreePath, branch);
+            ctx.broadcastToAll({
+                type: 'tabWorktreeSwitched',
+                tabId,
+                data: { tabId, worktreePath, branch: branch ?? null, repoPath: scopeRepoPath(ctx, tabId) ?? null },
+            });
+        },
+        releaseWorktreeReferences: (worktreePath, workingDir) => {
+            const resolved = join(worktreePath);
+            const registry = ctx.getRegistry(workingDir);
+            for (const [tid, scope] of ctx.gitScopes) {
+                if (scope.worktreePath === resolved || scope.worktreePath === worktreePath) {
+                    setScopeWorktree(ctx, tid, null);
+                    ctx.gitBranches.delete(tid);
+                    registry.updateTabWorktree(tid, null, null);
+                }
+            }
+        },
+        worktreesMutated: () => notifySdkGitWorktreesChanged(),
+    };
+    setSdkGitHost(host);
+    return host;
+}