omnindicator 0.1.0

package/docs/npm-installer.md

@@ -0,0 +1,91 @@
+# `omnindicator` npm installer
+
+`omnindicator` is a small, dependency-free Node.js host doctor and installer
+for this repository. It does not contain model weights and it does not replace
+the Python/CUDA runtime. Its job is deliberately narrow:
+
+1. identify the operating system, architecture, Tegra versus discrete NVIDIA
+   memory model, broker mode, system memory, model-class capacity, disk space,
+   desktop-session signal, and required host tools;
+2. stop before cloning or pulling model data when the coarse compute floor,
+   disk floor, platform, or prerequisites are not satisfied;
+3. prepare a release-pinned checkout of this repository;
+4. set the selected logical model as both the Omni and language tag, avoiding a
+   redundant language runner; and
+5. hand control to the repository-native deployer, which remains responsible
+   for exact artifact validation, live memory admission, GPU residency, service
+   readiness, rollback, and the model download itself.
+
+The fastest guided path is one command:
+
+```bash
+npx omnindicator@latest
+```
+
+Or install the CLI once:
+
+```bash
+npm install --global omnindicator
+omnindicator
+```
+
+There is intentionally no npm `postinstall` hook. Installing a JavaScript
+dependency must not silently clone source, request administrator access, pull
+tens of gigabytes of weights, or start a microphone-enabled service. `npx
+omnindicator` installs and immediately invokes the visible guided command; a
+global install exposes the same command for an explicit invocation.
+
+## Commands
+
+```bash
+omnindicator doctor
+omnindicator doctor --json
+omnindicator install
+omnindicator install --profile ornith15 --yes
+omnindicator status
+```
+
+Use `--dry-run` with `install` to print the checkout and native deploy command
+without cloning, pulling weights, or changing services. `--repo-dir PATH` uses
+an existing checkout without changing its Git state. On Linux, `--core-only`
+is the only way to opt out of the desktop indicator.
+
+## Platform scope
+
+| Platform | Compute path | Managed runtime | Always-listening tray/top-bar indicator |
+|---|---|---|---|
+| NVIDIA Jetson/Tegra Linux | CUDA on integrated GPU/unified memory | systemd direct mode | Yes; GTK/AppIndicator harness is the default |
+| Discrete NVIDIA Linux | broker-scoped CUDA when ollama-unify is present, direct otherwise | systemd | Yes; GTK/AppIndicator harness is the default |
+| macOS | pinned llama.cpp Metal build | per-user launchd agent | No native tray implementation yet; portal only |
+| Windows x64 + NVIDIA | pinned llama.cpp CUDA build | scheduled task or pywin32 service | No native tray implementation yet; portal only |
+
+The package refuses to describe macOS or Windows as indicator deployments.
+Interactive users must acknowledge the core-only boundary; unattended use must
+pass `--core-only --yes`.
+
+## Capacity screening
+
+The npm doctor uses conservative class-level floors, not an optimistic free
+VRAM snapshot. The compact Ornith bundle is about 8.15 GiB and is the preferred
+32 GB Jetson profile. The compact Qwen3.8 E03 bundle is about 18.33 GiB and
+needs substantially more headroom for KV cache, TTS, pointing, CUDA workspaces,
+the desktop, and tools. A 32 GB-class Tegra can be screened as conditional for
+Qwen3.8; that is not a promise that a useful live context tier will fit.
+
+After the coarse screen, the native deployment performs the authoritative
+checks using installed layer bytes, current unified/GPU memory, the operating
+reserve, GPU utilization policy, per-worker residency evidence, and readiness.
+It may still refuse or roll back a host that passed the npm screen. Conversely,
+the npm package offers no `--force` switch that can erase a compute failure.
+
+## Checkout and update behavior
+
+The default checkout lives in the platform application-data directory and is
+pinned to the release tag corresponding to the npm version. It stays on a
+tracking `main` branch so the Linux indicator's explicit **Update available**
+action can fast-forward it later. `omnindicator` will not overwrite tracked
+local changes, switch an unexpected branch, or update an unexpected Git
+remote. Untracked runtime data is preserved.
+
+No registry credential, portal access token, model credential, voice clip, or
+host identifier is embedded in the npm package.

package/npm/omnindicator/bin/omnindicator.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { main } = require("../lib/cli");
+
+main(process.argv.slice(2)).catch((error) => {
+  const message = error && error.message ? error.message : String(error);
+  process.stderr.write(`omnindicator: ${message}\n`);
+  process.exitCode = 1;
+});

package/npm/omnindicator/lib/cli.js

@@ -0,0 +1,267 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const readline = require("node:readline/promises");
+const { stdin, stdout } = require("node:process");
+const { inspectHost } = require("./host");
+const {
+  RELEASE_REF,
+  buildDeployment,
+  dataRoot,
+  ensureRepository,
+  runDeployment,
+  runStatus,
+} = require("./installer");
+
+function usage() {
+  return `Usage: omnindicator [install|doctor|status] [options]
+
+With no command, omnindicator runs the guarded interactive installer.
+
+Options:
+  --profile ornith15|qwen38  Select a trained audio-bridge model
+  --repo-dir PATH            Use an existing checkout without changing its Git state
+  --core-only                Linux: omit the always-listening indicator harness
+  --yes, -y                  Accept the deployment plan (requires --profile without a TTY)
+  --dry-run                  Show the resolved plan without cloning, pulling weights, or starting services
+  --json                     Emit machine-readable doctor output
+  --help, -h                 Show this help
+  --version, -v              Show the package version
+
+The Linux desktop default installs the visible AppIndicator harness. macOS and
+Windows currently install the GPU runtime/service and portal only; no native
+tray indicator is claimed on those platforms.`;
+}
+
+function parseArgs(argv) {
+  const result = {
+    command: "install",
+    profile: null,
+    repoDir: null,
+    externalCheckout: false,
+    coreOnly: false,
+    yes: false,
+    dryRun: false,
+    json: false,
+    help: false,
+    version: false,
+  };
+  let commandSeen = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (!value.startsWith("-") && !commandSeen) {
+      if (!new Set(["install", "doctor", "status"]).has(value)) throw new Error(`Unknown command: ${value}`);
+      result.command = value;
+      commandSeen = true;
+    } else if (value === "--profile") {
+      result.profile = argv[++index];
+      if (!result.profile) throw new Error("--profile requires a value");
+    } else if (value === "--repo-dir") {
+      result.repoDir = path.resolve(argv[++index] || "");
+      if (!argv[index]) throw new Error("--repo-dir requires a value");
+      result.externalCheckout = true;
+    } else if (value === "--core-only") result.coreOnly = true;
+    else if (value === "--yes" || value === "-y") result.yes = true;
+    else if (value === "--dry-run") result.dryRun = true;
+    else if (value === "--json") result.json = true;
+    else if (value === "--help" || value === "-h") result.help = true;
+    else if (value === "--version" || value === "-v") result.version = true;
+    else throw new Error(`Unknown option: ${value}`);
+  }
+  return result;
+}
+
+function packageVersion() {
+  const packagePath = path.resolve(__dirname, "..", "..", "..", "package.json");
+  return JSON.parse(fs.readFileSync(packagePath, "utf8")).version;
+}
+
+function round1(value) {
+  return Number.isFinite(value) ? (Math.round(value * 10) / 10).toFixed(1) : "unknown";
+}
+
+function platformLabel(host) {
+  if (host.tegra) return `Linux/${host.arch} NVIDIA ${host.tegraSoc || "Tegra"} (unified memory)`;
+  if (host.platform === "darwin") return `macOS/${host.arch} Metal`;
+  if (host.platform === "win32") return `Windows/${host.arch} NVIDIA CUDA`;
+  return `Linux/${host.arch} ${host.brokerManaged ? "broker-managed NVIDIA" : "direct NVIDIA"}`;
+}
+
+function renderDoctor(host) {
+  const lines = [
+    `Host: ${platformLabel(host)}`,
+    `System memory: ${round1(host.totalMemoryGiB)} GiB total, ${round1(host.freeMemoryGiB)} GiB currently free`,
+    `Install filesystem: ${round1(host.diskFreeGiB)} GiB free`,
+  ];
+  if (host.gpus.length) {
+    for (const gpu of host.gpus) lines.push(`GPU ${gpu.index}: ${gpu.name}, ${round1(gpu.memoryGiB)} GiB`);
+  }
+  lines.push(`Runtime mode: ${host.tegra ? "direct Tegra" : host.brokerManaged ? "ollama-unify broker" : "platform-native direct"}`);
+  lines.push(`Desktop indicator: ${host.indicatorAvailable ? "Linux harness available; target desktop is proven during deployment" : "not implemented on this platform (core runtime/portal only)"}`);
+  if (host.platform === "linux") lines.push(`Desktop session signal: ${host.desktopSessionDetected ? "detected" : "not visible from this shell; native installer will attempt signed-in-session recovery"}`);
+  lines.push("");
+  lines.push("Model screening (coarse pre-download check):");
+  for (const profile of host.profiles) {
+    lines.push(`  ${profile.id.padEnd(9)} ${profile.state.padEnd(11)} ${profile.artifactGiB} GiB artifacts — ${profile.reason}`);
+    if (profile.diskWarning) lines.push(`              disk warning: ${profile.diskWarning}`);
+  }
+  if (host.supportError) lines.push(`\nBLOCKED: ${host.supportError}`);
+  if (host.missingDependencies.length) lines.push(`\nBLOCKED: missing host tools: ${host.missingDependencies.join(", ")}`);
+  if (host.runningAsRoot && host.platform === "linux") lines.push("\nWARNING: run omnindicator as the signed-in desktop user, not root; deploy.sh requests sudo only for system steps.");
+  lines.push("\nThis is an early screen, not a residency guarantee. The repository doctor, exact layer-byte admission, live memory reserve, GPU-residency proof, and service readiness gates still run on the target host.");
+  return lines.join("\n");
+}
+
+function doctorJson(host) {
+  return {
+    platform: host.platform,
+    arch: host.arch,
+    tegra: host.tegra,
+    tegraSoc: host.tegraSoc,
+    totalMemoryGiB: host.totalMemoryGiB,
+    freeMemoryGiB: host.freeMemoryGiB,
+    diskFreeGiB: host.diskFreeGiB,
+    gpus: host.gpus.map(({ index, name, memoryGiB, driver }) => ({ index, name, memoryGiB, driver })),
+    maxGpuMemoryGiB: host.maxGpuMemoryGiB,
+    metalSupported: host.metalSupported,
+    brokerManaged: host.brokerManaged,
+    indicatorAvailable: host.indicatorAvailable,
+    desktopSessionDetected: host.desktopSessionDetected,
+    dependencies: Object.fromEntries(Object.entries(host.dependencies).map(([name, value]) => [name, Boolean(value)])),
+    missingDependencies: host.missingDependencies,
+    supportError: host.supportError,
+    runningAsRoot: host.runningAsRoot,
+    profiles: host.profiles,
+  };
+}
+
+async function ask(prompt) {
+  const interface_ = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    return (await interface_.question(prompt)).trim();
+  } finally {
+    interface_.close();
+  }
+}
+
+async function chooseProfile(host, requested) {
+  if (requested) {
+    const fit = host.profiles.find((profile) => profile.id === requested);
+    if (!fit) throw new Error(`Unknown profile ${requested}; expected ornith15 or qwen38.`);
+    return fit;
+  }
+  if (!stdin.isTTY || !stdout.isTTY) throw new Error("Non-interactive installation requires --profile and --yes.");
+  const candidates = host.profiles.filter((profile) => profile.state !== "unsupported");
+  if (!candidates.length) throw new Error("This host did not pass the coarse compute floor for either model.");
+  stdout.write("\nChoose a model:\n");
+  candidates.forEach((profile, index) => stdout.write(`  ${index + 1}) ${profile.title} [${profile.state}]\n`));
+  const answer = await ask(`Selection [1]: `);
+  const choice = answer === "" ? 0 : Number(answer) - 1;
+  if (!Number.isInteger(choice) || choice < 0 || choice >= candidates.length) throw new Error("Invalid model selection.");
+  return candidates[choice];
+}
+
+function shellDisplay(command, args) {
+  return [command, ...args].map((value) => /[^A-Za-z0-9_./:=+-]/.test(value) ? JSON.stringify(value) : value).join(" ");
+}
+
+async function install(options, host) {
+  if (host.supportError) throw new Error(host.supportError);
+  if (host.missingDependencies.length) {
+    throw new Error(`Install prerequisites are missing: ${host.missingDependencies.join(", ")}. No repository or model data was downloaded.`);
+  }
+  if (host.platform === "linux" && host.runningAsRoot && !options.coreOnly) {
+    throw new Error("Refusing a root-owned desktop indicator. Run as the signed-in desktop user; deploy.sh will request sudo when needed.");
+  }
+  if (host.platform === "linux" && !options.coreOnly && !host.desktopSessionDetected) {
+    throw new Error("No graphical desktop session was detected for the indicator. Run from the signed-in desktop session or pass --core-only; no repository or model data was downloaded.");
+  }
+
+  const profile = await chooseProfile(host, options.profile);
+  if (profile.state === "unsupported") throw new Error(`${profile.title} is not admitted: ${profile.reason}`);
+  if (profile.diskWarning) throw new Error(`${profile.diskWarning} No repository or model data was downloaded.`);
+
+  let coreOnly = options.coreOnly;
+  if (!host.indicatorAvailable && !coreOnly) {
+    stdout.write("\nThis platform has no native omnindicator tray implementation. The supported deployment is the core GPU service and portal.\n");
+    if (!options.yes) {
+      if (!stdin.isTTY || !stdout.isTTY) throw new Error("Pass --core-only --yes to acknowledge core-only deployment on this platform.");
+      const answer = (await ask("Continue with the core runtime and portal only? [y/N] ")).toLowerCase();
+      if (answer !== "y" && answer !== "yes") return;
+    }
+    coreOnly = true;
+  }
+
+  const root = dataRoot(host.platform);
+  const repoDir = options.repoDir || path.join(root, "qwen-omni-adapters");
+  const planSummary = [
+    "\nDeployment plan",
+    `  Release:    omnindicator ${packageVersion()} / ${RELEASE_REF}`,
+    `  Checkout:   ${repoDir}`,
+    `  Model:      ${profile.title}`,
+    `  Artifacts:  ${profile.artifactGiB} GiB plus KV/workspaces/runtime reserve`,
+    `  Interface:  ${coreOnly ? "core service + portal" : "core service + always-listening Linux indicator"}`,
+    `  Screening:  ${profile.state} — ${profile.reason}`,
+  ].join("\n");
+  stdout.write(`${planSummary}\n`);
+
+  if (!options.yes) {
+    if (!stdin.isTTY || !stdout.isTTY) throw new Error("Non-interactive installation requires --yes.");
+    const answer = (await ask("Proceed with checkout and native deployment? [y/N] ")).toLowerCase();
+    if (answer !== "y" && answer !== "yes") return;
+  }
+
+  const existing = fs.existsSync(repoDir);
+  const preview = buildDeployment({ platform: host.platform, repoDir, profile: profile.id, coreOnly, existing });
+  if (options.dryRun) {
+    stdout.write(`\nDry run: would prepare ${options.externalCheckout ? "the supplied checkout" : `the release-pinned ${RELEASE_REF} checkout`} and run:\n  ${shellDisplay(preview.command, preview.args)}\n`);
+    return;
+  }
+
+  const checkout = ensureRepository({
+    repoDir,
+    ref: RELEASE_REF,
+    externalCheckout: options.externalCheckout,
+    git: host.dependencies.git,
+  });
+  const deployment = buildDeployment({
+    platform: host.platform,
+    repoDir: checkout.repoDir,
+    profile: profile.id,
+    coreOnly,
+    existing: !checkout.created,
+  });
+  stdout.write(`\nStarting the repository-native deployment. Pulls begin only after the coarse host gate above; the native deployer then validates artifacts, live memory, GPU residency, and readiness before cutover.\n`);
+  runDeployment(deployment);
+  stdout.write(`\nomnindicator deployment completed. Run \"omnindicator status\" for current component state.\n`);
+}
+
+async function main(argv) {
+  const options = parseArgs(argv);
+  if (options.help) {
+    stdout.write(`${usage()}\n`);
+    return;
+  }
+  if (options.version) {
+    stdout.write(`${packageVersion()}\n`);
+    return;
+  }
+  if (options.command === "status") {
+    const repoDir = options.repoDir || path.join(dataRoot(process.platform), "qwen-omni-adapters");
+    runStatus(repoDir, process.platform);
+    return;
+  }
+
+  const host = inspectHost({ installTarget: options.repoDir ? path.dirname(options.repoDir) : dataRoot(process.platform) });
+  if (options.command === "doctor") {
+    stdout.write(options.json ? `${JSON.stringify(doctorJson(host), null, 2)}\n` : `${renderDoctor(host)}\n`);
+    return;
+  }
+
+  stdout.write("omnindicator — guarded installer for the Qwen Omni local voice, perception, tool, and desktop-indicator runtime\n\n");
+  stdout.write(`${renderDoctor(host)}\n`);
+  await install(options, host);
+}
+
+module.exports = { chooseProfile, doctorJson, install, main, packageVersion, parseArgs, renderDoctor, usage };

package/npm/omnindicator/lib/host.js

@@ -0,0 +1,207 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { evaluateProfiles } = require("./models");
+
+const GIB = 1024 ** 3;
+
+function executableCandidates(name, platform = process.platform) {
+  if (platform !== "win32") return [name];
+  const extensions = (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM")
+    .split(";")
+    .filter(Boolean);
+  return path.extname(name) ? [name] : extensions.map((extension) => `${name}${extension.toLowerCase()}`);
+}
+
+function findCommand(name, env = process.env, platform = process.platform) {
+  const searchPath = env.PATH || env.Path || env.path || "";
+  for (const directory of searchPath.split(path.delimiter).filter(Boolean)) {
+    for (const candidate of executableCandidates(name, platform)) {
+      const target = path.join(directory, candidate);
+      try {
+        fs.accessSync(target, fs.constants.X_OK);
+        return target;
+      } catch (_) {
+        // Keep searching.
+      }
+    }
+  }
+  return null;
+}
+
+function readTegraCompatible() {
+  try {
+    return fs.readFileSync("/proc/device-tree/compatible").toString("utf8").replaceAll("\0", "\n");
+  } catch (_) {
+    return "";
+  }
+}
+
+function detectNvidiaGpus(command) {
+  if (!command) return [];
+  const result = spawnSync(command, [
+    "--query-gpu=index,name,memory.total,driver_version",
+    "--format=csv,noheader,nounits",
+  ], { encoding: "utf8", timeout: 8000, windowsHide: true });
+  if (result.status !== 0) return [];
+  return result.stdout.split(/\r?\n/).filter(Boolean).map((line) => {
+    const [index, name, memoryMiB, driver] = line.split(",").map((value) => value.trim());
+    return {
+      index: Number(index),
+      name,
+      memoryGiB: Number(memoryMiB) / 1024,
+      driver,
+    };
+  }).filter((gpu) => Number.isFinite(gpu.memoryGiB));
+}
+
+function detectBroker(dockerCommand) {
+  if (!dockerCommand || process.platform !== "linux") return false;
+  const result = spawnSync(dockerCommand, ["gpu", "discover"], {
+    encoding: "utf8",
+    timeout: 10000,
+    windowsHide: true,
+  });
+  return result.status === 0;
+}
+
+function detectMacMetal(systemProfilerCommand, platform = process.platform) {
+  if (!systemProfilerCommand || platform !== "darwin") return null;
+  const result = spawnSync(systemProfilerCommand, ["SPDisplaysDataType"], {
+    encoding: "utf8",
+    timeout: 10000,
+    windowsHide: true,
+  });
+  if (result.status !== 0) return false;
+  return /Metal Support:\s*(?:Supported|Metal\b)/i.test(result.stdout);
+}
+
+function diskFreeGiB(target) {
+  let candidate = path.resolve(target);
+  while (!fs.existsSync(candidate)) {
+    const parent = path.dirname(candidate);
+    if (parent === candidate) return null;
+    candidate = parent;
+  }
+  try {
+    const stats = fs.statfsSync(candidate);
+    const available = Number(stats.bavail ?? stats.bfree);
+    return available * Number(stats.bsize) / GIB;
+  } catch (_) {
+    return null;
+  }
+}
+
+function hasLinuxDesktopSession(env = process.env) {
+  if (env.DISPLAY || env.WAYLAND_DISPLAY) return true;
+  const uid = typeof process.getuid === "function" ? process.getuid() : null;
+  if (uid === null) return false;
+  const runtime = env.XDG_RUNTIME_DIR || `/run/user/${uid}`;
+  try {
+    const entries = fs.readdirSync(runtime);
+    const displaySocket = entries.some((entry) => entry.startsWith("wayland-"));
+    const bus = fs.existsSync(path.join(runtime, "bus"));
+    if (displaySocket && bus) return true;
+  } catch (_) {
+    // No recoverable user runtime directory.
+  }
+  try {
+    return fs.readdirSync("/tmp/.X11-unix").some((entry) => entry.startsWith("X"));
+  } catch (_) {
+    return false;
+  }
+}
+
+function requiredCommands(platform, brokerManaged) {
+  if (platform === "win32") {
+    return ["git", "cmake", "ffmpeg", "ollama", "powershell", "py"];
+  }
+  if (platform === "darwin") {
+    return ["bash", "git", "cmake", "ffmpeg", "ollama", "python3", "system_profiler", "xcrun"];
+  }
+  const commands = ["bash", "git", "cmake", "ffmpeg", "ollama", "python3", "sudo", "systemctl"];
+  if (brokerManaged) commands.push("docker", "jq", "ss");
+  return commands;
+}
+
+function platformSupport(platform, arch, tegra) {
+  if (!new Set(["linux", "darwin", "win32"]).has(platform)) {
+    return `Unsupported operating system: ${platform}.`;
+  }
+  if (tegra && arch !== "arm64") {
+    return `Tegra was detected with unexpected architecture ${arch}.`;
+  }
+  if (platform === "darwin" && !new Set(["arm64", "x64"]).has(arch)) {
+    return `Unsupported macOS architecture: ${arch}.`;
+  }
+  if (platform === "win32" && arch !== "x64") {
+    return `Windows CUDA deployment currently requires x64, not ${arch}.`;
+  }
+  return null;
+}
+
+function inspectHost(options = {}) {
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+  const env = options.env || process.env;
+  const compatible = platform === "linux" ? readTegraCompatible() : "";
+  const tegra = /^nvidia,tegra\d+/m.test(compatible);
+  const nvidiaSmi = findCommand("nvidia-smi", env, platform);
+  const gpus = tegra ? [] : detectNvidiaGpus(nvidiaSmi);
+  const systemProfiler = findCommand("system_profiler", env, platform);
+  const metalSupported = platform === "darwin" ? detectMacMetal(systemProfiler, platform) : null;
+  const docker = findCommand("docker", env, platform);
+  const brokerManaged = !tegra && detectBroker(docker);
+  const totalMemoryGiB = os.totalmem() / GIB;
+  const freeMemoryGiB = os.freemem() / GIB;
+  const maxGpuMemoryGiB = gpus.length ? Math.max(...gpus.map((gpu) => gpu.memoryGiB)) : null;
+  const dependencyNames = requiredCommands(platform, brokerManaged);
+  const dependencies = Object.fromEntries(dependencyNames.map((name) => [name, findCommand(name, env, platform)]));
+  const missingDependencies = Object.entries(dependencies).filter(([, value]) => !value).map(([name]) => name);
+  let supportError = platformSupport(platform, arch, tegra);
+  if (!supportError && platform === "darwin" && metalSupported !== true) {
+    supportError = "A Metal-capable macOS GPU was not detected.";
+  }
+  if (!supportError && !tegra && platform !== "darwin" && gpus.length === 0) {
+    supportError = "No discrete NVIDIA CUDA GPU was detected.";
+  }
+  const indicatorAvailable = platform === "linux";
+  const desktopSessionDetected = platform === "linux" && hasLinuxDesktopSession(env);
+  const installTarget = options.installTarget || os.homedir();
+
+  const host = {
+    platform,
+    arch,
+    tegra,
+    tegraSoc: (compatible.match(/^nvidia,(tegra\d+)/m) || [])[1] || null,
+    totalMemoryGiB,
+    freeMemoryGiB,
+    diskFreeGiB: diskFreeGiB(installTarget),
+    gpus,
+    maxGpuMemoryGiB,
+    metalSupported,
+    brokerManaged,
+    indicatorAvailable,
+    desktopSessionDetected,
+    dependencies,
+    missingDependencies,
+    supportError,
+    runningAsRoot: platform !== "win32" && typeof process.getuid === "function" && process.getuid() === 0,
+  };
+  host.profiles = evaluateProfiles(host);
+  return host;
+}
+
+module.exports = {
+  detectNvidiaGpus,
+  detectMacMetal,
+  diskFreeGiB,
+  findCommand,
+  hasLinuxDesktopSession,
+  inspectHost,
+  platformSupport,
+  requiredCommands,
+};