@minionry/minion 0.7.36

package/dist/server/services/browser/electron-provision.js

@@ -0,0 +1,256 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { accessSync, existsSync, constants as fsConstants, mkdirSync, readFileSync, renameSync, rmSync, } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { MINIONRY_ROOT } from '../../utils/paths.js';
+export const PUBLIC_NPM_REGISTRY = 'https://registry.npmjs.org/';
+export const DEFAULT_ELECTRON_VERSION = '^41.8.0';
+const DEFAULT_PACKAGE_ROOT = MINIONRY_ROOT;
+export function electronStagingDir(packageRoot) {
+    return join(packageRoot, '.electron-stage');
+}
+export function buildElectronRepairCommand(packageRoot, version) {
+    const range = version ?? defaultReadElectronVersion(packageRoot);
+    const stage = electronStagingDir(packageRoot);
+    const target = join(packageRoot, 'node_modules', 'electron');
+    return [
+        `rm -rf '${stage}'`,
+        `npm install 'electron@${range}' --prefix '${stage}' --no-audit --no-fund --registry=${PUBLIC_NPM_REGISTRY}`,
+        `rm -rf '${target}'`,
+        `mv '${join(stage, 'node_modules', 'electron')}' '${target}'`,
+        `rm -rf '${stage}'`,
+    ].join(' && \\\n  ');
+}
+function defaultResolveElectronBinary() {
+    try {
+        const require_ = createRequire(import.meta.url);
+        const resolved = require_('electron');
+        return typeof resolved === 'string' ? resolved : null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildInstallEnv(base) {
+    const env = {};
+    for (const [key, value] of Object.entries(base)) {
+        if (key.toLowerCase().startsWith('npm_') || key === 'INIT_CWD' || key === 'NODE_ENV')
+            continue;
+        env[key] = value;
+    }
+    return env;
+}
+function defaultCanWrite(p) {
+    try {
+        accessSync(p, fsConstants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultReadElectronVersion(packageRoot) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+        return (pkg.optionalDependencies?.electron ?? pkg.dependencies?.electron ?? DEFAULT_ELECTRON_VERSION);
+    }
+    catch {
+        return DEFAULT_ELECTRON_VERSION;
+    }
+}
+const defaultSpawn = (cmd, args, opts) => new Promise((resolveExit) => {
+    const child = spawn(cmd, args, {
+        cwd: opts.cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: opts.env ?? process.env,
+        windowsHide: true,
+    });
+    let tail = '';
+    const TAIL_CAP = 4_000;
+    const append = (chunk) => {
+        const text = chunk.toString('utf8');
+        tail = (tail + text).slice(-TAIL_CAP);
+        if (opts.onLine) {
+            for (const line of text.split('\n')) {
+                if (line.trim().length > 0)
+                    opts.onLine(line);
+            }
+        }
+    };
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', (err) => {
+        tail = `${tail}\nspawn error: ${err.message}`.slice(-TAIL_CAP);
+        resolveExit({ ok: false, code: null, tail });
+    });
+    child.on('exit', (code) => resolveExit({ ok: code === 0, code, tail }));
+});
+export class ElectronRuntimeProvisioner {
+    packageRoot;
+    resolveElectronBinary;
+    pathExists;
+    readElectronVersion;
+    spawnFn;
+    installEnv;
+    mkdir;
+    rm;
+    move;
+    canWrite;
+    constructor(deps = {}) {
+        this.packageRoot = deps.packageRoot ?? DEFAULT_PACKAGE_ROOT;
+        this.resolveElectronBinary = deps.resolveElectronBinary ?? defaultResolveElectronBinary;
+        this.pathExists = deps.pathExists ?? existsSync;
+        this.readElectronVersion =
+            deps.readElectronVersion ?? (() => defaultReadElectronVersion(this.packageRoot));
+        this.spawnFn = deps.spawn ?? defaultSpawn;
+        this.installEnv = buildInstallEnv(deps.env ?? process.env);
+        this.mkdir = deps.mkdir ?? ((p) => mkdirSync(p, { recursive: true }));
+        this.rm = deps.rm ?? ((p) => rmSync(p, { recursive: true, force: true }));
+        this.move = deps.move ?? renameSync;
+        this.canWrite = deps.canWrite ?? defaultCanWrite;
+    }
+    get root() {
+        return this.packageRoot;
+    }
+    status() {
+        const resolved = this.resolveElectronBinary();
+        if (resolved && this.pathExists(resolved)) {
+            return { provisioned: true, binaryPath: resolved, state: 'ok' };
+        }
+        const pkgManifest = join(this.packageRoot, 'node_modules', 'electron', 'package.json');
+        if (this.pathExists(pkgManifest)) {
+            return { provisioned: false, binaryPath: resolved, state: 'binary-missing' };
+        }
+        return { provisioned: false, binaryPath: null, state: 'package-missing' };
+    }
+    async provision(onLine) {
+        const log = onLine ?? (() => { });
+        const before = this.status();
+        if (before.provisioned) {
+            return { ok: true, status: before, action: 'noop' };
+        }
+        let action = 'failed';
+        if (before.state === 'binary-missing') {
+            log('Electron package present but its binary is missing — downloading it…');
+            action = 'binary-download';
+            const installJs = join(this.packageRoot, 'node_modules', 'electron', 'install.js');
+            const r = await this.spawnFn(process.execPath, [installJs], {
+                cwd: join(this.packageRoot, 'node_modules', 'electron'),
+                onLine: log,
+                env: this.installEnv,
+            });
+            if (!r.ok && !this.status().provisioned) {
+                log('Binary download failed; reinstalling the electron package…');
+                action = 'npm-install';
+                await this.runNpmInstall(log, true);
+            }
+        }
+        else {
+            action = 'npm-install';
+            await this.runNpmInstall(log, false);
+        }
+        const after = this.status();
+        if (after.provisioned) {
+            return { ok: true, status: after, action };
+        }
+        return { ok: false, status: after, action: 'failed', error: this.describeFailure(after) };
+    }
+    async runNpmInstall(log, force) {
+        const version = this.readElectronVersion();
+        const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const stage = electronStagingDir(this.packageRoot);
+        const staged = join(stage, 'node_modules', 'electron');
+        const target = join(this.packageRoot, 'node_modules', 'electron');
+        log(`Installing electron@${version} into ${this.packageRoot} from ${PUBLIC_NPM_REGISTRY}…`);
+        this.rm(stage);
+        this.mkdir(stage);
+        const args = [
+            'install',
+            `electron@${version}`,
+            '--prefix',
+            stage,
+            '--no-audit',
+            '--no-fund',
+            '--no-package-lock',
+            `--registry=${PUBLIC_NPM_REGISTRY}`,
+        ];
+        if (force)
+            args.push('--force');
+        const r = await this.spawnFn(npm, args, { cwd: stage, onLine: log, env: this.installEnv });
+        if (!r.ok) {
+            log(`npm install exited with code ${r.code ?? 'null'}.`);
+            this.rm(stage);
+            return r;
+        }
+        if (!this.pathExists(staged)) {
+            this.rm(stage);
+            return {
+                ok: false,
+                code: r.code,
+                tail: `${r.tail}\nnpm reported success but ${staged} does not exist.`,
+            };
+        }
+        try {
+            this.rm(target);
+            this.move(staged, target);
+        }
+        catch (err) {
+            const message = err.message;
+            log(`Could not move electron into place: ${message}`);
+            this.rm(stage);
+            return { ok: false, code: r.code, tail: `${r.tail}\n${message}` };
+        }
+        this.rm(stage);
+        return r;
+    }
+    describeFailure(status) {
+        const note = status.state === 'package-missing'
+            ? `Could not install electron into ${this.packageRoot}.`
+            : `electron is installed at ${this.packageRoot} but its binary is still missing.`;
+        if (!this.canWrite(this.packageRoot)) {
+            return `${note} ${this.packageRoot} is not writable by this user — re-run with elevated permissions (e.g. \`sudo minion install browser\`) or reinstall the cli.`;
+        }
+        return `${note} Run the runtime install command printed below.`;
+    }
+}
+let inFlight = null;
+let lastFailureAt = 0;
+let lastFailureResult = null;
+export const PROVISION_FAILURE_COOLDOWN_MS = 60_000;
+export function ensureElectronProvisioned(onLine, deps) {
+    if (inFlight)
+        return inFlight;
+    if (lastFailureResult && now() - lastFailureAt < PROVISION_FAILURE_COOLDOWN_MS) {
+        return Promise.resolve(lastFailureResult);
+    }
+    const run = new ElectronRuntimeProvisioner(deps)
+        .provision(onLine)
+        .then((result) => {
+        if (result.ok) {
+            lastFailureResult = null;
+        }
+        else {
+            lastFailureResult = result;
+            lastFailureAt = now();
+        }
+        return result;
+    })
+        .finally(() => {
+        inFlight = null;
+    });
+    inFlight = run;
+    return run;
+}
+export function isElectronProvisioning() {
+    return inFlight !== null;
+}
+function now() {
+    return Date.now();
+}
+export function resetElectronProvisionStateForTests() {
+    inFlight = null;
+    lastFailureAt = 0;
+    lastFailureResult = null;
+}

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

@@ -0,0 +1,245 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { accessSync, existsSync, constants as fsConstants, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { MINIONRY_ROOT } from '../../utils/paths.js';
+export const DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+export const DEFAULT_INITIAL_URL = 'about:blank';
+export const LIFECYCLE_EVENTS = new Set([
+    'ready',
+    'restarting',
+    'recovering',
+    'stopped',
+    'crashed',
+]);
+export const RECOVER_THROTTLE_MS = 5_000;
+export const SIGTERM_GRACE_MS = 5_000;
+export const STARTUP_TIMEOUT_MS = 20_000;
+export const MAX_RESTARTS = 3;
+export const RESTART_BACKOFFS_MS = [1_000, 2_000, 4_000];
+export class TabInfoCache {
+    tabs = new Map();
+    get(tabId) {
+        return this.tabs.get(tabId) ?? null;
+    }
+    upsert(tabId, info) {
+        const prev = this.tabs.get(tabId);
+        const next = {
+            url: info.url ?? prev?.url ?? '',
+            title: info.title ?? prev?.title ?? '',
+            ...(info.faviconUrl !== undefined ? { faviconUrl: info.faviconUrl } : prev?.faviconUrl !== undefined ? { faviconUrl: prev.faviconUrl } : {}),
+            canGoBack: info.canGoBack ?? prev?.canGoBack ?? false,
+            canGoForward: info.canGoForward ?? prev?.canGoForward ?? false,
+            ...(info.deviceProfile !== undefined
+                ? { deviceProfile: info.deviceProfile }
+                : prev?.deviceProfile !== undefined
+                    ? { deviceProfile: prev.deviceProfile }
+                    : {}),
+        };
+        this.tabs.set(tabId, next);
+    }
+    delete(tabId) {
+        this.tabs.delete(tabId);
+    }
+    clear() {
+        this.tabs.clear();
+    }
+    entries() {
+        const out = [];
+        for (const [id, info] of this.tabs) {
+            out.push({ id, ...info });
+        }
+        return out;
+    }
+    has(tabId) {
+        return this.tabs.has(tabId);
+    }
+}
+export function extractCandidate(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    if (typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    const out = {};
+    if (typeof obj.candidate === 'string')
+        out.candidate = obj.candidate;
+    if (obj.sdpMLineIndex === null || typeof obj.sdpMLineIndex === 'number') {
+        out.sdpMLineIndex = obj.sdpMLineIndex;
+    }
+    if (obj.sdpMid === null || typeof obj.sdpMid === 'string') {
+        out.sdpMid = obj.sdpMid;
+    }
+    if (obj.usernameFragment === null || typeof obj.usernameFragment === 'string') {
+        out.usernameFragment = obj.usernameFragment;
+    }
+    return out;
+}
+export function extractLeaseExpired(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    const tabId = typeof obj.tabId === 'string' ? obj.tabId : null;
+    const agentId = typeof obj.agentId === 'string' ? obj.agentId : null;
+    if (!tabId || !agentId)
+        return null;
+    const planId = typeof obj.planId === 'string' ? obj.planId : undefined;
+    return planId !== undefined ? { tabId, agentId, planId } : { tabId, agentId };
+}
+export function resolveDefaultAppDir() {
+    return join(MINIONRY_ROOT, 'electron-host');
+}
+export function buildChildEnv(parent, overrides) {
+    const ALLOW = [
+        'DISPLAY',
+        'WAYLAND_DISPLAY',
+        'XDG_RUNTIME_DIR',
+        'XDG_SESSION_TYPE',
+        'HOME',
+        'PATH',
+        'TMPDIR',
+        'TEMP',
+        'TMP',
+        'LANG',
+        'LC_ALL',
+        'ELECTRON_RUN_AS_NODE',
+        'ELECTRON_NO_ASAR',
+        'CHROME_DEVEL_SANDBOX',
+        'MINIONRY_BROWSER_DEBUG',
+        'DBUS_SESSION_BUS_ADDRESS',
+    ];
+    const out = {};
+    for (const key of ALLOW) {
+        const value = parent[key];
+        if (typeof value === 'string')
+            out[key] = value;
+    }
+    out.ELECTRON_ENABLE_LOGGING = '1';
+    if (overrides) {
+        for (const [key, value] of Object.entries(overrides)) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+export function resolveDefaultElectronBinary() {
+    try {
+        const require_ = createRequire(import.meta.url);
+        const resolved = require_('electron');
+        return typeof resolved === 'string' ? resolved : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readPackageVersion(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+        return typeof parsed.version === 'string' ? parsed.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const BOOT_PACKAGE_VERSION = readPackageVersion(MINIONRY_ROOT);
+function defaultCanExecute(p) {
+    try {
+        accessSync(p, fsConstants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function checkSpawnPreconditions(deps) {
+    const pathExists = deps.pathExists ?? existsSync;
+    const canExecute = deps.canExecute ?? defaultCanExecute;
+    const readInstalled = deps.readInstalledVersion ?? (() => readPackageVersion(MINIONRY_ROOT));
+    const installedVersion = readInstalled();
+    if (deps.bootVersion !== null && installedVersion !== null && installedVersion !== deps.bootVersion) {
+        return (`minion v${installedVersion} is installed on disk but this server is still running v${deps.bootVersion} — ` +
+            'an update replaced the install while it was running. Restart minion, then open the browser again.');
+    }
+    if (deps.electronBinary === null) {
+        return 'the Electron runtime is not installed — run `minion install browser`';
+    }
+    if (!pathExists(deps.electronBinary)) {
+        return `the Electron binary is missing at ${deps.electronBinary} — run \`minion install browser\` to reinstall it`;
+    }
+    if (!canExecute(deps.electronBinary)) {
+        return `the Electron binary at ${deps.electronBinary} is not executable (EACCES) — fix its permissions or run \`minion install browser\``;
+    }
+    if (!pathExists(join(deps.appDir, 'package.json'))) {
+        return (`the browser host app is missing at ${deps.appDir} (no package.json) — ` +
+            'reinstall minion, or run `npm run build:electron-host` in a source checkout');
+    }
+    return null;
+}
+export function describeSpawnError(err, binary, appDir) {
+    const what = `${err.syscall ?? 'spawn'} ${err.path ?? binary}`;
+    switch (err.code) {
+        case 'ENOENT':
+            return (`${what} failed (ENOENT): the Electron binary or the host app dir ${appDir} disappeared — ` +
+                'run `minion install browser`, or restart minion if an update just replaced the install');
+        case 'EACCES':
+            return `${what} failed (EACCES): ${binary} is not executable — fix its permissions or run \`minion install browser\``;
+        default:
+            return `${what} failed: ${err.code ?? err.message}`;
+    }
+}
+const ROOT_WITHOUT_FLAG = /Running as root without --no-sandbox/;
+const NO_USABLE_SANDBOX = /SUID sandbox helper binary was found, but is not configured correctly|No usable sandbox/;
+const NAMESPACES_BLOCKED = /Failed to move to new namespace|zygote_host_impl_linux\.cc/;
+const EXEC_FAILED = /: exec: .*: (?:not found|Permission denied)/;
+const MISSING_LIBS = /error while loading shared libraries|cannot open shared object file/;
+const APP_MISSING = /Unable to find Electron app|Cannot find module/;
+function classifySandboxFailure(text) {
+    if (ROOT_WITHOUT_FLAG.test(text))
+        return 'root-without-flag';
+    if (NO_USABLE_SANDBOX.test(text))
+        return 'no-usable-sandbox';
+    if (NAMESPACES_BLOCKED.test(text))
+        return 'namespaces-blocked';
+    return null;
+}
+export function classifyCrash(reason, stderrTail) {
+    const text = [reason, ...stderrTail].join('\n');
+    const sandboxFailure = classifySandboxFailure(text);
+    if (sandboxFailure !== null) {
+        return { permanent: true, hint: null, sandboxFailure };
+    }
+    if (EXEC_FAILED.test(text)) {
+        return {
+            permanent: true,
+            hint: 'the Electron binary could not be executed — run `minion install browser`, or restart minion if an update just replaced the install',
+            sandboxFailure: null,
+        };
+    }
+    if (MISSING_LIBS.test(text)) {
+        return {
+            permanent: true,
+            hint: 'Chromium is missing system libraries — run `minion doctor browser` for the install command',
+            sandboxFailure: null,
+        };
+    }
+    if (APP_MISSING.test(text)) {
+        return {
+            permanent: true,
+            hint: 'the browser host app did not load — reinstall minion (`minion update`)',
+            sandboxFailure: null,
+        };
+    }
+    return { permanent: false, hint: null, sandboxFailure: null };
+}
+export function resolveSdkStubPath() {
+    try {
+        const require_ = createRequire(import.meta.url);
+        const pkgJsonPath = require_.resolve('@minionry/sdk/package.json');
+        const stubPath = join(dirname(pkgJsonPath), 'dist', 'injected', 'v1.js');
+        return existsSync(stubPath) ? stubPath : null;
+    }
+    catch {
+        return null;
+    }
+}