@oracle-agent/oracle 0.9.8 → 0.11.0

package/src/cli/commands/auth.mjs

@@ -0,0 +1,193 @@
+import { writeModelConfig } from "../model-config.mjs";
+import {
+  getOAuthStore,
+  loginOAuth,
+  oauthProviderConfig,
+  oauthProviderId,
+} from "../../auth/oauth.mjs";
+
+const API_PROVIDERS = Object.freeze({
+  openrouter: { model: "openrouter/auto" },
+  openai: { model: "gpt-4.1-mini" },
+  xai: { model: "grok-4.5" },
+  deepseek: { model: "deepseek-chat" },
+  gemini: { model: "gemini-2.5-flash" },
+  custom: { model: "" },
+});
+
+function option(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 && args[index + 1] ? args[index + 1] : "";
+}
+
+async function readAllStdin() {
+  let value = "";
+  for await (const chunk of process.stdin) value += chunk;
+  return value.trim();
+}
+
+function readHidden(prompt = "API key: ") {
+  if (!process.stdin.isTTY || !process.stdin.setRawMode) {
+    throw new Error("non-interactive API-key input requires --stdin");
+  }
+  process.stdout.write(prompt);
+  return new Promise((resolve, reject) => {
+    let value = "";
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write("\n");
+    };
+    const onData = (chunk) => {
+      const text = String(chunk);
+      for (const character of text) {
+        if (character === "\r" || character === "\n") {
+          cleanup();
+          resolve(value.trim());
+          return;
+        }
+        if (character === "\u0003") {
+          cleanup();
+          reject(new Error("cancelled"));
+          return;
+        }
+        if (character === "\u007f" || character === "\b") value = value.slice(0, -1);
+        else value += character;
+      }
+    };
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+
+function selection(provider, model, { baseUrl = "" } = {}) {
+  if (!model) throw new Error(`${provider} provider requires --model`);
+  const config = { backend: "standalone", provider, model };
+  if (provider === "custom") {
+    if (!baseUrl) throw new Error("custom provider requires --base-url");
+    config.baseUrl = baseUrl;
+  }
+  return config;
+}
+
+function saveSelection(provider, model, options = {}) {
+  return writeModelConfig(selection(provider, model, options));
+}
+
+function printStatus(status) {
+  process.stdout.write(`storage: ${status.storage}\n`);
+  const oauth = Object.entries(status.providers || {});
+  const apiKeys = Object.entries(status.apiKeys || {});
+  if (!oauth.length && !apiKeys.length) {
+    process.stdout.write("no credentials configured\n");
+    return;
+  }
+  for (const [provider, value] of oauth) {
+    const expiry = value.expiresAt ? new Date(value.expiresAt).toISOString() : "unknown";
+    process.stdout.write(`${provider}: ${value.loggedIn ? "logged in" : "missing"}, expires ${expiry}\n`);
+  }
+  for (const [provider, value] of apiKeys) {
+    process.stdout.write(`${provider}: API key ${value.configured ? "configured" : "missing"}\n`);
+  }
+}
+
+function usage() {
+  return [
+    "oracle auth, configure OAuth or API-key authentication",
+    "",
+    "  oracle auth login claude|codex|grok [--model MODEL] [--no-browser]",
+    "  oracle auth api-key PROVIDER [--model MODEL] [--base-url URL]",
+    "  printf '%s\\n' \"$KEY\" | oracle auth api-key PROVIDER --stdin",
+    "  oracle auth status [--json]",
+    "  oracle auth logout PROVIDER",
+    "",
+    "OAuth and API keys are additive. Select any compatible model with oracle model --provider PROVIDER --model MODEL.",
+  ].join("\n");
+}
+
+export default {
+  name: "auth",
+  summary: "login with Claude, Codex, or Grok OAuth; store provider API keys",
+  group: "read",
+  usage: usage(),
+  async run(ctx) {
+    const args = [...ctx.argv];
+    const action = args.shift() || "status";
+    const store = getOAuthStore();
+    try {
+      if (action === "status") {
+        const status = store.status();
+        if (args.includes("--json")) process.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+        else printStatus(status);
+        return 0;
+      }
+
+      if (action === "login") {
+        const requested = args.find((value) => !value.startsWith("-"));
+        if (!requested) throw new Error("usage: oracle auth login claude|codex|grok");
+        const config = oauthProviderConfig(requested);
+        const model = option(args, "--model") || config.model;
+        selection(config.id, model);
+        const credential = await loginOAuth(config.id, {
+          openFn: args.includes("--no-browser") ? () => false : undefined,
+        });
+        await store.withLock(async () => {
+          const previous = store.get(config.id);
+          store.set(config.id, credential);
+          try {
+            saveSelection(config.id, model);
+          } catch (error) {
+            if (previous) store.set(config.id, previous);
+            else store.remove(config.id);
+            throw error;
+          }
+        });
+        process.stdout.write(`${config.id}: logged in, stored in ${store.storage}\n`);
+        return 0;
+      }
+
+      if (action === "api-key") {
+        const provider = String(args.find((value) => !value.startsWith("-")) || "").trim().toLowerCase();
+        if (!provider) throw new Error("usage: oracle auth api-key PROVIDER [--stdin]");
+        if (!Object.hasOwn(API_PROVIDERS, provider)) throw new Error(`unsupported API-key provider: ${provider}`);
+        const model = option(args, "--model") || API_PROVIDERS[provider].model;
+        const baseUrl = option(args, "--base-url");
+        selection(provider, model, { baseUrl });
+        const apiKey = args.includes("--stdin") ? await readAllStdin() : await readHidden();
+        await store.withLock(async () => {
+          const previous = store.getApiKey(provider);
+          store.setApiKey(provider, apiKey);
+          try {
+            saveSelection(provider, model, { baseUrl });
+          } catch (error) {
+            if (previous) store.setApiKey(provider, previous);
+            else store.removeApiKey(provider);
+            throw error;
+          }
+        });
+        process.stdout.write(`${provider}: API key configured in ${store.storage}\n`);
+        return 0;
+      }
+
+      if (action === "logout") {
+        const requested = String(args.find((value) => !value.startsWith("-")) || "").trim().toLowerCase();
+        if (!requested) throw new Error("usage: oracle auth logout PROVIDER");
+        let removedOAuth = false;
+        try {
+          removedOAuth = store.remove(oauthProviderId(requested));
+        } catch {}
+        const removedApiKey = store.removeApiKey(requested);
+        if (!removedOAuth && !removedApiKey) throw new Error(`${requested}: no local credential found`);
+        process.stdout.write(`${requested}: local credential removed\n`);
+        return 0;
+      }
+
+      throw new Error(`unknown auth action: ${action}`);
+    } catch (error) {
+      process.stderr.write(`oracle auth: ${error.message}\n`);
+      return 1;
+    }
+  },
+};

package/src/cli/commands/bootstrap.mjs

@@ -7,7 +7,7 @@ import {
 
 function usage() {
   return [
-    "oracle bootstrap - install the local agent runtime oracle chat needs",
+    "oracle bootstrap - optionally install an isolated Hermes compatibility runtime",
     "",
     "  oracle bootstrap            install into ~/.config/oracle/runtime/venv",
     "  oracle bootstrap --upgrade  upgrade the managed runtime",
@@ -22,7 +22,7 @@ function usage() {
 
 export default {
   name: "bootstrap",
-  summary: "install the local agent runtime for oracle chat",
+  summary: "optionally install a Hermes compatibility runtime",
   group: "read",
   usage: usage(),
   async run(ctx) {

package/src/cli/commands/chat.mjs

@@ -3,9 +3,13 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { PACKAGE_ROOT, hermesRoot, ensureDir } from "../paths.mjs";
 import { activeChainEnv } from "../chain-state.mjs";
+import { readModelConfig } from "../model-config.mjs";
 import { spawnChild } from "../spawn-child.mjs";
-import { installManagedHermes, resolveHermes } from "../runtime.mjs";
+import { resolveHermes } from "../runtime.mjs";
 import { runOracleTui } from "../../tui/app.mjs";
+import { resolveChatBackend } from "../../tui/backend.mjs";
+import { createStandaloneClient, runStandaloneQuery } from "../../tui/standalone-client.mjs";
+import { getOAuthStore } from "../../auth/oauth.mjs";
 
 const PROFILE = "oracle";
 const SKIN_NAME = "oracle";
@@ -24,30 +28,6 @@ function which(bin) {
   return null;
 }
 
-/**
- * First-run bootstrap. Only fires for a real interactive TTY so scripts,
- * pipes, and CI never trigger a multi-minute install.
- */
-function ensureRuntime() {
-  const found = resolveHermes();
-  if (found.ok) return found.bin;
-  if (process.env.ORACLE_NO_BOOTSTRAP === "1") return null;
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return null;
-
-  process.stdout.write(
-    "oracle needs a local agent runtime for chat (one-time setup).\n" +
-      "installing into ~/.config/oracle/runtime/venv, a few minutes.\n\n",
-  );
-  const r = installManagedHermes();
-  if (!r.ok) {
-    process.stderr.write(`oracle: runtime setup failed: ${r.reason}\n`);
-    if (r.stderr) process.stderr.write(`${r.stderr}\n`);
-    return null;
-  }
-  process.stdout.write("\nruntime ready.\n\n");
-  return r.bin;
-}
-
 function pythonShebang(file) {
   try {
     const first = fs.readFileSync(file, "utf8").split(/\r?\n/, 1)[0];
@@ -291,6 +271,38 @@ function printBanner() {
   process.stdout.write(centerBlock(lines, terminalColumns()).join("\n") + "\n");
 }
 
+function parseLaunchArgs(args) {
+  const parsed = { pass: [], query: null, model: null, provider: null };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if ((arg === "--model" || arg === "-m") && args[i + 1]) {
+      parsed.model = args[++i];
+      parsed.pass.push("--model", parsed.model);
+      continue;
+    }
+    if (arg === "--provider" && args[i + 1]) {
+      parsed.provider = args[++i];
+      parsed.pass.push("--provider", parsed.provider);
+      continue;
+    }
+    if ((arg === "-q" || arg === "--query") && args[i + 1]) {
+      parsed.query = args[++i];
+      parsed.pass.push("-q", parsed.query);
+      continue;
+    }
+    if (arg === "--quiet" || arg === "-Q") {
+      parsed.pass.push("--quiet");
+      continue;
+    }
+    if (arg === "--continue" || arg === "-c") {
+      parsed.pass.push("--continue");
+      continue;
+    }
+    parsed.pass.push(arg);
+  }
+  return parsed;
+}
+
 export default {
   name: "chat",
   summary: "open the one oracle chat surface (telegram-like, multi-model)",
@@ -307,15 +319,69 @@ export default {
       return 0;
     }
 
-    const hermes = which("hermes") || ensureRuntime();
-    if (!hermes) {
+    const parsed = parseLaunchArgs(args);
+    const selectionEnv = {
+      ...process.env,
+      ...(parsed.model ? { ORACLE_MODEL: parsed.model } : {}),
+      ...(parsed.provider ? { ORACLE_PROVIDER: parsed.provider } : {}),
+    };
+    const authStore = getOAuthStore();
+    const backend = resolveChatBackend({
+      env: selectionEnv,
+      hermes: resolveHermes(),
+      storedConfig: readModelConfig(),
+      oauthAvailable: (provider) => Boolean(authStore.get(provider)),
+      apiKeyResolver: (provider) => authStore.getApiKey(provider),
+    });
+    if (backend.kind === "unconfigured") {
+      process.stderr.write(`${backend.reason}\n`);
+      return 1;
+    }
+
+    const cleanEnv = activeChainEnv({
+      ORACLE_CHAT_SURFACE: "1",
+      ORACLE_PROFILE: PROFILE,
+      ORACLE_NODE_BIN: process.execPath,
+      ORACLE_CLI_ENTRY: path.join(PACKAGE_ROOT, "bin", "oracle.mjs"),
+    });
+
+    if (backend.kind === "standalone") {
+      const client = createStandaloneClient({
+        config: {
+          ...backend.config,
+          ...(parsed.model ? { model: parsed.model } : {}),
+        },
+      });
+      if (parsed.query) {
+        try {
+          return await runStandaloneQuery({
+            client,
+            text: parsed.query,
+            stdout: process.stdout,
+            stderr: process.stderr,
+          });
+        } catch {
+          return 1;
+        }
+      }
+      const native = await runOracleTui({
+        client,
+        args,
+        env: cleanEnv,
+        cwd: process.cwd(),
+        stdin: process.stdin,
+        stdout: process.stdout,
+      });
+      if (native.native) return native.code;
       process.stderr.write(
-        "oracle chat needs a local agent runtime\n" +
-          "run: oracle bootstrap\n",
+        process.env.ORACLE_NATIVE_TUI === "0"
+          ? "oracle standalone chat requires the native TUI; remove ORACLE_NATIVE_TUI=0\n"
+          : "oracle standalone chat requires an interactive TTY or -q <query>\n",
       );
       return 1;
     }
 
+    const hermes = backend.bin;
     ensureOracleProfile(PROFILE);
     ensureOracleSkin(PROFILE);
     ensureSkillCommands(PROFILE);
@@ -325,7 +391,7 @@ export default {
       process.stderr.write(`oracle chat: skin note: ${skinSet.reason}\n`);
     }
 
-    const explicitModel = args.includes("--model") || args.includes("-m") || args.includes("--provider");
+    const explicitModel = Boolean(parsed.model || parsed.provider);
     if (!modelReady(PROFILE) && !explicitModel) {
       if (!process.stdin.isTTY || !process.stdout.isTTY) {
         process.stderr.write("oracle chat needs a configured model\nrun: oracle model\n");
@@ -342,50 +408,7 @@ export default {
       if (selected !== 0 || !modelReady(PROFILE)) return selected || 1;
     }
 
-    // Parse a few passthrough flags.
     const hermesArgs = ["-p", PROFILE, "chat"];
-    const pass = [];
-    for (let i = 0; i < args.length; i++) {
-      const a = args[i];
-      if (a === "--model" || a === "-m") {
-        if (args[i + 1]) {
-          pass.push("--model", args[++i]);
-        }
-        continue;
-      }
-      if (a === "--provider") {
-        if (args[i + 1]) {
-          pass.push("--provider", args[++i]);
-        }
-        continue;
-      }
-      if (a === "-q" || a === "--query") {
-        if (args[i + 1]) {
-          pass.push("-q", args[++i]);
-        }
-        continue;
-      }
-      if (a === "--quiet" || a === "-Q") {
-        pass.push("--quiet");
-        continue;
-      }
-      if (a === "--continue" || a === "-c") {
-        pass.push("--continue");
-        continue;
-      }
-      // unknown flags go through
-      pass.push(a);
-    }
-
-    // hermes -p scopes the same profile used by Telegram. Do not replace
-    // HERMES_HOME with the profile dir; nested profile resolution would break.
-    const cleanEnv = activeChainEnv({
-      ORACLE_CHAT_SURFACE: "1",
-      ORACLE_PROFILE: PROFILE,
-      ORACLE_NODE_BIN: process.execPath,
-      ORACLE_CLI_ENTRY: path.join(PACKAGE_ROOT, "bin", "oracle.mjs"),
-    });
-
     const hermesPython = resolveHermesPython(hermes);
     const native = await runOracleTui({
       hermesPython,
@@ -397,8 +420,7 @@ export default {
     });
     if (native.native) return native.code;
 
-    const launch = oracleHarnessInvocation(hermes, [...hermesArgs, ...pass]);
-
+    const launch = oracleHarnessInvocation(hermes, [...hermesArgs, ...parsed.pass]);
     return spawnChild(
       launch.command,
       launch.args,

package/src/cli/commands/data.mjs

@@ -53,7 +53,9 @@ export default {
       const bin = path.join(ctx.root, "bin", "desk-server.mjs");
       return spawnChild(process.execPath, [bin], { stdio: "inherit", env }, "desk-server");
     }
-    if (verb === "health") return dataFetch("/");
+    // The server serves /health; / intentionally 404s with a route list. This
+    // probed / and so reported the package's own running server as down.
+    if (verb === "health") return dataFetch("/health");
     if (verb === "catalog") return dataFetch("/data/catalog");
     if (verb === "call") {
       const provider = ctx.argv[1];

package/src/cli/commands/doctor.mjs

@@ -21,7 +21,9 @@ function loadExecEnv(p) {
 
 async function probeDataServer(url) {
   try {
-    const res = await fetch(url.replace(/\/$/, "") + "/");
+    // The server serves /health; / intentionally 404s with a route list, so
+    // probing / reported a healthy server as down.
+    const res = await fetch(url.replace(/\/$/, "") + "/health");
     return res.ok;
   } catch {
     return false;
@@ -47,9 +49,17 @@ export default {
 
     const execEnvPath = ctx.paths.oracleExecEnvPath();
     const envFile = loadExecEnv(execEnvPath);
+    // `oracle init --apply` writes ORACLE_ROUTE_ATTESTATION_SECRET (see
+    // bin/oracle-init.mjs), but doctor checked only ORACLE_ATTESTATION_SECRET
+    // and ORACLE_STAMP_HMAC_SECRET — so it told the user to rerun an init step
+    // that could never satisfy the check.
     const att =
+      process.env.ORACLE_ROUTE_ATTESTATION_SECRET ||
+      process.env.MAD_ROUTE_ATTESTATION_SECRET ||
       process.env.ORACLE_ATTESTATION_SECRET ||
       process.env.ORACLE_STAMP_HMAC_SECRET ||
+      envFile.ORACLE_ROUTE_ATTESTATION_SECRET ||
+      envFile.MAD_ROUTE_ATTESTATION_SECRET ||
       envFile.ORACLE_ATTESTATION_SECRET ||
       envFile.ORACLE_STAMP_HMAC_SECRET;
     push("attestation_secret", att ? "ok" : "warn", att ? "present" : "missing",

package/src/cli/commands/model.mjs

@@ -1,38 +1,94 @@
 import { spawnChild } from "../spawn-child.mjs";
-import { installManagedHermes, resolveHermes } from "../runtime.mjs";
+import { resolveHermes } from "../runtime.mjs";
+import { readModelConfig, writeModelConfig } from "../model-config.mjs";
 import { oracleHarnessInvocation } from "./chat.mjs";
 
-function runtimeBin() {
-  const found = resolveHermes();
-  if (found.ok) return found.bin;
-  if (process.env.ORACLE_NO_BOOTSTRAP === "1") return null;
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return null;
-  process.stdout.write("setting up oracle's local model runtime (one time)\n\n");
-  const installed = installManagedHermes();
-  if (!installed.ok) {
-    process.stderr.write(`oracle model: runtime setup failed: ${installed.reason}\n`);
-    return null;
+function option(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 && args[index + 1] ? args[index + 1] : null;
+}
+
+function standalonePatch(args) {
+  const backend = option(args, "--backend");
+  const provider = option(args, "--provider");
+  const model = option(args, "--model") || option(args, "-m");
+  const baseUrl = option(args, "--base-url");
+  const apiKeyEnv = option(args, "--api-key-env");
+  const contextLength = option(args, "--context-length");
+  const reasoningEffort = option(args, "--reasoning-effort");
+  const hasStandaloneField = Boolean(provider || model || baseUrl || apiKeyEnv || contextLength || reasoningEffort);
+  if (!backend && !hasStandaloneField) return null;
+  const current = { ...(readModelConfig() || {}) };
+  if (provider) {
+    delete current.apiKeyEnv;
+    if (provider !== "custom" || provider !== current.provider) delete current.baseUrl;
   }
-  return installed.bin;
+  return {
+    ...current,
+    backend: backend || "standalone",
+    ...(provider ? { provider } : {}),
+    ...(model ? { model } : {}),
+    ...(baseUrl ? { baseUrl } : {}),
+    ...(apiKeyEnv ? { apiKeyEnv } : {}),
+    ...(contextLength ? { contextLength } : {}),
+    ...(reasoningEffort ? { reasoningEffort } : {}),
+  };
+}
+
+function usage() {
+  return [
+    "oracle model, choose standalone model settings or open Hermes' picker",
+    "",
+    "  oracle model",
+    "  oracle model --show",
+    "  oracle model --backend standalone --provider openrouter --model openrouter/auto",
+    "  oracle model --backend auto",
+    "",
+    "standalone keys stay in environment variables, never model.json:",
+    "  OPENROUTER_API_KEY, OPENAI_API_KEY, XAI_API_KEY, DEEPSEEK_API_KEY, GEMINI_API_KEY",
+  ].join("\n");
 }
 
 export default {
   name: "model",
-  summary: "choose the oracle profile's model/provider",
+  summary: "choose Oracle's standalone model or existing Hermes provider",
   group: "read",
-  usage: [
-    "oracle model - interactive provider/model picker for the oracle profile",
-    "",
-    "inside chat: /model",
-    "one oracle persona stays loaded when the model changes.",
-  ].join("\n"),
+  usage: usage(),
   async run(ctx) {
-    const hermes = runtimeBin();
-    if (!hermes) {
-      process.stderr.write("oracle model needs the local runtime\nrun: oracle bootstrap\n");
+    const args = [...ctx.argv];
+    if (args.includes("--show")) {
+      process.stdout.write(`${JSON.stringify(readModelConfig() || { backend: "auto" }, null, 2)}\n`);
+      return 0;
+    }
+
+    const patch = standalonePatch(args);
+    if (patch) {
+      try {
+        const saved = writeModelConfig(patch);
+        process.stdout.write(`oracle model: ${saved.backend}`);
+        if (saved.provider) process.stdout.write(` / ${saved.provider}`);
+        if (saved.model) process.stdout.write(` / ${saved.model}`);
+        process.stdout.write("\n");
+        if (saved.backend === "standalone" && saved.apiKeyEnv) {
+          process.stdout.write(`key source: ${saved.apiKeyEnv}\n`);
+        }
+        return 0;
+      } catch (error) {
+        process.stderr.write(`oracle model: ${error.message}\n`);
+        return 1;
+      }
+    }
+
+    const found = resolveHermes();
+    if (!found.ok) {
+      process.stderr.write(
+        "Oracle standalone chat does not require Hermes.\n" +
+          "Configure a provider with: oracle model --backend standalone --provider openrouter --model openrouter/auto\n" +
+          "Then set OPENROUTER_API_KEY.\n",
+      );
       return 1;
     }
-    const launch = oracleHarnessInvocation(hermes, ["-p", "oracle", "model", ...ctx.argv]);
+    const launch = oracleHarnessInvocation(found.bin, ["-p", "oracle", "model", ...args]);
     return spawnChild(
       launch.command,
       launch.args,

package/src/cli/kernel.mjs

@@ -12,12 +12,13 @@ import {
 const HELP_HEADER = `oracle — self-custody multichain agent control plane`;
 
 const STATIC_HELP = `READ / RESEARCH (no keys, this package)
-  oracle                      open the plain oracle chat harness (TTY)
-  oracle bootstrap            install the local agent runtime chat needs
+  oracle                      open the native Oracle chat (TTY)
+  oracle bootstrap            optional: install an isolated Hermes compatibility runtime
   oracle init                 install agent lanes + read plane (dry-run by default)
   oracle doctor               check read plane; checks signer too when installed
   oracle chat                 premium boxed oracle chat (multi-model)
-  oracle model                choose the profile's default model/provider
+  oracle model                choose standalone/Hermes provider and any compatible model
+  oracle auth                 Claude/Codex/Grok OAuth or securely stored provider API keys
   oracle chain                list/select working chains (hyperliquid, base, ...)
   oracle setup                telegram/discord/slack messaging menu
   oracle data serve|call|catalog|health