@oracle-agent/oracle 0.4.2 → 0.6.0

package/src/cli/commands/chain.mjs

@@ -0,0 +1,143 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import {
+  findWorkingChain,
+  listWorkingChains,
+  renderChainList,
+} from "../chain-catalog.mjs";
+import {
+  clearActiveChain,
+  readActiveChain,
+  writeActiveChain,
+} from "../chain-state.mjs";
+
+function usage() {
+  return [
+    "oracle chain — pick the build/trade surface",
+    "",
+    "  oracle chain                 list working chains",
+    "  oracle chain list            same",
+    "  oracle chain show            show active chain",
+    "  oracle chain use <name>      select (hyperliquid, base, solana, ...)",
+    "  oracle chain clear           unset",
+    "  oracle chain --json          machine output",
+    "",
+    "chat:",
+    "  /chain",
+    "  /chain hyperliquid",
+    "  /chain show",
+  ].join("\n");
+}
+
+function printList(json) {
+  const active = readActiveChain();
+  if (json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          active,
+          chains: listWorkingChains(),
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    return 0;
+  }
+  process.stdout.write(
+    renderChainList({ selectedKey: active?.key || null }),
+  );
+  return 0;
+}
+
+function printShow(json) {
+  const active = readActiveChain();
+  if (json) {
+    process.stdout.write(JSON.stringify({ active }, null, 2) + "\n");
+    return active ? 0 : 1;
+  }
+  if (!active) {
+    process.stdout.write("active: none\nrun: oracle chain use hyperliquid\n");
+    return 1;
+  }
+  process.stdout.write(
+    `active: ${active.key}  id=${active.chainId}  agent=${active.agent}\n`,
+  );
+  return 0;
+}
+
+function useChain(query, json) {
+  try {
+    const active = writeActiveChain(query);
+    if (json) {
+      process.stdout.write(JSON.stringify({ ok: true, active }, null, 2) + "\n");
+    } else {
+      process.stdout.write(
+        `selected ${active.key} (${active.chainId}) · agent ${active.agent}\n` +
+          `build/trade context pinned for this machine\n`,
+      );
+    }
+    return 0;
+  } catch (err) {
+    if (err?.code === "UNKNOWN_CHAIN") {
+      process.stderr.write(`oracle chain: unknown '${query}'\n`);
+      process.stderr.write("try: oracle chain list\n");
+      return 1;
+    }
+    throw err;
+  }
+}
+
+export default {
+  name: "chain",
+  summary: "list/select working chains (hyperliquid, base, solana, ...)",
+  group: "read",
+  usage: usage(),
+  async run(ctx) {
+    const args = [...ctx.argv];
+    const json = args.includes("--json");
+    const clean = args.filter((a) => a !== "--json");
+    const verb = (clean[0] || "list").toLowerCase();
+    const rest = clean.slice(1);
+
+    if (["-h", "--help", "help"].includes(verb)) {
+      process.stdout.write(usage() + "\n");
+      return 0;
+    }
+    if (["list", "ls"].includes(verb)) return printList(json);
+    if (["show", "status", "current"].includes(verb)) return printShow(json);
+    if (["clear", "unset", "none"].includes(verb)) {
+      clearActiveChain();
+      process.stdout.write(json ? "{\"ok\":true,\"active\":null}\n" : "active chain cleared\n");
+      return 0;
+    }
+    if (["use", "set", "select", "pick"].includes(verb)) {
+      const q = rest.join(" ").trim();
+      if (!q) {
+        process.stderr.write("usage: oracle chain use <name>\n");
+        return 1;
+      }
+      return useChain(q, json);
+    }
+
+    // bare token: oracle chain hyperliquid
+    if (findWorkingChain(verb)) return useChain(verb, json);
+
+    // interactive pick when tty and no args beyond list default already handled
+    if (!clean.length && process.stdin.isTTY) {
+      const chains = listWorkingChains();
+      process.stdout.write(renderChainList({ selectedKey: readActiveChain()?.key }));
+      const rl = readline.createInterface({ input, output });
+      try {
+        const answer = (await rl.question("chain> ")).trim();
+        if (!answer) return 0;
+        return useChain(answer, false);
+      } finally {
+        rl.close();
+      }
+    }
+
+    process.stderr.write(`oracle chain: unknown verb '${verb}'\n${usage()}\n`);
+    return 1;
+  },
+};

package/src/cli/commands/chat.mjs

@@ -0,0 +1,268 @@
+import fs from "node:fs";
+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 { spawnChild } from "../spawn-child.mjs";
+
+const PROFILE = "oracle";
+const SKIN_NAME = "oracle";
+
+function which(bin) {
+  if (bin === "hermes" && process.env.ORACLE_HERMES_BIN) {
+    return process.env.ORACLE_HERMES_BIN;
+  }
+  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+    const c = path.join(dir, bin);
+    try {
+      if (fs.existsSync(c)) return c;
+    } catch {}
+  }
+  return null;
+}
+
+function pythonShebang(file) {
+  try {
+    const first = fs.readFileSync(file, "utf8").split(/\r?\n/, 1)[0];
+    if (!first.startsWith("#!")) return null;
+    const parts = first.slice(2).trim().split(/\s+/);
+    if (parts[0]?.endsWith("/env") && parts[1]?.startsWith("python")) {
+      return { command: parts[0], prefix: [parts[1]] };
+    }
+    if (path.basename(parts[0] || "").startsWith("python")) {
+      return { command: parts[0], prefix: parts.slice(1) };
+    }
+  } catch {}
+  return null;
+}
+
+export function resolveHermesPython(hermes) {
+  const direct = pythonShebang(hermes);
+  if (direct) return direct;
+  try {
+    const body = fs.readFileSync(hermes, "utf8");
+    const match = body.match(/["']([^"'\r\n]+\/bin\/hermes)["']/);
+    if (match) return pythonShebang(match[1]);
+  } catch {}
+  return null;
+}
+
+function harnessSourcePath() {
+  return path.join(PACKAGE_ROOT, "src", "cli", "oracle-harness.py");
+}
+
+function skinSourcePath() {
+  return path.join(PACKAGE_ROOT, "skins", "oracle.yaml");
+}
+
+function ensureOracleSkin(profile = PROFILE) {
+  const src = skinSourcePath();
+  if (!fs.existsSync(src)) return { ok: false, reason: "skin missing from package" };
+  const rootSkins = path.join(hermesRoot(), "skins");
+  const profileSkins = path.join(hermesRoot(), "profiles", profile, "skins");
+  ensureDir(rootSkins);
+  ensureDir(profileSkins);
+  const body = fs.readFileSync(src, "utf8");
+  fs.writeFileSync(path.join(rootSkins, `${SKIN_NAME}.yaml`), body);
+  fs.writeFileSync(path.join(profileSkins, `${SKIN_NAME}.yaml`), body);
+  return { ok: true, skin: SKIN_NAME };
+}
+
+function ensureQuickCommands(profile = PROFILE) {
+  // Install /chain and /setup as hermes quick commands that call oracle.
+  const cfgPath = path.join(hermesRoot(), "profiles", profile, "config.yaml");
+  if (!fs.existsSync(cfgPath)) return { ok: false, reason: "profile config missing" };
+
+  // Prefer a tiny sidecar json the chat skill can also read; hermes quick_commands
+  // live in config.yaml which we must not corrupt with naive YAML mutation.
+  // We install a hermes-facing skill command instead (see skills/oracle-chat).
+  const oracleBin = which("oracle") || path.join(PACKAGE_ROOT, "bin", "oracle.mjs");
+  const markerDir = path.join(hermesRoot(), "profiles", profile, "oracle");
+  ensureDir(markerDir);
+  const marker = {
+    profile,
+    skin: SKIN_NAME,
+    oracleBin,
+    commands: {
+      chain: [oracleBin, "chain"],
+      setup: [oracleBin, "setup"],
+    },
+    updatedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(
+    path.join(markerDir, "chat-surface.json"),
+    JSON.stringify(marker, null, 2) + "\n",
+    { mode: 0o600 },
+  );
+  return { ok: true, marker };
+}
+
+function ensureSkillCommands(profile = PROFILE) {
+  const srcDir = path.join(PACKAGE_ROOT, "skills", "oracle-chat");
+  if (!fs.existsSync(srcDir)) return { ok: false, reason: "oracle-chat skill missing" };
+  const destRoot = path.join(hermesRoot(), "profiles", profile, "skills", "oracle-chat");
+  ensureDir(destRoot);
+  for (const name of fs.readdirSync(srcDir)) {
+    const from = path.join(srcDir, name);
+    const to = path.join(destRoot, name);
+    if (fs.statSync(from).isFile()) {
+      fs.copyFileSync(from, to);
+    }
+  }
+  // Also install under profile skills root aliases for /chain and /setup.
+  for (const slug of ["chain", "setup"]) {
+    const aliasDir = path.join(hermesRoot(), "profiles", profile, "skills", slug);
+    ensureDir(aliasDir);
+    const skillMd = path.join(srcDir, `${slug}.SKILL.md`);
+    const fallback = path.join(srcDir, "SKILL.md");
+    const body = fs.existsSync(skillMd)
+      ? fs.readFileSync(skillMd, "utf8")
+      : fs.readFileSync(fallback, "utf8");
+    fs.writeFileSync(path.join(aliasDir, "SKILL.md"), body);
+  }
+  return { ok: true };
+}
+
+function setDisplaySkin(profile = PROFILE) {
+  const hermes = which("hermes");
+  if (!hermes) return { ok: false, reason: "hermes missing" };
+  // hermes config set is safe; avoids hand-editing yaml.
+  const r = spawnSync(
+    hermes,
+    ["-p", profile, "config", "set", "display.skin", SKIN_NAME],
+    { encoding: "utf8", timeout: 30_000 },
+  );
+  if (r.status !== 0) {
+    return {
+      ok: false,
+      reason: (r.stderr || r.stdout || "config set failed").trim(),
+    };
+  }
+  return { ok: true };
+}
+
+function usage() {
+  return [
+    "oracle chat — one lowercase oracle surface",
+    "",
+    "  oracle chat                 open interactive oracle chat",
+    "  oracle chat -q \"...\"        one-shot query",
+    "  oracle chat --model <m>     pass model to hermes for this session",
+    "  oracle chat --print-banner  show plain ascii banner only",
+    "",
+    "inside chat:",
+    "  /chain                      list/select chains",
+    "  /setup                      messaging setup menu",
+    "  /model                      switch models (still one oracle persona)",
+    "",
+    "brand: plain lowercase ascii oracle",
+  ].join("\n");
+}
+
+function printBanner() {
+  const lines = [
+    "",
+    "                 _",
+    " ___ _ _ __ _ __| |___",
+    "/ _ \\ '_/ _` / _| / -_)",
+    "\\___/_| \\__,_\\__|_\\___|",
+    "",
+  ];
+  process.stdout.write(lines.join("\n") + "\n");
+}
+
+export default {
+  name: "chat",
+  summary: "open the one oracle chat surface (telegram-like, multi-model)",
+  group: "read",
+  usage: usage(),
+  async run(ctx) {
+    const args = [...ctx.argv];
+    if (args.includes("-h") || args.includes("--help")) {
+      process.stdout.write(usage() + "\n");
+      return 0;
+    }
+    if (args.includes("--print-banner")) {
+      printBanner();
+      return 0;
+    }
+
+    const hermes = which("hermes");
+    if (!hermes) {
+      process.stderr.write(
+        "oracle chat needs hermes on PATH\n" +
+          "install: https://hermes-agent.nousresearch.com/docs\n",
+      );
+      return 1;
+    }
+
+    ensureOracleSkin(PROFILE);
+    ensureQuickCommands(PROFILE);
+    ensureSkillCommands(PROFILE);
+    const skinSet = setDisplaySkin(PROFILE);
+    if (!skinSet.ok && process.env.ORACLE_CLI_DEBUG) {
+      process.stderr.write(`oracle chat: skin note: ${skinSet.reason}\n`);
+    }
+
+    // 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,
+    });
+
+    const harness = harnessSourcePath();
+    const runtime = process.env.ORACLE_PLAIN_HARNESS === "0"
+      ? null
+      : resolveHermesPython(hermes);
+    const command = runtime && fs.existsSync(harness) ? runtime.command : hermes;
+    const launchArgs = runtime && fs.existsSync(harness)
+      ? [...runtime.prefix, harness, ...hermesArgs, ...pass]
+      : [...hermesArgs, ...pass];
+
+    return spawnChild(
+      command,
+      launchArgs,
+      {
+        stdio: "inherit",
+        env: cleanEnv,
+      },
+      "oracle-chat",
+    );
+  },
+};

package/src/cli/commands/credential.mjs

@@ -0,0 +1,9 @@
+export default {
+  name: "credential",
+  summary: "OS credential store glue",
+  group: "sign",
+  usage: "oracle credential <get|set|delete> ...",
+  async run(ctx) {
+    return ctx.dispatchOperator("oracle-credential", ctx.argv, { appendHintOnError: true });
+  },
+};

package/src/cli/commands/data-mcp.mjs

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { spawnChild } from "../spawn-child.mjs";
+
+export default {
+  name: "data-mcp",
+  summary: "start the read-only data MCP server",
+  group: "read",
+  usage: "oracle data-mcp",
+  async run(ctx) {
+    const bin = path.join(ctx.root, "bin", "oracle-data-mcp.mjs");
+    return spawnChild(
+      process.execPath,
+      [bin, ...ctx.argv],
+      { stdio: "inherit", env: process.env },
+      "oracle-data-mcp",
+    );
+  },
+};

package/src/cli/commands/data.mjs

@@ -0,0 +1,73 @@
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { spawnChild } from "../spawn-child.mjs";
+
+const DEFAULT_DATA_URL = "http://127.0.0.1:8787";
+
+function usage() {
+  process.stderr.write(
+    "usage: oracle data <serve|call|catalog|health> [args]\n" +
+      "  oracle data serve [--port N]\n" +
+      "  oracle data call <provider> <op> [--args '<json>']\n" +
+      "  oracle data catalog\n" +
+      "  oracle data health\n",
+  );
+}
+
+async function dataFetch(pathname, { method = "GET", body } = {}) {
+  const base = (process.env.ORACLE_DATA_URL || DEFAULT_DATA_URL).replace(/\/$/, "");
+  const url = base + pathname;
+  try {
+    const res = await fetch(url, {
+      method,
+      headers: body ? { "content-type": "application/json" } : undefined,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    const text = await res.text();
+    process.stdout.write(text.endsWith("\n") ? text : text + "\n");
+    return res.ok ? 0 : 1;
+  } catch (err) {
+    if (err && (err.code === "ECONNREFUSED" || /fetch failed|ECONNREFUSED/i.test(String(err)))) {
+      process.stderr.write("oracle: data server not running — start it with 'oracle data serve'\n");
+      return 4;
+    }
+    process.stderr.write(`oracle data: ${err.message || err}\n`);
+    return 1;
+  }
+}
+
+export default {
+  name: "data", summary: "desk data plane", group: "read",
+  usage: "oracle data serve|call|catalog|health",
+  async run(ctx) {
+    const verb = ctx.argv[0];
+    if (!verb || verb === "--help" || verb === "-h") { usage(); return verb ? 0 : 1; }
+    if (verb === "serve") {
+      let port = null;
+      try {
+        const { values } = parseArgs({ args: ctx.argv.slice(1), options: { port: { type: "string" } }, allowPositionals: true, strict: false });
+        port = values.port || null;
+      } catch {}
+      const env = { ...process.env };
+      if (port) env.ORACLE_DATA_PORT = String(port);
+      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("/");
+    if (verb === "catalog") return dataFetch("/data/catalog");
+    if (verb === "call") {
+      const provider = ctx.argv[1];
+      const op = ctx.argv[2];
+      if (!provider || !op) { usage(); return 1; }
+      let argsObj = {};
+      const i = ctx.argv.indexOf("--args");
+      if (i >= 0) {
+        try { argsObj = JSON.parse(ctx.argv[i + 1] || "{}"); }
+        catch (err) { process.stderr.write(`oracle data call: invalid --args JSON: ${err.message}\n`); return 1; }
+      }
+      return dataFetch("/data/call", { method: "POST", body: { provider, op, args: argsObj } });
+    }
+    usage();
+    return 1;
+  },
+};

package/src/cli/commands/doctor.mjs

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DOCTOR_SIGNING_OPTIONAL } from "../first-run.mjs";
+
+function nodeVersionOk() {
+  const [maj, min] = process.versions.node.split(".").map(Number);
+  return maj > 20 || (maj === 20 && min >= 19);
+}
+
+function loadExecEnv(p) {
+  if (!fs.existsSync(p)) return {};
+  const out = {};
+  for (const line of fs.readFileSync(p, "utf8").split(/\r?\n/)) {
+    const m = line.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (m) out[m[1]] = m[2];
+  }
+  return out;
+}
+
+function which(bin) {
+  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+    const c = path.join(dir, bin);
+    try { if (fs.existsSync(c)) return c; } catch {}
+  }
+  return null;
+}
+
+async function probeDataServer(url) {
+  try {
+    const res = await fetch(url.replace(/\/$/, "") + "/");
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export default {
+  name: "doctor",
+  summary: "check read plane; checks signer too when installed",
+  group: "read",
+  usage: "oracle doctor [--json]",
+  async run(ctx) {
+    const json = ctx.argv.includes("--json");
+    const checks = [];
+    let failed = false;
+    const push = (id, status, detail, fix = null) => {
+      checks.push({ id, status, detail, fix });
+      if (status === "fail") failed = true;
+    };
+
+    push("node", nodeVersionOk() ? "ok" : "fail", `node ${process.versions.node}`,
+      nodeVersionOk() ? null : "install node >= 20.19");
+
+    const execEnvPath = ctx.paths.oracleExecEnvPath();
+    const envFile = loadExecEnv(execEnvPath);
+    const att =
+      process.env.ORACLE_ATTESTATION_SECRET ||
+      process.env.ORACLE_STAMP_HMAC_SECRET ||
+      envFile.ORACLE_ATTESTATION_SECRET ||
+      envFile.ORACLE_STAMP_HMAC_SECRET;
+    push("attestation_secret", att ? "ok" : "warn", att ? "present" : "missing",
+      att ? null : "run oracle init --apply (writes ~/.config/oracle/exec.env)");
+
+    const dataUrl = process.env.ORACLE_DATA_URL || "http://127.0.0.1:8787";
+    const dataUp = await probeDataServer(dataUrl);
+    push("data_server", dataUp ? "ok" : "warn", dataUp ? `reachable ${dataUrl}` : `down ${dataUrl}`,
+      dataUp ? null : "oracle data serve");
+
+    const hermes = which("hermes");
+    push("hermes_cli", hermes ? "ok" : "warn", hermes ? `present ${hermes}` : "not on PATH",
+      hermes ? null : "install Hermes if you want agent lanes");
+
+    const profilesDir = path.join(ctx.paths.hermesRoot(), "profiles");
+    let laneCount = 0;
+    if (fs.existsSync(profilesDir)) {
+      laneCount = fs.readdirSync(profilesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).length;
+    }
+    push("hermes_lanes", laneCount > 0 ? "ok" : "warn",
+      laneCount > 0 ? `${laneCount} profile dir(s)` : "no lane profiles found",
+      laneCount > 0 ? null : "oracle init --apply");
+
+    const operator = ctx.resolveOperator();
+    let operatorBlock = { installed: false };
+    if (operator.ok) {
+      const r = ctx.dispatchOperator("oracle-agentic-doctor", ["--json"], { stdio: "pipe" });
+      let detail = { installed: true, version: operator.version, source: operator.source };
+      if (r && typeof r === "object" && r.stdout) {
+        try {
+          const parsed = JSON.parse(r.stdout);
+          detail = {
+            installed: true,
+            version: operator.version,
+            source: operator.source,
+            signingReady: parsed.signingReady,
+            broadcastReady: parsed.broadcastReady,
+            executionReady: parsed.executionReady,
+            masterKillSwitch: parsed.masterKillSwitch,
+            raw: parsed,
+          };
+        } catch {
+          detail.doctorParseError = true;
+          detail.doctorExit = r.code;
+        }
+      } else if (typeof r === "number") {
+        detail.doctorExit = r;
+      }
+      operatorBlock = detail;
+      const signingReady = detail.signingReady === true;
+      push(
+        "signing",
+        signingReady ? "ok" : "warn",
+        signingReady
+          ? `operator ${operator.version} ready via ${operator.source}`
+          : `operator ${operator.version} installed but signing is not ready`,
+        signingReady ? null : "oracle sign doctor --json",
+      );
+    }
+
+    const report = { ok: !failed, checks, operator: operatorBlock };
+    if (json) {
+      process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    } else {
+      for (const c of checks) {
+        process.stdout.write(`${c.status.toUpperCase().padEnd(4)} ${c.id}: ${c.detail}\n`);
+        if (c.fix) process.stdout.write(`     fix: ${c.fix}\n`);
+      }
+      if (!operator.ok) process.stdout.write(`INFO ${DOCTOR_SIGNING_OPTIONAL}\n`);
+    }
+    return failed ? 1 : 0;
+  },
+};

package/src/cli/commands/help.mjs

@@ -0,0 +1,7 @@
+export default {
+  name: "help",
+  summary: "show command help",
+  group: "meta",
+  usage: "oracle help [noun]",
+  async run() { return 0; },
+};

package/src/cli/commands/init.mjs

@@ -0,0 +1,27 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { renderNextSteps } from "../first-run.mjs";
+
+export default {
+  name: "init",
+  summary: "install agent lanes + read plane (dry-run by default)",
+  group: "read",
+  usage: "oracle init [--apply --force --only <lane> --json --yes]",
+  async run(ctx) {
+    const argv = [...ctx.argv];
+    if (argv.includes("--yes") && !argv.includes("--apply")) argv.push("--apply");
+    const bin = path.join(ctx.root, "bin", "oracle-init.mjs");
+    const r = spawnSync(process.execPath, [bin, ...argv], { encoding: "utf8", env: process.env });
+    if (r.error) {
+      process.stderr.write(`oracle: failed to spawn oracle-init: ${r.error.message}\n`);
+      return 1;
+    }
+    if (r.stdout) process.stdout.write(r.stdout);
+    if (r.stderr) process.stderr.write(r.stderr);
+    const code = typeof r.status === "number" ? r.status : 1;
+    if (code === 0 && argv.includes("--apply") && !argv.includes("--json")) {
+      process.stdout.write(renderNextSteps());
+    }
+    return code;
+  },
+};