@minionry/minion 0.7.36

package/electron-host/dist/viewer-session.js

@@ -0,0 +1,288 @@
+import { hostLog, shortId } from './host-log.js';
+import { reorderH264First } from './sdp.js';
+import { isIpv6Candidate, isMdnsHostCandidate } from './webrtc-ice-filter.js';
+import { createPeerConnection, extractSelectedCandidateType } from './webrtc-peer.js';
+const log = hostLog('ctrl');
+export const MAX_ICE_RESTARTS = 3;
+export const DISCONNECTED_GRACE_MS = 5_000;
+export class ViewerSession {
+    sessionId;
+    activeTabId = null;
+    peer;
+    sink;
+    selectedCandidateType;
+    timers;
+    negotiator = 'ready';
+    streamsAssociated = false;
+    pendingRemoteIce = [];
+    lastReportedState = null;
+    iceRestartAttempts = 0;
+    disconnectedTimer = null;
+    closed = false;
+    constructor(deps) {
+        this.sessionId = deps.sessionId;
+        this.sink = deps.sink;
+        this.selectedCandidateType = deps.selectedCandidateType ?? extractSelectedCandidateType;
+        this.timers = deps.timers ?? { setTimeout, clearTimeout };
+        this.peer = (deps.createPeer ?? createPeerConnection)(deps.rtcConfig);
+        this.wirePeerEvents();
+    }
+    arm(tabId) {
+        this.activeTabId = tabId;
+        this.iceRestartAttempts = 0;
+        this.reportState('negotiating');
+    }
+    async attachStream(stream) {
+        await this.replaceSenderTrack(this.peer.videoSender, stream.getVideoTracks()[0] ?? null, 'video');
+        await this.replaceSenderTrack(this.peer.audioSender, stream.getAudioTracks()[0] ?? null, 'audio');
+        if (this.streamsAssociated)
+            return;
+        try {
+            this.peer.videoSender.setStreams?.(stream);
+            this.peer.audioSender.setStreams?.(stream);
+            this.streamsAssociated = true;
+        }
+        catch (err) {
+            this.reportError('set_streams_failed', `setStreams failed: ${messageOf(err)}`);
+        }
+    }
+    detachTracks() {
+        void this.replaceSenderTrack(this.peer.videoSender, null, 'video');
+        void this.replaceSenderTrack(this.peer.audioSender, null, 'audio');
+    }
+    hasLiveVideo() {
+        return this.peer.videoSender.track?.readyState === 'live';
+    }
+    hasOffered() {
+        return this.peer.pc.localDescription !== null;
+    }
+    async offerAfter(setup) {
+        this.negotiator = 'suspended';
+        try {
+            await setup();
+        }
+        finally {
+            if (this.negotiator === 'suspended')
+                this.negotiator = 'ready';
+        }
+        await this.negotiate();
+    }
+    async negotiate() {
+        const pc = this.peer.pc;
+        const skip = this.negotiator !== 'ready' ? this.negotiator : pc.signalingState !== 'stable' ? `signalingState=${pc.signalingState}` : null;
+        if (skip !== null) {
+            log('startNegotiation.skip', `session=${shortId(this.sessionId)} reason=${skip}`);
+            return;
+        }
+        this.negotiator = 'offering';
+        try {
+            await this.setLocalOffer();
+            const sdp = pc.localDescription?.sdp;
+            if (!sdp || this.closed)
+                return;
+            log.info('startNegotiation.emit', `session=${shortId(this.sessionId)} sdpLen=${sdp.length} iceRestart=${this.iceRestartAttempts > 0}`);
+            this.sink.offer({ sessionId: this.sessionId, sdp, sdpType: 'offer' });
+        }
+        catch (err) {
+            if (!this.closed)
+                this.reportError('offer_failed', `createOffer/setLocalDescription failed: ${messageOf(err)}`);
+        }
+        finally {
+            if (this.negotiator === 'offering')
+                this.negotiator = 'ready';
+        }
+    }
+    async setLocalOffer() {
+        const pc = this.peer.pc;
+        if (this.peer.codecPolicyApplied) {
+            await pc.setLocalDescription();
+            return;
+        }
+        const offer = await pc.createOffer();
+        if (this.closed)
+            return;
+        await pc.setLocalDescription(offer.sdp ? { type: offer.type, sdp: reorderH264First(offer.sdp) } : offer);
+    }
+    async applyAnswer(sdp) {
+        const pc = this.peer.pc;
+        log.info('remoteAnswer', `session=${shortId(this.sessionId)} sdpLen=${sdp.length} signalingState=${pc.signalingState}`);
+        if (pc.signalingState !== 'have-local-offer') {
+            log.info('remoteAnswer.drop', `session=${shortId(this.sessionId)} reason=signalingState=${pc.signalingState}`);
+            return;
+        }
+        try {
+            await pc.setRemoteDescription({ type: 'answer', sdp });
+        }
+        catch (err) {
+            this.reportError('set_remote_answer_failed', `setRemoteDescription(answer) failed: ${messageOf(err)}`);
+            return;
+        }
+        const pending = this.pendingRemoteIce;
+        this.pendingRemoteIce = [];
+        for (const candidate of pending)
+            await this.applyRemoteIce(candidate);
+    }
+    async addRemoteIce(candidate) {
+        if (isMdnsHostCandidate(candidate) || isIpv6Candidate(candidate)) {
+            log('remoteIce.skip', `session=${shortId(this.sessionId)} unusable=${isMdnsHostCandidate(candidate) ? 'mdns' : 'ipv6'}`);
+            return;
+        }
+        if (!this.peer.pc.remoteDescription) {
+            this.pendingRemoteIce.push(candidate);
+            return;
+        }
+        await this.applyRemoteIce(candidate);
+    }
+    async applyRemoteIce(candidate) {
+        try {
+            await this.peer.pc.addIceCandidate(candidate ?? undefined);
+        }
+        catch (err) {
+            const message = messageOf(err);
+            if (message && !/state/i.test(message))
+                this.reportError('add_ice_failed', `addIceCandidate failed: ${message}`);
+        }
+    }
+    setRtcConfig(rtcConfig) {
+        try {
+            this.peer.pc.setConfiguration(rtcConfig);
+        }
+        catch (err) {
+            this.reportError('set_configuration_failed', `setConfiguration failed: ${messageOf(err)}`);
+        }
+    }
+    reportState(state, extra = {}) {
+        const repeat = this.lastReportedState === state && !extra.reason && !extra.selectedCandidateType;
+        if (repeat)
+            return;
+        this.lastReportedState = state;
+        this.sink.state({
+            sessionId: this.sessionId,
+            state,
+            ...(extra.selectedCandidateType !== undefined ? { selectedCandidateType: extra.selectedCandidateType } : {}),
+            ...(extra.reason !== undefined ? { reason: extra.reason } : {}),
+        });
+    }
+    reportError(code, message) {
+        this.sink.error({ sessionId: this.sessionId, message, code });
+    }
+    close(reason) {
+        if (this.closed)
+            return;
+        this.reportState('closed', { reason });
+        this.closed = true;
+        this.clearDisconnectedTimer();
+        this.activeTabId = null;
+        this.pendingRemoteIce = [];
+        this.peer.videoSender.replaceTrack(null).catch(() => undefined);
+        this.peer.audioSender.replaceTrack(null).catch(() => undefined);
+        try {
+            this.peer.pc.close();
+        }
+        catch {
+        }
+    }
+    wirePeerEvents() {
+        const pc = this.peer.pc;
+        pc.addEventListener('icecandidate', (event) => this.onLocalCandidate(event.candidate));
+        pc.addEventListener('negotiationneeded', () => {
+            log('pc.negotiationneeded', `session=${shortId(this.sessionId)} signalingState=${pc.signalingState}`);
+            void this.negotiate();
+        });
+        pc.addEventListener('connectionstatechange', () => this.onConnectionState(pc.connectionState));
+        pc.addEventListener('iceconnectionstatechange', () => {
+            log('pc.iceConnectionState', `session=${shortId(this.sessionId)} state=${pc.iceConnectionState}`);
+        });
+        pc.addEventListener('signalingstatechange', () => {
+            log('pc.signalingState', `session=${shortId(this.sessionId)} state=${pc.signalingState}`);
+        });
+    }
+    onLocalCandidate(candidate) {
+        const init = candidate ? candidate.toJSON() : null;
+        if (init && isIpv6Candidate(init)) {
+            log('icecandidate.skipIpv6', `session=${shortId(this.sessionId)}`);
+            return;
+        }
+        this.sink.ice({ sessionId: this.sessionId, candidate: init });
+    }
+    onConnectionState(state) {
+        if (state !== 'disconnected')
+            this.clearDisconnectedTimer();
+        switch (state) {
+            case 'new':
+            case 'connecting':
+                this.reportState('negotiating');
+                return;
+            case 'disconnected':
+                this.reportState('negotiating');
+                this.armDisconnectedTimer();
+                return;
+            case 'connected':
+                this.iceRestartAttempts = 0;
+                this.reportState('connected');
+                void this.reportSelectedPath();
+                return;
+            case 'failed':
+                this.reportState('failed', this.peer.pc.iceConnectionState === 'failed' ? { reason: 'ice_failed' } : {});
+                this.restartIce();
+                return;
+            case 'closed':
+                this.reportState('closed');
+                return;
+        }
+    }
+    async reportSelectedPath() {
+        let selected;
+        try {
+            selected = await this.selectedCandidateType(this.peer.pc);
+        }
+        catch {
+            return;
+        }
+        if (this.closed || this.peer.pc.connectionState !== 'connected' || selected === null)
+            return;
+        this.reportState('connected', { selectedCandidateType: selected });
+    }
+    armDisconnectedTimer() {
+        if (this.disconnectedTimer !== null)
+            return;
+        this.disconnectedTimer = this.timers.setTimeout(() => {
+            this.disconnectedTimer = null;
+            if (this.closed || this.peer.pc.connectionState !== 'disconnected')
+                return;
+            log.info('disconnected.restartIce', `session=${shortId(this.sessionId)} after=${DISCONNECTED_GRACE_MS}ms`);
+            this.restartIce();
+        }, DISCONNECTED_GRACE_MS);
+    }
+    clearDisconnectedTimer() {
+        if (this.disconnectedTimer === null)
+            return;
+        this.timers.clearTimeout(this.disconnectedTimer);
+        this.disconnectedTimer = null;
+    }
+    restartIce() {
+        if (this.iceRestartAttempts >= MAX_ICE_RESTARTS) {
+            this.reportError('ice_restart_budget_exhausted', `ICE restart budget exhausted (${MAX_ICE_RESTARTS} attempts)`);
+            return;
+        }
+        this.iceRestartAttempts += 1;
+        try {
+            this.peer.pc.restartIce();
+        }
+        catch (err) {
+            this.reportError('ice_restart_failed', `restartIce failed: ${messageOf(err)}`);
+        }
+    }
+    async replaceSenderTrack(sender, track, kind) {
+        try {
+            await sender.replaceTrack(track);
+        }
+        catch (err) {
+            if (!this.closed)
+                this.reportError('replace_track_failed', `${kind} replaceTrack failed: ${messageOf(err)}`);
+        }
+    }
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/electron-host/dist/webrtc-channels.js

@@ -0,0 +1,14 @@
+export const CH_SET_ICE_CONFIG = 'minionry:webrtc:set-ice-config';
+export const CH_START_SESSION = 'minionry:webrtc:start-session';
+export const CH_REMOTE_ANSWER = 'minionry:webrtc:remote-answer';
+export const CH_REMOTE_ICE = 'minionry:webrtc:remote-ice';
+export const CH_CLOSE_VIEWER = 'minionry:webrtc:close-viewer';
+export const CH_CLOSE_SESSION = 'minionry:webrtc:close-session';
+export const CH_LOCAL_OFFER = 'minionry:webrtc:local-offer';
+export const CH_LOCAL_ICE = 'minionry:webrtc:local-ice';
+export const CH_CONNECTION_STATE = 'minionry:webrtc:connection-state';
+export const CH_ERROR = 'minionry:webrtc:error';
+export const CH_REFRESH_CAPTURE = 'minionry:webrtc:refresh-capture';
+export const CH_SWITCH_VIEWER_TAB = 'minionry:webrtc:switch-viewer-tab';
+export const CH_ARM_DISPLAY_MEDIA = 'minionry:webrtc:arm-display-media';
+export const CH_EVICT_SESSION_CAPTURE = 'minionry:webrtc:evict-session-capture';

package/electron-host/dist/webrtc-controller.js

@@ -0,0 +1,57 @@
+import { CaptureRecovery } from './capture-recovery.js';
+import { CONTROLLER_HANDLERS, dispatchControllerMessage } from './controller-handlers.js';
+import { hostLog } from './host-log.js';
+import { ScreenCaptureCache } from './screen-capture-cache.js';
+import { ViewerRegistry } from './viewer-registry.js';
+import { CH_ARM_DISPLAY_MEDIA, CH_CONNECTION_STATE, CH_ERROR, CH_LOCAL_ICE, CH_LOCAL_OFFER, } from './webrtc-channels.js';
+import { BASE_RTC_CONFIG } from './webrtc-peer.js';
+const log = hostLog('ctrl');
+function resolveIpcRenderer() {
+    const found = window.__minionryIpcRenderer;
+    if (!found) {
+        throw new Error('[webrtc-controller] window.__minionryIpcRenderer is missing — the preload script must run before this module');
+    }
+    return found;
+}
+function bootstrap() {
+    const ipcRenderer = resolveIpcRenderer();
+    const send = (channel, payload) => {
+        try {
+            ipcRenderer.send(channel, payload);
+        }
+        catch {
+        }
+    };
+    const sink = {
+        offer: (payload) => send(CH_LOCAL_OFFER, payload),
+        ice: (payload) => send(CH_LOCAL_ICE, payload),
+        state: (payload) => send(CH_CONNECTION_STATE, payload),
+        error: (payload) => send(CH_ERROR, payload),
+    };
+    const captureCache = new ScreenCaptureCache({
+        onTrackEnded: (sessionId, tabId) => recovery.onTrackEnded(sessionId, tabId),
+        armDisplayMedia: async (sessionId, tabId) => {
+            await ipcRenderer.invoke(CH_ARM_DISPLAY_MEDIA, { sessionId, tabId });
+        },
+        getDisplayMedia: (constraints) => navigator.mediaDevices.getDisplayMedia(constraints),
+        log: (event, detail) => (event === 'capture.audioUnavailable' ? log.info : log)(event, detail),
+    });
+    const registry = new ViewerRegistry({
+        rtcConfig: BASE_RTC_CONFIG,
+        sink,
+        onDestroy: (sessionId) => recovery.cancel(sessionId),
+    });
+    const recovery = new CaptureRecovery({
+        sessions: registry,
+        refresh: (sessionId, tabId) => captureCache.refresh(sessionId, tabId),
+    });
+    const ctx = { registry, captureCache, recovery, sink };
+    for (const channel of Object.keys(CONTROLLER_HANDLERS)) {
+        ipcRenderer.on(channel, (_event, payload) => void dispatchControllerMessage(ctx, channel, payload));
+    }
+    window.addEventListener('beforeunload', () => {
+        registry.destroyAll('controller_unload');
+        captureCache.clear();
+    });
+}
+bootstrap();

package/electron-host/dist/webrtc-ice-filter.js

@@ -0,0 +1,13 @@
+export function isMdnsHostCandidate(candidate) {
+    if (!candidate?.candidate)
+        return false;
+    return /\s\S+\.local(?:\s|$)/i.test(candidate.candidate);
+}
+export function isIpv6Candidate(candidate) {
+    if (!candidate?.candidate)
+        return false;
+    const parts = candidate.candidate.split(/\s+/);
+    if (parts.length > 4 && parts[4].includes(':'))
+        return true;
+    return false;
+}

package/electron-host/dist/webrtc-peer.js

@@ -0,0 +1,45 @@
+import { applyScreenEncodingPolicy, applyVideoCodecPolicy } from './codec-policy.js';
+export const BASE_RTC_CONFIG = {
+    iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+    bundlePolicy: 'max-bundle',
+    rtcpMuxPolicy: 'require',
+};
+export function normalizeTabId(tabId) {
+    return typeof tabId === 'string' ? tabId : String(tabId);
+}
+export function createPeerConnection(rtcConfig) {
+    const pc = new RTCPeerConnection(rtcConfig);
+    const videoTransceiver = pc.addTransceiver('video', { direction: 'sendonly' });
+    const audioTransceiver = pc.addTransceiver('audio', { direction: 'sendonly' });
+    const codecPolicyApplied = applyVideoCodecPolicy(videoTransceiver, RTCRtpSender.getCapabilities?.('video'));
+    applyScreenEncodingPolicy(videoTransceiver.sender);
+    return {
+        pc,
+        videoSender: videoTransceiver.sender,
+        audioSender: audioTransceiver.sender,
+        codecPolicyApplied,
+    };
+}
+function reportsOfType(stats, type) {
+    const found = [];
+    stats.forEach((report) => {
+        if (report.type === type)
+            found.push(report);
+    });
+    return found;
+}
+function selectedPair(stats) {
+    const pairId = reportsOfType(stats, 'transport').find((t) => t.selectedCandidatePairId)
+        ?.selectedCandidatePairId;
+    if (pairId)
+        return stats.get(pairId);
+    return reportsOfType(stats, 'candidate-pair').find((pair) => pair.selected === true && pair.state === 'succeeded');
+}
+export async function extractSelectedCandidateType(pc) {
+    const stats = await pc.getStats();
+    const localId = selectedPair(stats)?.localCandidateId;
+    if (!localId)
+        return null;
+    const type = stats.get(localId)?.candidateType;
+    return type === 'host' || type === 'srflx' || type === 'prflx' || type === 'relay' ? type : null;
+}

package/electron-host/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "minionry-electron-host",
+  "version": "0.0.0",
+  "private": true,
+  "license": "UNLICENSED",
+  "description": "Internal component of the Minionry CLI.",
+  "type": "module",
+  "main": "dist/main.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}

package/electron-host/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "types": ["node"],
+    "skipLibCheck": true,
+    "moduleDetection": "force",
+    "outDir": "dist",
+    "rootDir": ".",
+    "declaration": false,
+    "sourceMap": true,
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "isolatedModules": true
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/electron-host/webrtc-controller-preload.cjs

@@ -0,0 +1,3 @@
+const { ipcRenderer } = require('electron');
+
+window.__minionryIpcRenderer = ipcRenderer;

package/electron-host/webrtc-controller.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; script-src 'self'; style-src 'self'; connect-src 'self' ws: wss:; media-src 'self' blob: mediastream:; img-src 'self' data: blob:;"
+    />
+    <title>minionry webrtc-controller</title>
+  </head>
+  <body>
+    <script type="module" src="./dist/webrtc-controller.js"></script>
+  </body>
+</html>

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@minionry/minion",
+  "version": "0.7.36",
+  "description": "Command-line client that connects this machine to Minionry.",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "engines": {
+    "node": "^20.20.0 || >=22.22.0"
+  },
+  "bin": {
+    "minion": "./bin/minion.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "vendor/",
+    "electron-host/",
+    "!electron-host/fixtures/",
+    "!electron-host/__snapshots__/",
+    "!electron-host/**/*.ts",
+    "!electron-host/core",
+    "!electron-host/core.[0-9]*",
+    "!electron-host/*.core",
+    "electron-host/core/",
+    "!dist/electron-host/core",
+    "!dist/electron-host/core.[0-9]*",
+    "!dist/electron-host/*.core",
+    "dist/electron-host/core/",
+    "PRIVACY.md",
+    "THIRD_PARTY_NOTICES.md",
+    "!**/README.md",
+    "!**/*.backup",
+    "!**/*.bak",
+    "!**/.env",
+    "!**/.env.*",
+    "!**/*.test.ts",
+    "!**/*.spec.ts",
+    "!**/*.test.js",
+    "!**/*.test.js.map",
+    "!**/*.spec.js",
+    "!**/*.spec.js.map",
+    "!**/*.js.map",
+    "!**/*.d.ts",
+    "!**/*.d.ts.map",
+    "!**/*.tsbuildinfo"
+  ],
+  "scripts": {
+    "postinstall": "node bin/postinstall.js",
+    "start": "NODE_ENV=production node dist/server/index.js"
+  },
+  "dependencies": {
+    "@codemirror/collab": "^6.1.1",
+    "@codemirror/state": "^6.5.4",
+    "@hono/node-server": "^1.19.6",
+    "@minionry/app-manifest": "^0.1.14",
+    "@minionry/browser-types": "^0.1.8",
+    "@minionry/e2ee": "file:vendor/e2ee",
+    "@minionry/roles": "^0.2.12",
+    "@minionry/sdk": "^0.4.22",
+    "@modelcontextprotocol/sdk": "^1.21.1",
+    "@sentry/core": "^10.54.0",
+    "fflate": "^0.8.3",
+    "fuse.js": "^7.1.0",
+    "hono": "^4.12.27",
+    "posthog-node": "^5.21.2",
+    "undici": "^7.29.0",
+    "ws": "^8.21.0"
+  },
+  "optionalDependencies": {
+    "@lydell/node-pty": "1.1.0",
+    "fsevents": "~2.3.3"
+  },
+  "overrides": {
+    "minimatch": ">=10.2.1",
+    "path-to-regexp": ">=8.4.0"
+  },
+  "devDependencies": {
+    "node-pty": "^1.1.0"
+  },
+  "gitHead": "0df8aa79f7246517aa99e32373d8d7ac0b18f051"
+}

package/vendor/e2ee/LICENSE

@@ -0,0 +1,14 @@
+Minionry Commercial License
+
+Copyright (c) 2025-present Minionry, Inc. All rights reserved.
+
+This software is not open-source. It is provided under a commercial
+license, and your rights to install, use, and (where the Minionry Terms
+of Service expressly permit it) distribute this software are set out
+there, together with all applicable restrictions, termination, and
+disclaimer terms:
+
+https://app.minionry.com/terms
+
+If you do not agree to the Minionry Terms of Service, you may not
+install or use this software.

package/vendor/e2ee/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@minionry/e2ee",
+  "version": "0.1.0",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts"
+  ]
+}