@oracle-agent/oracle 0.8.0 → 0.9.0

package/src/cli/oracle-harness.py

@@ -1,23 +1,80 @@
+#!/usr/bin/env python3
 import importlib
 import importlib.abc
 import importlib.machinery
-import re
+import json
+import os
+import shutil
+import subprocess
 import sys
 
-LOGO = (
-    "                 _",
-    " ___ _ _ __ _ __| |___",
-    "/ _ \\ '_/ _` / _| / -_)",
-    "\\___/_| \\__,_\\__|_\\___|",
+
+WORDMARK = (
+    "                                       ████          ",
+    "                                      ░░███          ",
+    "  ██████  ████████   ██████    ██████  ░███   ██████ ",
+    " ███░░███░░███░░███ ░░░░░███  ███░░███ ░███  ███░░███",
+    "░███ ░███ ░███ ░░░   ███████ ░███ ░░░  ░███ ░███████ ",
+    "░███ ░███ ░███      ███░░███ ░███  ███ ░███ ░███░░░  ",
+    "░░██████  █████    ░░████████░░██████  █████░░██████  ",
+    " ░░░░░░  ░░░░░      ░░░░░░░░  ░░░░░░  ░░░░░  ░░░░░░   ",
 )
 
-SILENT_STDERR = {
+SILENT_OUTPUT = {
     "[anthropic_billing_bypass] Bypass installed",
     "[anthropic_billing_bypass] Transport unwrap hook installed",
 }
 
 
-class OracleStderr:
+def _oracle_chain(command):
+    node = os.environ.get("ORACLE_NODE_BIN")
+    entry = os.environ.get("ORACLE_CLI_ENTRY")
+    if not node or not entry:
+        return False, "oracle chain is unavailable in this session"
+
+    parts = command.strip().split()[1:]
+    args = parts or ["list"]
+    try:
+        result = subprocess.run(
+            [node, entry, "chain", *args],
+            capture_output=True,
+            text=True,
+            timeout=15,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return False, f"oracle chain failed: {exc}"
+
+    output = "\n".join(
+        part.strip() for part in (result.stdout, result.stderr) if part.strip()
+    )
+    if result.returncode != 0:
+        return False, output or "oracle chain failed"
+
+    state = subprocess.run(
+        [node, entry, "chain", "show", "--json"],
+        capture_output=True,
+        text=True,
+        timeout=15,
+        check=False,
+    )
+    if state.returncode in (0, 1):
+        try:
+            active = json.loads(state.stdout).get("active") or {}
+            if active:
+                os.environ["ORACLE_ACTIVE_CHAIN"] = str(active.get("key", ""))
+                os.environ["ORACLE_ACTIVE_CHAIN_ID"] = str(active.get("chainId", ""))
+                os.environ["ORACLE_ACTIVE_AGENT"] = str(active.get("agent", ""))
+            else:
+                os.environ.pop("ORACLE_ACTIVE_CHAIN", None)
+                os.environ.pop("ORACLE_ACTIVE_CHAIN_ID", None)
+                os.environ.pop("ORACLE_ACTIVE_AGENT", None)
+        except (TypeError, ValueError):
+            pass
+    return True, output
+
+
+class OracleOutput:
     def __init__(self, wrapped):
         self.wrapped = wrapped
 
@@ -25,8 +82,12 @@ class OracleStderr:
         kept = "".join(
             line
             for line in data.splitlines(keepends=True)
-            if line.rstrip("\r\n") not in SILENT_STDERR
+            if line.rstrip("\r\n") not in SILENT_OUTPUT
         )
+        kept = kept.replace("hermes model", "oracle model")
+        kept = kept.replace("hermes --resume", "oracle --resume")
+        kept = kept.replace("hermes -c", "oracle -c")
+        kept = kept.replace(" in ~/.hermes/.env", " through oracle model")
         if kept:
             self.wrapped.write(kept)
         return len(data)
@@ -39,74 +100,167 @@ class OracleStderr:
 
 
 def patch_cli(module):
-    hermes_cli = getattr(module, "HermesCLI")
-    original_layout = hermes_cli._build_tui_layout_children
-    original_emit = hermes_cli._emit_stream_text
-    original_flush = hermes_cli._flush_stream
-    original_cprint = getattr(module, "_cprint")
-    frame_filter = [0]
-
-    def cprint(text="", *args, **kwargs):
-        if frame_filter[0] and isinstance(text, str):
-            plain = re.sub(r"\x1b\[[0-9;]*m", "", text).lstrip("\n")
-            if plain.startswith("\u256d\u2500oracle") or plain.startswith("\u2570"):
-                return None
-        return original_cprint(text, *args, **kwargs)
-
-    setattr(module, "_cprint", cprint)
+    cls = getattr(module, "HermesCLI", None)
+    if cls is None or getattr(cls, "_oracle_patched", False):
+        return
+
+    original_style = getattr(cls, "_build_tui_style_dict", None)
+    original_process_command = cls.process_command
 
     def show_banner(self):
+        from rich.align import Align
+        from rich.panel import Panel
+        from rich.text import Text
+
         self.console.clear()
-        self._console_print()
-        for line in LOGO:
-            self._console_print(f"[#e6edf3]{line}[/]")
-        self._console_print()
+        width = shutil.get_terminal_size((100, 28)).columns
+        body = Text(justify="center")
+        if width >= 72:
+            colors = (
+                "#B8F0FF",
+                "#B8F0FF",
+                "#ACDEEF",
+                "#A5D9EB",
+                "#9FCBDD",
+                "#9FCBDD",
+                "#ACDEEF",
+                "#B8F0FF",
+            )
+            for index, line in enumerate(WORDMARK):
+                body.append(line.rstrip(), style=f"bold {colors[index]}")
+                if index != len(WORDMARK) - 1:
+                    body.append("\n")
+        else:
+            body.append("oracle", style="bold #B8F0FF")
+
+        body.append("\n\nTHE FUTURE IS AGENTIC", style="bold #EAF2F8")
+        body.append("  /  ", style="#52606D")
+        model = str(getattr(self, "model", "") or "choose model")
+        body.append(model, style="#91A2B1")
+        body.append("\n\n/model   /chain   /setup", style="#60717F")
+
+        panel_width = min(max(66, 66 if width >= 72 else 34), max(width - 4, 34))
+        panel = Panel(
+            Align.center(body),
+            width=panel_width,
+            padding=(0, 2),
+            border_style="#455867",
+        )
+        self.console.print(Align.center(panel))
+        self.console.print()
 
     def prompt_fragments(self):
-        if self._approval_state or getattr(self, "_slash_confirm_state", None):
-            marker = "!"
-        elif self._clarify_state or self._clarify_freetext:
-            marker = "?"
-        elif self._command_running or self._agent_running:
-            marker = "..."
-        else:
-            marker = ">"
-        return [("class:prompt", f"oracle {marker} ")]
-
-    def layout_children(self, **kwargs):
-        kwargs["status_bar"] = None
-        kwargs["input_rule_top"] = None
-        kwargs["input_rule_bot"] = None
-        return original_layout(self, **kwargs)
-
-    def emit_stream_text(self, text):
-        first = not self._stream_box_opened
-        if first:
-            original_cprint()
-        frame_filter[0] += 1
-        try:
-            return original_emit(self, text)
-        finally:
-            frame_filter[0] -= 1
+        if getattr(self, "_voice_recording", False):
+            return [("class:voice-recording", "recording ")]
+        if getattr(self, "_voice_processing", False):
+            return [("class:voice-processing", "transcribing ")]
+        if getattr(self, "_sudo_state", None) or getattr(self, "_secret_state", None):
+            return [("class:sudo-prompt", "secure › ")]
+        if getattr(self, "_approval_state", None) or getattr(self, "_slash_confirm_state", None):
+            return [("class:prompt-working", "confirm › ")]
+        if getattr(self, "_clarify_freetext", False):
+            return [("class:clarify-selected", "answer › ")]
+        if getattr(self, "_clarify_state", None):
+            return [("class:prompt-working", "choose › ")]
+        if getattr(self, "_command_running", False):
+            return [("class:prompt-working", "working ")]
+        if getattr(self, "_agent_running", False):
+            return [("class:prompt-working", "thinking ")]
+        return [("class:prompt", "› ")]
 
-    def flush_stream(self):
-        frame_filter[0] += 1
-        try:
-            return original_flush(self)
-        finally:
-            frame_filter[0] -= 1
+    def layout_children(
+        self,
+        *,
+        sudo_widget,
+        secret_widget,
+        approval_widget,
+        slash_confirm_widget=None,
+        clarify_widget,
+        model_picker_widget=None,
+        spinner_widget=None,
+        spacer,
+        status_bar,
+        input_rule_top,
+        image_bar,
+        input_area,
+        input_rule_bot,
+        voice_status_bar,
+        completions_menu,
+    ):
+        from prompt_toolkit.layout.containers import HSplit, Window
+        from prompt_toolkit.widgets import Frame
+        from prompt_toolkit.widgets.base import Border
 
-    hermes_cli.show_banner = show_banner
-    hermes_cli._get_tui_prompt_fragments = prompt_fragments
-    hermes_cli._build_tui_layout_children = layout_children
-    hermes_cli._emit_stream_text = emit_stream_text
-    hermes_cli._flush_stream = flush_stream
-    tips = importlib.import_module("hermes_cli.tips")
+        Border.TOP_LEFT = "╭"
+        Border.TOP_RIGHT = "╮"
+        Border.BOTTOM_LEFT = "╰"
+        Border.BOTTOM_RIGHT = "╯"
 
-    def no_tip():
-        raise LookupError("oracle quiet startup")
+        composer = Frame(
+            HSplit([item for item in (image_bar, input_area) if item is not None]),
+            style="class:oracle-composer",
+        )
+        return [
+            item
+            for item in (
+                Window(height=0),
+                sudo_widget,
+                secret_widget,
+                approval_widget,
+                slash_confirm_widget,
+                clarify_widget,
+                model_picker_widget,
+                spinner_widget,
+                spacer,
+                composer,
+                completions_menu,
+                voice_status_bar,
+            )
+            if item is not None
+        ]
 
-    setattr(tips, "get_random_tip", no_tip)
+    def build_style(self):
+        style = original_style(self) if original_style else {}
+        style.update(
+            {
+                "frame": "bg:#0B0E11 #EAF2F8",
+                "frame.border": "#455867",
+                "frame.label": "bold #B8F0FF",
+                "oracle-composer": "bg:#0B0E11 #EAF2F8",
+                "input-area": "bg:#0B0E11 #EAF2F8",
+                "prompt": "bold #B8F0FF",
+                "prompt-working": "bold #91C2D7",
+            }
+        )
+        return style
+
+    def process_command(self, command):
+        parts = command.strip().lower().split(maxsplit=1)
+        if parts and parts[0] == "/chain":
+            ok, output = _oracle_chain(command)
+            prefix = "" if ok else "error: "
+            lines = output.splitlines() or [""]
+            for index, line in enumerate(lines):
+                module._cprint(f"{prefix if index == 0 else ''}{line}")
+            return True
+        return original_process_command(self, command)
+
+    setattr(cls, "show_banner", show_banner)
+    setattr(cls, "_get_tui_prompt_fragments", prompt_fragments)
+    setattr(cls, "_build_tui_layout_children", layout_children)
+    setattr(cls, "_build_tui_style_dict", build_style)
+    setattr(cls, "process_command", process_command)
+    setattr(cls, "_oracle_patched", True)
+
+    try:
+        tips = importlib.import_module("hermes_cli.tips")
+
+        def no_tip():
+            raise LookupError("oracle quiet startup")
+
+        setattr(tips, "get_random_tip", no_tip)
+    except Exception:
+        pass
 
 
 class OracleLoader(importlib.abc.Loader):
@@ -138,9 +292,11 @@ class OracleFinder(importlib.abc.MetaPathFinder):
 
 
 def main():
-    sys.stderr = OracleStderr(sys.stderr)
+    sys.stdout = OracleOutput(sys.stdout)
+    sys.stderr = OracleOutput(sys.stderr)
     sys.meta_path.insert(0, OracleFinder())
-    hermes_main = getattr(importlib.import_module("hermes_cli.main"), "main")
+    from hermes_cli.main import main as hermes_main
+
     return hermes_main()
 
 

package/src/cli/runtime.mjs

@@ -0,0 +1,351 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { homeDir, oracleConfigDir, ensureDir } from "./paths.mjs";
+
+export const HERMES_VERSION = "0.19.0";
+export const HERMES_PYPI = `hermes-agent==${HERMES_VERSION}`;
+const MIN_PY = [3, 11];
+const MAX_PY_EXCLUSIVE = [3, 14];
+export const UV_PYTHON = "3.13";
+export const UV_VERSION = "0.12.1";
+export const UV_INSTALLERS = Object.freeze({
+  posix: Object.freeze({
+    url: `https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/uv-installer.sh`,
+    sha256: "d3f5412d38c99f9d024901843bf98206f0d2c6dbe64df40d0b740e2751ca62c1",
+  }),
+  windows: Object.freeze({
+    url: `https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/uv-installer.ps1`,
+    sha256: "b9ec035151bfbb11d616dbd69886498d885551489eddf095ea3c0ad59f640eb0",
+  }),
+});
+
+export function verifyUvInstaller(bytes, { windows = process.platform === "win32" } = {}) {
+  const body = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
+  const spec = windows ? UV_INSTALLERS.windows : UV_INSTALLERS.posix;
+  const digest = createHash("sha256").update(body).digest("hex");
+  const text = body.toString("utf8");
+  return digest === spec.sha256 && text.length >= 1_000 && text.includes(UV_VERSION);
+}
+
+export function runtimeDir() {
+  return path.join(oracleConfigDir(), "runtime");
+}
+
+export function runtimeVenvDir() {
+  return path.join(runtimeDir(), "venv");
+}
+
+function venvBin(name) {
+  const dir = process.platform === "win32" ? "Scripts" : "bin";
+  const exe = process.platform === "win32" ? `${name}.exe` : name;
+  return path.join(runtimeVenvDir(), dir, exe);
+}
+
+export function managedHermesPath() {
+  return venvBin("hermes");
+}
+
+export function managedPythonPath() {
+  const py = venvBin("python3");
+  return fs.existsSync(py) ? py : venvBin("python");
+}
+
+export function managedUvPath() {
+  return path.join(runtimeDir(), "uv", process.platform === "win32" ? "uv.exe" : "uv");
+}
+
+export function whichBin(bin) {
+  const suffixes = process.platform === "win32" && !path.extname(bin)
+    ? ["", ".exe", ".cmd", ".bat"]
+    : [""];
+  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+    if (!dir) continue;
+    for (const suffix of suffixes) {
+      const c = path.join(dir, `${bin}${suffix}`);
+      try {
+        if (fs.existsSync(c)) return c;
+      } catch {}
+    }
+  }
+  return null;
+}
+
+function parsePyVersion(out) {
+  const m = /Python (\d+)\.(\d+)\.(\d+)/.exec(out || "");
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+
+function versionSupported(v) {
+  if (!v) return false;
+  const [maj, min] = v;
+  if (maj < MIN_PY[0] || (maj === MIN_PY[0] && min < MIN_PY[1])) return false;
+  if (maj > MAX_PY_EXCLUSIVE[0] || (maj === MAX_PY_EXCLUSIVE[0] && min >= MAX_PY_EXCLUSIVE[1])) {
+    return false;
+  }
+  return true;
+}
+
+export function findHostPython() {
+  const candidates = [
+    process.env.ORACLE_PYTHON,
+    "python3.13",
+    "python3.12",
+    "python3.11",
+    "python3",
+    "python",
+  ].filter(Boolean);
+  for (const cand of candidates) {
+    const bin = path.isAbsolute(cand) ? (fs.existsSync(cand) ? cand : null) : whichBin(cand);
+    if (!bin) continue;
+    const r = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 15_000 });
+    const v = parsePyVersion(`${r.stdout || ""}${r.stderr || ""}`);
+    if (versionSupported(v)) return { bin, version: v.join("."), source: "host" };
+  }
+  return null;
+}
+
+function uvBin() {
+  return (
+    process.env.ORACLE_UV_BIN ||
+    whichBin("uv") ||
+    (fs.existsSync(path.join(homeDir(), ".local", "bin", "uv"))
+      ? path.join(homeDir(), ".local", "bin", "uv")
+      : null) ||
+    (fs.existsSync(managedUvPath()) ? managedUvPath() : null)
+  );
+}
+
+function downloadFile(url, dest) {
+  const script = [
+    "const fs=require('node:fs');",
+    "const [url,dest]=process.argv.slice(1);",
+    "fetch(url).then(r=>{if(!r.ok)throw new Error('http '+r.status);return r.arrayBuffer()})",
+    ".then(b=>fs.writeFileSync(dest,Buffer.from(b)))",
+    ".catch(e=>{console.error(e.message);process.exit(1)});",
+  ].join("");
+  return spawnSync(process.execPath, ["-e", script, url, dest], {
+    encoding: "utf8",
+    timeout: 2 * 60_000,
+  });
+}
+
+export function installManagedUv({ quiet = false } = {}) {
+  const existing = uvBin();
+  if (existing) return { ok: true, bin: existing, reused: true };
+
+  ensureDir(runtimeDir());
+  const windows = process.platform === "win32";
+  const installer = path.join(runtimeDir(), windows ? "uv-install.ps1" : "uv-install.sh");
+  const spec = windows ? UV_INSTALLERS.windows : UV_INSTALLERS.posix;
+  const dl = downloadFile(spec.url, installer);
+  if (dl.status !== 0) {
+    return {
+      ok: false,
+      reason: `could not download the uv installer (${dl.status})`,
+      stderr: (dl.stderr || "").slice(-800),
+    };
+  }
+
+  const body = fs.readFileSync(installer);
+  if (!verifyUvInstaller(body, { windows })) {
+    return { ok: false, reason: `uv ${UV_VERSION} installer checksum mismatch` };
+  }
+
+  const installDir = path.dirname(managedUvPath());
+  ensureDir(installDir);
+  const command = windows
+    ? (whichBin("powershell.exe") || whichBin("powershell"))
+    : (whichBin("sh") || "/bin/sh");
+  if (!command) return { ok: false, reason: windows ? "PowerShell not found" : "sh not found" };
+  const args = windows
+    ? ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", installer]
+    : [installer];
+  const inst = spawnSync(command, args, {
+    stdio: quiet ? "pipe" : "inherit",
+    encoding: "utf8",
+    timeout: 5 * 60_000,
+    env: {
+      ...process.env,
+      UV_INSTALL_DIR: installDir,
+      UV_NO_MODIFY_PATH: "1",
+    },
+  });
+  if (inst.status !== 0 || !fs.existsSync(managedUvPath())) {
+    return {
+      ok: false,
+      reason: `uv install failed (${inst.status})`,
+      stderr: (inst.stderr || "").slice(-800),
+    };
+  }
+  return { ok: true, bin: managedUvPath(), reused: false };
+}
+
+export function provisionPythonViaUv({ quiet = false } = {}) {
+  const installed = installManagedUv({ quiet });
+  if (!installed.ok) return installed;
+  const uv = installed.bin;
+
+  const uvEnv = {
+    ...process.env,
+    UV_PYTHON_INSTALL_DIR: path.join(runtimeDir(), "python"),
+    UV_CACHE_DIR: path.join(runtimeDir(), "cache"),
+  };
+  const inst = spawnSync(uv, ["python", "install", "--no-bin", UV_PYTHON], {
+    stdio: quiet ? "pipe" : "inherit",
+    encoding: "utf8",
+    timeout: 15 * 60_000,
+    env: uvEnv,
+  });
+  if (inst.status !== 0) {
+    return {
+      ok: false,
+      reason: `uv python install ${UV_PYTHON} failed (${inst.status})`,
+      stderr: (inst.stderr || "").slice(-800),
+    };
+  }
+
+  const found = spawnSync(uv, ["python", "find", UV_PYTHON], {
+    encoding: "utf8",
+    timeout: 60_000,
+    env: uvEnv,
+  });
+  const bin = (found.stdout || "").trim().split(/\r?\n/)[0];
+  if (found.status !== 0 || !bin || !fs.existsSync(bin)) {
+    return { ok: false, reason: `uv could not locate python ${UV_PYTHON}` };
+  }
+  return { ok: true, bin, version: UV_PYTHON, source: "uv" };
+}
+
+/**
+ * Resolve the hermes runtime this Oracle install should use.
+ * Order: explicit override -> system PATH -> oracle-managed venv.
+ */
+export function resolveHermes() {
+  if (process.env.ORACLE_HERMES_BIN) {
+    return { ok: true, bin: process.env.ORACLE_HERMES_BIN, source: "env" };
+  }
+  const onPath = whichBin("hermes");
+  if (onPath) return { ok: true, bin: onPath, source: "path" };
+  const managed = managedHermesPath();
+  if (fs.existsSync(managed)) return { ok: true, bin: managed, source: "managed" };
+  return { ok: false, bin: null, source: null };
+}
+
+export function runtimeStatus() {
+  const resolved = resolveHermes();
+  const host = findHostPython();
+  return {
+    hermes: resolved,
+    managedVenv: runtimeVenvDir(),
+    managedInstalled: fs.existsSync(managedHermesPath()),
+    hostPython: host,
+    uv: uvBin(),
+  };
+}
+
+function run(cmd, args, { quiet }) {
+  return spawnSync(cmd, args, {
+    stdio: quiet ? "pipe" : "inherit",
+    encoding: "utf8",
+    timeout: 20 * 60_000,
+  });
+}
+
+/**
+ * Create ~/.config/oracle/runtime/venv and install hermes-agent into it.
+ * Never touches system python or global site-packages.
+ */
+export function installManagedHermes({ quiet = false, upgrade = false } = {}) {
+  let host = findHostPython();
+  if (!host) {
+    const viaUv = provisionPythonViaUv({ quiet });
+    if (viaUv.ok) {
+      host = { bin: viaUv.bin, version: viaUv.version, source: "uv" };
+    } else {
+      return {
+        ok: false,
+        reason:
+          `no supported python found (need 3.11-3.13) and uv could not provide one: ${viaUv.reason}. ` +
+          "install uv (https://docs.astral.sh/uv) or python 3.13, then re-run 'oracle bootstrap'",
+      };
+    }
+  }
+
+  ensureDir(runtimeDir());
+  const venv = runtimeVenvDir();
+  const alreadyInstalled = fs.existsSync(managedHermesPath());
+  if (alreadyInstalled && !upgrade) {
+    return { ok: true, bin: managedHermesPath(), reused: true };
+  }
+
+  if (!fs.existsSync(path.join(venv, "pyvenv.cfg"))) {
+    let mk = run(host.bin, ["-m", "venv", venv], { quiet });
+    if (mk.status !== 0 && host.source !== "uv") {
+      fs.rmSync(venv, { recursive: true, force: true });
+      const viaUv = provisionPythonViaUv({ quiet });
+      if (viaUv.ok) {
+        host = { bin: viaUv.bin, version: viaUv.version, source: "uv" };
+        mk = run(host.bin, ["-m", "venv", venv], { quiet });
+      } else {
+        return {
+          ok: false,
+          reason: `python -m venv failed (${mk.status}) and uv fallback failed: ${viaUv.reason}`,
+          stderr: (mk.stderr || "").slice(-800),
+        };
+      }
+    }
+    if (mk.status !== 0) {
+      return {
+        ok: false,
+        reason: `isolated python -m venv failed (${mk.status})`,
+        stderr: (mk.stderr || "").slice(-800),
+      };
+    }
+  }
+
+  const py = managedPythonPath();
+  if (!fs.existsSync(py)) {
+    return { ok: false, reason: `venv python missing at ${py}` };
+  }
+
+  const pipArgs = ["-m", "pip", "install", "--disable-pip-version-check"];
+  if (upgrade) pipArgs.push("--upgrade");
+  pipArgs.push(HERMES_PYPI);
+  const inst = run(py, pipArgs, { quiet });
+  if (inst.status !== 0) {
+    return {
+      ok: false,
+      reason: `pip install ${HERMES_PYPI} failed (${inst.status})`,
+      stderr: (inst.stderr || "").slice(-1200),
+    };
+  }
+
+  const bin = managedHermesPath();
+  if (!fs.existsSync(bin)) {
+    return { ok: false, reason: `hermes entrypoint not found after install (${bin})` };
+  }
+  return { ok: true, bin, reused: false, python: host.version };
+}
+
+export const runtime = {
+  HERMES_PYPI,
+  HERMES_VERSION,
+  UV_PYTHON,
+  runtimeDir,
+  runtimeVenvDir,
+  managedHermesPath,
+  managedPythonPath,
+  managedUvPath,
+  findHostPython,
+  installManagedUv,
+  provisionPythonViaUv,
+  resolveHermes,
+  runtimeStatus,
+  installManagedHermes,
+  whichBin,
+};
+
+export default runtime;