@oracle-agent/oracle 0.4.2 → 0.6.0

package/src/cli/operator-dispatch.mjs

@@ -0,0 +1,258 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(HERE, "../..");
+
+export const OPERATOR_BIN_NAMES = Object.freeze([
+  "oracle-vault",
+  "oracle-credential",
+  "oracle-signer",
+  "oracle-runner",
+  "oracle-agentic-init",
+  "oracle-agentic-doctor",
+  "oracle-control-mcp",
+  "oracle-operator-caps",
+]);
+
+export const SIGN_NOUNS = Object.freeze([
+  "vault",
+  "credential",
+  "signer",
+  "runner",
+  "sign",
+]);
+
+export const OPERATOR_NOT_INSTALLED_MESSAGE = `oracle: signing lives in @oracle-agent/operator, which is not installed.
+
+  The public 'oracle' package is prepare-only and never handles keys.
+  To enable local signing on THIS machine:
+
+    npm i -g @oracle-agent/operator      # or add it to this project
+    oracle sign init                     # provision keys + policy (interactive)
+
+  Nothing about your read/research setup is affected.
+`;
+
+export const SIGN_HINT =
+  "hint: run 'oracle sign init' to provision keys, or 'oracle sign doctor --json' for detail.";
+
+function whichOnPath(binName) {
+  const pathEnv = process.env.PATH || "";
+  const parts = pathEnv.split(path.delimiter).filter(Boolean);
+  const exts = process.platform === "win32" ? ["", ".cmd", ".exe", ".bat"] : [""];
+  for (const dir of parts) {
+    for (const ext of exts) {
+      const candidate = path.join(dir, binName + ext);
+      try {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+          return candidate;
+        }
+      } catch {
+        // ignore
+      }
+    }
+  }
+  return null;
+}
+
+function binsFromDir(binDir) {
+  const bins = {};
+  for (const name of OPERATOR_BIN_NAMES) {
+    const candidates = [
+      path.join(binDir, name),
+      path.join(binDir, `${name}.mjs`),
+      path.join(binDir, `${name}.js`),
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c) && fs.statSync(c).isFile()) {
+        bins[name] = c;
+        break;
+      }
+    }
+  }
+  return bins;
+}
+
+function findPackageRoot(entryPath) {
+  let dir = path.dirname(entryPath);
+  while (dir !== path.dirname(dir)) {
+    const pkgJson = path.join(dir, "package.json");
+    if (fs.existsSync(pkgJson)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf8"));
+        if (pkg.name === "@oracle-agent/operator") return { root: dir, pkg };
+      } catch {
+        // continue upward
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function tryResolvePackage(fromPaths) {
+  for (const from of fromPaths) {
+    try {
+      const req = createRequire(path.join(from, "package.json"));
+      let found;
+      try {
+        const pkgJson = req.resolve("@oracle-agent/operator/package.json");
+        found = {
+          root: path.dirname(pkgJson),
+          pkg: JSON.parse(fs.readFileSync(pkgJson, "utf8")),
+        };
+      } catch {
+        const entry = req.resolve("@oracle-agent/operator");
+        found = findPackageRoot(entry);
+      }
+      if (!found) continue;
+      const { root, pkg } = found;
+      const binField = pkg.bin || {};
+      const bins = {};
+      for (const [name, rel] of Object.entries(binField)) {
+        bins[name] = path.resolve(root, rel);
+      }
+      const extra = binsFromDir(path.join(root, "bin"));
+      for (const [k, v] of Object.entries(extra)) {
+        if (!bins[k]) bins[k] = v;
+      }
+      return {
+        ok: true,
+        binDir: path.join(root, "bin"),
+        version: pkg.version || "unknown",
+        bins,
+        source: `require:${from}`,
+      };
+    } catch {
+      // continue
+    }
+  }
+  return null;
+}
+
+function tryCapsOnPath() {
+  const capsBin = whichOnPath("oracle-operator-caps");
+  if (!capsBin) return null;
+  const r = spawnSync(capsBin, [], {
+    encoding: "utf8",
+    timeout: 5000,
+    env: process.env,
+  });
+  if (r.status !== 0 || !r.stdout) return null;
+  try {
+    const report = JSON.parse(r.stdout);
+    if (!report || typeof report !== "object" || !report.bins) return null;
+    return {
+      ok: true,
+      binDir: path.dirname(Object.values(report.bins)[0] || capsBin),
+      version: report.version || "unknown",
+      bins: report.bins,
+      source: "caps-path",
+      controlMcp: report.controlMcp,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function tryPathProbe() {
+  const bins = {};
+  for (const name of OPERATOR_BIN_NAMES) {
+    const hit = whichOnPath(name);
+    if (hit) bins[name] = hit;
+  }
+  if (!Object.keys(bins).length) return null;
+  return {
+    ok: true,
+    binDir: path.dirname(Object.values(bins)[0]),
+    version: "unknown",
+    bins,
+    source: "path-probe",
+  };
+}
+
+export function resolveOperator() {
+  const envDir = process.env.ORACLE_OPERATOR_BIN_DIR;
+  if (envDir) {
+    const abs = path.resolve(envDir);
+    if (!fs.existsSync(abs)) return { ok: false };
+    const bins = binsFromDir(abs);
+    if (!Object.keys(bins).length) return { ok: false };
+    let version = "unknown";
+    const pkgCandidate = path.resolve(abs, "../package.json");
+    if (fs.existsSync(pkgCandidate)) {
+      try {
+        version = JSON.parse(fs.readFileSync(pkgCandidate, "utf8")).version || version;
+      } catch {
+        // ignore
+      }
+    }
+    return { ok: true, binDir: abs, version, bins, source: "env:ORACLE_OPERATOR_BIN_DIR" };
+  }
+
+  const fromPkg =
+    tryResolvePackage([process.cwd(), PACKAGE_ROOT]) ||
+    tryCapsOnPath() ||
+    tryPathProbe();
+  return fromPkg || { ok: false };
+}
+
+export function printOperatorNotInstalled(stream = process.stderr) {
+  stream.write(OPERATOR_NOT_INSTALLED_MESSAGE);
+  if (!OPERATOR_NOT_INSTALLED_MESSAGE.endsWith("\n")) stream.write("\n");
+}
+
+export function dispatchOperator(binName, argv = [], opts = {}) {
+  const resolved = resolveOperator();
+  if (!resolved.ok) {
+    printOperatorNotInstalled(opts.stderr || process.stderr);
+    return 3;
+  }
+  const binPath = resolved.bins[binName];
+  if (!binPath) {
+    const err = opts.stderr || process.stderr;
+    err.write(`oracle: operator bin '${binName}' not found in resolved operator (${resolved.source})\n`);
+    return 3;
+  }
+
+  const stdio = opts.stdio || "inherit";
+  const isJs = /\.(mjs|cjs|js)$/.test(binPath);
+  const command = isJs ? process.execPath : binPath;
+  const args = isJs ? [binPath, ...argv] : [...argv];
+  const r = spawnSync(command, args, {
+    stdio,
+    env: opts.env || process.env,
+    cwd: opts.cwd || process.cwd(),
+    encoding: stdio === "pipe" ? "utf8" : undefined,
+  });
+
+  if (r.error) {
+    const err = opts.stderr || process.stderr;
+    err.write(`oracle: failed to spawn ${binName}: ${r.error.message}\n`);
+    return 1;
+  }
+
+  const code = typeof r.status === "number" ? r.status : 1;
+  if (code !== 0 && opts.appendHintOnError) {
+    const err = opts.stderr || process.stderr;
+    err.write(SIGN_HINT + "\n");
+  }
+  if (stdio === "pipe") {
+    return { code, stdout: r.stdout || "", stderr: r.stderr || "" };
+  }
+  return code;
+}
+
+export default {
+  resolveOperator,
+  dispatchOperator,
+  printOperatorNotInstalled,
+  OPERATOR_NOT_INSTALLED_MESSAGE,
+  SIGN_HINT,
+  SIGN_NOUNS,
+  OPERATOR_BIN_NAMES,
+};

package/src/cli/oracle-harness.py

@@ -0,0 +1,148 @@
+import importlib
+import importlib.abc
+import importlib.machinery
+import re
+import sys
+
+LOGO = (
+    "                 _",
+    " ___ _ _ __ _ __| |___",
+    "/ _ \\ '_/ _` / _| / -_)",
+    "\\___/_| \\__,_\\__|_\\___|",
+)
+
+SILENT_STDERR = {
+    "[anthropic_billing_bypass] Bypass installed",
+    "[anthropic_billing_bypass] Transport unwrap hook installed",
+}
+
+
+class OracleStderr:
+    def __init__(self, wrapped):
+        self.wrapped = wrapped
+
+    def write(self, data):
+        kept = "".join(
+            line
+            for line in data.splitlines(keepends=True)
+            if line.rstrip("\r\n") not in SILENT_STDERR
+        )
+        if kept:
+            self.wrapped.write(kept)
+        return len(data)
+
+    def flush(self):
+        return self.wrapped.flush()
+
+    def __getattr__(self, name):
+        return getattr(self.wrapped, name)
+
+
+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)
+
+    def show_banner(self):
+        self.console.clear()
+        self._console_print()
+        for line in LOGO:
+            self._console_print(f"[#e6edf3]{line}[/]")
+        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
+
+    def flush_stream(self):
+        frame_filter[0] += 1
+        try:
+            return original_flush(self)
+        finally:
+            frame_filter[0] -= 1
+
+    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")
+
+    def no_tip():
+        raise LookupError("oracle quiet startup")
+
+    setattr(tips, "get_random_tip", no_tip)
+
+
+class OracleLoader(importlib.abc.Loader):
+    def __init__(self, wrapped):
+        self.wrapped = wrapped
+
+    def create_module(self, spec):
+        if hasattr(self.wrapped, "create_module"):
+            return self.wrapped.create_module(spec)
+        return None
+
+    def exec_module(self, module):
+        self.wrapped.exec_module(module)
+        patch_cli(module)
+
+
+class OracleFinder(importlib.abc.MetaPathFinder):
+    def find_spec(self, fullname, path, target=None):
+        if fullname != "cli":
+            return None
+        try:
+            sys.meta_path.remove(self)
+        except ValueError:
+            pass
+        spec = importlib.machinery.PathFinder.find_spec(fullname, path)
+        if spec and spec.loader:
+            spec.loader = OracleLoader(spec.loader)
+        return spec
+
+
+def main():
+    sys.stderr = OracleStderr(sys.stderr)
+    sys.meta_path.insert(0, OracleFinder())
+    hermes_main = getattr(importlib.import_module("hermes_cli.main"), "main")
+    return hermes_main()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/cli/paths.mjs

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+export const PACKAGE_ROOT = path.resolve(HERE, "../..");
+
+export function homeDir() {
+  return process.env.ORACLE_FAKE_HOME || os.homedir();
+}
+
+export function oracleConfigDir() {
+  return path.join(homeDir(), ".config", "oracle");
+}
+
+export function oracleExecEnvPath() {
+  return path.join(oracleConfigDir(), "exec.env");
+}
+
+export function hermesRoot() {
+  if (process.env.HERMES_HOME) return path.resolve(process.env.HERMES_HOME);
+  return path.join(homeDir(), ".hermes");
+}
+
+export function claudeCodeUserConfigPath() {
+  return path.join(homeDir(), ".claude.json");
+}
+
+export function claudeCodeProjectMcpPath(cwd = process.cwd()) {
+  return path.join(cwd, ".mcp.json");
+}
+
+export function claudeDesktopConfigPath() {
+  if (process.platform === "darwin") {
+    return path.join(homeDir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  return path.join(homeDir(), ".config", "Claude", "claude_desktop_config.json");
+}
+
+export function codexConfigPath() {
+  return path.join(homeDir(), ".codex", "config.toml");
+}
+
+export function chatgptConnectorDir() {
+  return path.join(oracleConfigDir(), "connectors");
+}
+
+export function chatgptOpenApiPath() {
+  return path.join(chatgptConnectorDir(), "chatgpt-openapi.json");
+}
+
+export function activeChainPath() {
+  return path.join(oracleConfigDir(), "active-chain.json");
+}
+
+export function packageBin(name) {
+  return path.join(PACKAGE_ROOT, "bin", name);
+}
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export const paths = {
+  homeDir,
+  oracleConfigDir,
+  oracleExecEnvPath,
+  hermesRoot,
+  activeChainPath,
+  claudeCodeUserConfigPath,
+  claudeCodeProjectMcpPath,
+  claudeDesktopConfigPath,
+  codexConfigPath,
+  chatgptConnectorDir,
+  chatgptOpenApiPath,
+  packageBin,
+  ensureDir,
+  PACKAGE_ROOT,
+};
+
+export default paths;

package/src/cli/setup-state.mjs

@@ -0,0 +1,168 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  listMessagingPlatforms,
+  findMessagingPlatform,
+  renderSetupMenu,
+} from "./messaging-platforms.mjs";
+import { hermesRoot, ensureDir, oracleConfigDir } from "./paths.mjs";
+
+const SECRETISH = /(TOKEN|SECRET|PASSWORD|KEY|AUTH|PRIVATE|MNEMONIC|SEED)/i;
+
+export function profileEnvPath(profile = "oracle") {
+  return path.join(hermesRoot(), "profiles", profile, ".env");
+}
+
+export function parseDotEnv(text) {
+  const out = {};
+  for (const line of String(text || "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let val = trimmed.slice(eq + 1).trim();
+    if (
+      (val.startsWith('"') && val.endsWith('"')) ||
+      (val.startsWith("'") && val.endsWith("'"))
+    ) {
+      val = val.slice(1, -1);
+    }
+    out[key] = val;
+  }
+  return out;
+}
+
+export function readProfileEnv(profile = "oracle") {
+  const p = profileEnvPath(profile);
+  if (!fs.existsSync(p)) return {};
+  return parseDotEnv(fs.readFileSync(p, "utf8"));
+}
+
+export function writeProfileEnvKey(profile, key, value) {
+  if (!key || SECRETISH.test(key) === false && /[^A-Z0-9_]/.test(key)) {
+    // keep simple env keys
+  }
+  if (!/^[A-Z][A-Z0-9_]*$/.test(key)) {
+    const err = new Error(`invalid env key '${key}'`);
+    err.code = "BAD_KEY";
+    throw err;
+  }
+  if (value == null || String(value).trim() === "") {
+    const err = new Error(`empty value for ${key}`);
+    err.code = "EMPTY";
+    throw err;
+  }
+  const p = profileEnvPath(profile);
+  ensureDir(path.dirname(p));
+  let text = fs.existsSync(p) ? fs.readFileSync(p, "utf8") : "";
+  const lines = text ? text.split(/\r?\n/) : [];
+  const next = [];
+  let replaced = false;
+  const assignment = `${key}=${String(value)}`;
+  for (const line of lines) {
+    if (line.startsWith(`${key}=`)) {
+      next.push(assignment);
+      replaced = true;
+    } else if (line.length || next.length) {
+      next.push(line);
+    }
+  }
+  if (!replaced) {
+    if (next.length && next[next.length - 1] !== "") next.push("");
+    next.push(assignment);
+  }
+  while (next.length && next[next.length - 1] === "") next.pop();
+  next.push("");
+  fs.writeFileSync(p, next.join("\n"), { mode: 0o600 });
+  try {
+    fs.chmodSync(p, 0o600);
+  } catch {
+    // best effort on platforms that ignore mode
+  }
+  return { path: p, key, set: true };
+}
+
+export function platformStatus(profile = "oracle") {
+  const env = readProfileEnv(profile);
+  const statuses = {};
+  for (const p of listMessagingPlatforms()) {
+    if (!p.required.length) {
+      statuses[p.key] = "manual";
+      continue;
+    }
+    const missing = p.required.filter((k) => !String(env[k] || "").trim());
+    statuses[p.key] = missing.length ? "unset" : "ready";
+  }
+  return { profile, statuses, envPath: profileEnvPath(profile) };
+}
+
+export function renderStatus(profile = "oracle") {
+  const { statuses } = platformStatus(profile);
+  return renderSetupMenu({ profile, statuses });
+}
+
+export function setPlatformToken(profile, platformKey, token, extra = {}) {
+  const platform = findMessagingPlatform(platformKey);
+  if (!platform) {
+    const err = new Error(`unknown platform '${platformKey}'`);
+    err.code = "UNKNOWN_PLATFORM";
+    throw err;
+  }
+  if (!platform.required.length) {
+    const err = new Error(
+      `${platform.key} uses hermes interactive setup (oracle setup messaging)`,
+    );
+    err.code = "NEEDS_INTERACTIVE";
+    throw err;
+  }
+  const primary = platform.required[0];
+  writeProfileEnvKey(profile, primary, token);
+  for (const [k, v] of Object.entries(extra || {})) {
+    if (v != null && String(v).trim()) writeProfileEnvKey(profile, k, v);
+  }
+  return {
+    platform: platform.key,
+    set: platform.required,
+    profile,
+    path: profileEnvPath(profile),
+  };
+}
+
+export function setupStatePath() {
+  return path.join(oracleConfigDir(), "setup-state.json");
+}
+
+export function touchSetupState(patch = {}) {
+  ensureDir(oracleConfigDir());
+  const p = setupStatePath();
+  let cur = {};
+  if (fs.existsSync(p)) {
+    try {
+      cur = JSON.parse(fs.readFileSync(p, "utf8"));
+    } catch {
+      cur = {};
+    }
+  }
+  const next = {
+    ...cur,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+    host: os.hostname(),
+  };
+  fs.writeFileSync(p, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+  return next;
+}
+
+export default {
+  profileEnvPath,
+  parseDotEnv,
+  readProfileEnv,
+  writeProfileEnvKey,
+  platformStatus,
+  renderStatus,
+  setPlatformToken,
+  setupStatePath,
+  touchSetupState,
+};

package/src/cli/spawn-child.mjs

@@ -0,0 +1,43 @@
+import { spawn } from "node:child_process";
+
+const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+
+export function spawnChild(command, args = [], options = {}, label = command) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, options);
+    let settled = false;
+    let forwardedSignal = null;
+
+    const handlers = new Map(
+      FORWARDED_SIGNALS.map((signal) => [signal, () => {
+        forwardedSignal ||= signal;
+        if (child.exitCode === null && child.signalCode === null) child.kill(signal);
+      }]),
+    );
+    for (const [signal, handler] of handlers) process.on(signal, handler);
+
+    const cleanup = () => {
+      for (const [signal, handler] of handlers) process.off(signal, handler);
+    };
+
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      process.stderr.write(`oracle: could not start ${label}: ${error.message}\n`);
+      resolve(1);
+    });
+
+    child.once("exit", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      const propagated = forwardedSignal || signal;
+      if (propagated) {
+        process.kill(process.pid, propagated);
+        return;
+      }
+      resolve(code ?? 1);
+    });
+  });
+}