@minionry/minion 0.7.36

package/bin/branding.js

@@ -0,0 +1,4 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+
+export const APP_NAME = 'Minionry';

package/bin/commands/browser-install.js

@@ -0,0 +1,483 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+
+
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { APP_NAME } from '../branding.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLIENT_ROOT = resolve(__dirname, '..', '..');
+
+const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+};
+
+const colors =
+  process.stdout.isTTY && !process.env.NO_COLOR
+    ? ANSI
+    : Object.fromEntries(Object.keys(ANSI).map((name) => [name, '']));
+
+function log(msg, color = '') {
+  console.log(`${color}${msg}${colors.reset}`);
+}
+
+function emitJson(event) {
+  process.stdout.write(`${JSON.stringify({ ts: Date.now(), ...event })}\n`);
+}
+
+export async function loadPreflight() {
+  try {
+    return await import('../../dist/server/services/browser/preflight.js');
+  } catch {
+    const tsx = await import('tsx/esm/api').catch(() => null);
+    if (tsx?.tsImport) {
+      return tsx.tsImport(
+        '../../server/services/browser/preflight.ts',
+        pathToFileURL(__filename).href,
+      );
+    }
+    return import('../../server/services/browser/preflight.js');
+  }
+}
+
+async function loadElectronProvisioner() {
+  try {
+    return await import('../../dist/server/services/browser/electron-provision.js');
+  } catch {
+    const tsx = await import('tsx/esm/api').catch(() => null);
+    if (tsx?.tsImport) {
+      return tsx.tsImport(
+        '../../server/services/browser/electron-provision.ts',
+        pathToFileURL(__filename).href,
+      );
+    }
+    return import('../../server/services/browser/electron-provision.js');
+  }
+}
+
+async function loadInstaller() {
+  try {
+    return await import('../../dist/server/services/browser/installer/index.js');
+  } catch {
+    const tsx = await import('tsx/esm/api').catch(() => null);
+    if (tsx?.tsImport) {
+      return tsx.tsImport(
+        '../../server/services/browser/installer/index.ts',
+        pathToFileURL(__filename).href,
+      );
+    }
+    return import('../../server/services/browser/installer/index.js');
+  }
+}
+
+function isRoot() {
+  if (process.platform === 'win32') return false;
+  return typeof process.getuid === 'function' && process.getuid() === 0;
+}
+
+function runStreamed(cmd, args, opts, report) {
+  return new Promise((resolveExit) => {
+    report({ type: 'exec', cmd, args });
+    const child = spawn(cmd, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: opts?.cwd ?? CLIENT_ROOT,
+      env: { ...process.env, ...(opts?.env ?? {}) },
+    });
+
+    let stdoutBuf = '';
+    let stderrBuf = '';
+
+    const flushLines = (buf, stream) => {
+      const parts = buf.split('\n');
+      const tail = parts.pop() ?? '';
+      for (const line of parts) {
+        if (line.length === 0) continue;
+        report({ type: 'log', stream, line });
+      }
+      return tail;
+    };
+
+    child.stdout.on('data', (chunk) => {
+      stdoutBuf += chunk.toString();
+      stdoutBuf = flushLines(stdoutBuf, 'stdout');
+    });
+    child.stderr.on('data', (chunk) => {
+      stderrBuf += chunk.toString();
+      stderrBuf = flushLines(stderrBuf, 'stderr');
+    });
+
+    child.on('error', (err) => {
+      report({ type: 'log', stream: 'stderr', line: `spawn error: ${err.message}` });
+      resolveExit({ ok: false, code: null, signal: null });
+    });
+
+    child.on('exit', (code, signal) => {
+      if (stdoutBuf) report({ type: 'log', stream: 'stdout', line: stdoutBuf });
+      if (stderrBuf) report({ type: 'log', stream: 'stderr', line: stderrBuf });
+      resolveExit({ ok: code === 0, code, signal });
+    });
+  });
+}
+
+async function provisionElectronRuntime(loadProvisioner, report) {
+  report({ type: 'step', step: 'electron runtime', status: 'starting' });
+  try {
+    const { ensureElectronProvisioned } = await loadProvisioner();
+    const outcome = await ensureElectronProvisioned((line) =>
+      report({ type: 'log', stream: 'stdout', line }),
+    );
+    report({
+      type: 'step',
+      step: 'electron runtime',
+      status: outcome.ok ? 'completed' : 'failed',
+      ...(outcome.ok ? {} : { error: outcome.error }),
+    });
+    return outcome.ok;
+  } catch (err) {
+    report({ type: 'step', step: 'electron runtime', status: 'failed', error: err.message });
+    return false;
+  }
+}
+
+function systemFixFor(preflightMod, result, { runDeps }) {
+  const parts = result.checks
+    .filter((c) => !c.ok && c.systemFix && (runDeps || c.id !== 'chromium-libs'))
+    .map((c) => ({ fix: c.systemFix, optional: c.advisory === true }));
+  return {
+    command: preflightMod.buildSystemFixCommand(parts, result.packageManager),
+    optional: parts.every((p) => p.optional),
+  };
+}
+
+async function applySystemFix(command, runShell, report) {
+  report({ type: 'step', step: 'system', status: 'starting' });
+  const result = await runShell('sh', ['-c', command.replace(/\bsudo\s+/g, '')], {}, report);
+  report({
+    type: 'step',
+    step: 'system',
+    status: result.ok ? 'completed' : 'failed',
+    ...(result.ok ? {} : { error: `exited with code ${result.code ?? 'null'}` }),
+  });
+  return result.ok;
+}
+
+const USER_FIXED_CHECKS = new Set(['electron', 'electron-host-dist']);
+
+const isComment = (line) => line.trim().startsWith('#');
+
+function planNextSteps(result, system, { checkOnly }) {
+  const failing = result.checks.filter((c) => !c.ok);
+  const steps = failing
+    .filter((c) => !c.advisory && USER_FIXED_CHECKS.has(c.id) && c.fixCommands.length > 0)
+    .map((c) => ({
+      title:
+        c.id !== 'electron'
+          ? `Fix the ${c.label} (no sudo needed):`
+          : checkOnly
+            ? 'Run this to install the browser runtime and get one command for everything else:'
+            : 'Install the browser runtime (no sudo needed):',
+      commands: c.fixCommands,
+    }));
+
+  if (failing.some((c) => c.id === 'electron')) {
+    if (!checkOnly) {
+      steps.push({
+        title:
+          'Run "minion install browser" again. With the runtime in place it checks the rest and prints one command for everything still missing.',
+        commands: [],
+      });
+    }
+    return steps;
+  }
+
+  const prose = failing
+    .filter((c) => !c.advisory && !c.systemFix && !USER_FIXED_CHECKS.has(c.id) && c.fixCommands.length > 0)
+    .filter((c) => c.fixCommands.every(isComment));
+  if (prose.length > 0) {
+    steps.push({
+      title: 'Install these with your distribution’s package manager:',
+      commands: prose.map((c) => c.fixCommands.join('\n')),
+    });
+  }
+
+  if (system.command) {
+    steps.push({
+      title: system.optional
+        ? 'Optional — this adds extras the browser can run without:'
+        : 'Run this once to install everything that is missing:',
+      commands: [system.command],
+    });
+  }
+  return steps;
+}
+
+function wrap(text, width) {
+  const lines = [];
+  let line = '';
+  for (const word of text.split(/\s+/)) {
+    if (line && line.length + 1 + word.length > width) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = line ? `${line} ${word}` : word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines;
+}
+
+const isUnchecked = (c) => c.ok && /^not checked/i.test(c.detected ?? '');
+
+const TAG_WIDTH = '[MISSING]'.length;
+
+function statusTag(c) {
+  if (c.ok) return isUnchecked(c) ? ['[SKIP]', colors.dim] : ['[OK]', colors.green];
+  return c.advisory ? ['[WARN]', colors.yellow] : ['[MISSING]', colors.red];
+}
+
+function tidyPaths(text) {
+  const home = homedir();
+  return home && home !== '/' ? text.split(home).join('~') : text;
+}
+
+export function renderChecks(checks) {
+  const labelWidth = Math.max(0, ...checks.map((c) => c.label.length));
+  for (const c of checks) {
+    const [tag, color] = statusTag(c);
+    const head = `  ${color}${tag.padEnd(TAG_WIDTH)}${colors.reset} ${c.label}`;
+    const detail = c.ok && c.detected ? tidyPaths(c.detected) : null;
+    log(detail ? `${head}${' '.repeat(labelWidth - c.label.length + 2)}${colors.dim}${detail}` : head);
+    if (!c.ok && c.reason) {
+      for (const line of wrap(tidyPaths(c.reason), 66)) log(`  ${' '.repeat(TAG_WIDTH)} ${line}`, colors.dim);
+    }
+  }
+}
+
+const STEP_TITLES = {
+  'electron runtime': 'Installing the browser runtime (Electron)',
+  system: 'Installing the system dependencies as root',
+};
+
+function renderInstallerEvent(event) {
+  switch (event.kind) {
+    case 'extension-copied':
+      log(`    extension: copied ${event.fileCount} file(s) → ${event.to}`, colors.dim);
+      return;
+    case 'extension-skipped':
+      log(`    extension: skipped (${event.reason})`, colors.yellow);
+      return;
+    case 'extension-id':
+      log(`    extension id: ${event.id} ${colors.dim}(source: ${event.source})${colors.reset}`, colors.dim);
+      return;
+    case 'manifest-written':
+      log(`    ${colors.green}wrote${colors.reset} ${event.browser}: ${event.path}`, colors.dim);
+      return;
+    case 'manifest-skipped':
+      log(`    ${colors.dim}skip${colors.reset}  ${event.browser}: ${event.reason}`, colors.dim);
+      return;
+    case 'manifest-failed':
+      log(`    ${colors.yellow}fail${colors.reset}  ${event.browser}: ${event.error}`, colors.yellow);
+      return;
+    case 'registry-written':
+      log(`    ${colors.green}reg+${colors.reset}  ${event.browser}: ${event.keyPath}`, colors.dim);
+      return;
+    case 'registry-failed':
+      log(`    ${colors.yellow}reg!${colors.reset}  ${event.browser}: ${event.error}`, colors.yellow);
+      return;
+    case 'note':
+      log(`    ${colors.dim}note:${colors.reset} ${event.message}`, colors.dim);
+      return;
+    case 'done':
+      log(`    native-messaging: ${event.wrote} target(s) touched`, colors.dim);
+      return;
+    default:
+      log(`    ${JSON.stringify(event)}`, colors.dim);
+  }
+}
+
+const HUMAN_REPORTERS = {
+  step: (event) => {
+    const title = STEP_TITLES[event.step] ?? event.step;
+    if (event.status === 'starting') {
+      log(`  ${title}…`, colors.bold);
+    } else if (event.status === 'completed') {
+      log(`  ${title}: done.\n`, colors.green);
+    } else {
+      log(`  ${title}: failed.`, colors.red);
+      for (const line of wrap(tidyPaths(event.error ?? ''), 72)) log(`    ${line}`, colors.red);
+      log('');
+    }
+  },
+  exec: (event) => {
+    const text = event.cmd === 'sh' && event.args[0] === '-c' ? event.args[1] : [event.cmd, ...event.args].join(' ');
+    for (const line of text.split('\n')) log(`    ${line}`, colors.dim);
+  },
+  log: (event) => {
+    log(`      ${event.line}`, event.stream === 'stderr' ? colors.yellow : colors.dim);
+  },
+  preflight: (event) => {
+    renderChecks(event.checks);
+    log('');
+  },
+  'next-steps': (event) => {
+    const numbered = event.steps.length > 1;
+    const indent = numbered ? '       ' : '    ';
+    for (const [i, step] of event.steps.entries()) {
+      const [first, ...rest] = wrap(step.title, 72);
+      log(`  ${numbered ? `${i + 1}. ` : ''}${first}`, colors.bold);
+      for (const line of rest) log(`  ${numbered ? '   ' : ''}${line}`, colors.bold);
+      for (const command of step.commands) {
+        log('');
+        log(command.replace(/^/gm, indent), colors.cyan);
+      }
+      log('');
+    }
+    if (event.confirm) log('  Then run "minion install browser" again to confirm.\n');
+  },
+  done: (event) => {
+    if (event.uninstalled) {
+      log(event.skipped ? '  Nothing to uninstall.\n' : '  Native-messaging host removed.\n', colors.dim);
+    } else if (event.ok) {
+      log('  All browser dependencies ready.\n', colors.bold + colors.green);
+    }
+  },
+};
+
+function createReporter(jsonMode) {
+  if (jsonMode) return emitJson;
+  return (event) => {
+    const render = HUMAN_REPORTERS[event.type];
+    if (render) render(event);
+  };
+}
+
+async function runNativeMessagingInstall({ uninstall, report, jsonMode, load }) {
+  let installer;
+  try {
+    installer = await load();
+  } catch (err) {
+    if (jsonMode) report({ type: 'installer-unavailable', error: err.message });
+    return { ok: true, skipped: true };
+  }
+
+  const sink = jsonMode
+    ? (event) => report({ type: 'installer', event })
+    : renderInstallerEvent;
+
+  if (!jsonMode) {
+    log('  Native-messaging host', colors.bold);
+  }
+
+  try {
+    if (uninstall) {
+      const r = await installer.uninstallNativeMessagingHost({ report: sink });
+      return { ok: r.ok, removed: r.manifestsRemoved.length + r.registryKeysRemoved.length };
+    }
+    const bundled = installer.defaultBundledExtensionDir();
+    const launcher = installer.defaultLauncherPath();
+    installer.ensureLauncherExecutable(launcher, resolve(CLIENT_ROOT, 'bin', 'native-messaging-host-entry.js'));
+    const r = await installer.installNativeMessagingHost({
+      bundledExtensionDir: bundled,
+      launcherPath: launcher,
+      report: sink,
+    });
+    return { ok: r.ok, wrote: r.manifestsWritten.length + r.registryKeysWritten.length };
+  } catch (err) {
+    if (jsonMode) {
+      report({ type: 'installer-error', error: err.message });
+    } else {
+      log(`    ${colors.red}native-messaging install failed: ${err.message}${colors.reset}`);
+    }
+    return { ok: false };
+  } finally {
+    if (!jsonMode) log('');
+  }
+}
+
+const electronMissing = (result) => result.checks.some((c) => c.id === 'electron' && !c.ok);
+
+async function repair({ runPreflight, fixFor, loadProvisioner, runningAsRoot, runShell, report }) {
+  let result = await runPreflight();
+  let failed = false;
+  if (electronMissing(result)) {
+    failed = !(await provisionElectronRuntime(loadProvisioner, report));
+    result = await runPreflight();
+  }
+  let system = fixFor(result);
+  if (!electronMissing(result) && system.command && runningAsRoot()) {
+    if (!(await applySystemFix(system.command, runShell, report))) failed = true;
+    result = await runPreflight();
+    system = fixFor(result);
+  }
+  return { result, system, failed };
+}
+
+export async function browserInstall(args = [], { exit = true, deps = {} } = {}) {
+  const jsonMode = args.includes('--json');
+  const runDeps = !args.includes('--no-deps');
+  const checkOnly = args.includes('--check');
+  const uninstall = args.includes('--uninstall');
+  const {
+    loadPreflight: loadPreflightModule = loadPreflight,
+    loadElectronProvisioner: loadProvisioner = loadElectronProvisioner,
+    loadInstaller: loadInstallerModule = loadInstaller,
+    isRoot: runningAsRoot = isRoot,
+    runShell = runStreamed,
+  } = deps;
+
+  const finish = (code) => {
+    if (exit) process.exit(code);
+    return code;
+  };
+
+  const report = createReporter(jsonMode);
+
+  if (!jsonMode) log(`\n  ${APP_NAME} Browser Install\n`, colors.bold + colors.cyan);
+
+  if (uninstall) {
+    const result = await runNativeMessagingInstall({ uninstall: true, report, jsonMode, load: loadInstallerModule });
+    report({ type: 'done', ok: !!result.ok, uninstalled: true, skipped: !!result.skipped });
+    return finish(0);
+  }
+
+  let preflightMod;
+  try {
+    preflightMod = await loadPreflightModule();
+  } catch (err) {
+    log(`  Could not load preflight: ${err.message}`, colors.red);
+    return finish(1);
+  }
+
+  const PREFLIGHT_DEPS = { selfRepairAvailable: checkOnly };
+  const runPreflight = () => preflightMod.preflight(PREFLIGHT_DEPS);
+  const fixFor = (checked) => systemFixFor(preflightMod, checked, { runDeps });
+
+  const { result, system, failed } = checkOnly
+    ? await runPreflight().then((checked) => ({ result: checked, system: fixFor(checked), failed: false }))
+    : await repair({ runPreflight, fixFor, loadProvisioner, runningAsRoot, runShell, report });
+
+  report({ type: 'preflight', checks: result.checks, platform: result.platform, packageManager: result.packageManager });
+  const steps = planNextSteps(result, system, { checkOnly });
+  if (steps.length > 0) {
+    report({ type: 'next-steps', steps, confirm: !result.ok && !electronMissing(result) });
+  }
+
+  await runNativeMessagingInstall({ uninstall: false, report, jsonMode, load: loadInstallerModule });
+
+  report({ type: 'done', ok: result.ok });
+
+  if (checkOnly) return finish(result.ok ? 0 : 1);
+  return finish(failed ? 1 : 0);
+}
+
+export default browserInstall;