@opennous/cli 0.18.1 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @opennous/cli changelog
 
+## 0.19.0
+
+### Added: read on your own API key
+
+`runner install --api-key` reads on your own Anthropic or OpenAI API key instead of your plan. It
+takes the key from `ANTHROPIC_API_KEY` / `OPENAI_API_KEY`, or asks for it without echoing it, and
+keeps it in `~/.nous/config.json`, which only you can read now. Each call gets only that key, for
+that agent. The app shows the runner as reading with an API key (GET-1310).
+
+## 0.18.2
+
+### Fixed: the runner service finds your Mac's name
+
+Started at login, the runner couldn't find `scutil`, so it named your Mac by its network hostname
+instead of its own name. It now calls it by its full path, and saves nothing (GET-1308).
+
 ## 0.18.1
 
 ### Fixed: one machine is one runner

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennous/cli",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "description": "Ownable CLI — set up Ownable, connect it to your coding agent, and read the Context API from your terminal",
   "type": "module",
   "bin": {

package/src/backfill.js

@@ -120,6 +120,11 @@ export function resetAt(message, now = Date.now()) {
   return null;
 }
 
+/** The agent CLIs installed here, signed in or not: an API key needs only the program (GET-1310). */
+export function installedAgents(run = spawnSync) {
+  return ["claude", "codex"].filter((a) => run(a, ["--version"], { encoding: "utf8" }).status === 0);
+}
+
 export function detectAgents(run = spawnSync) {
   const found = [];
   if (run("claude", ["auth", "status"], { encoding: "utf8" }).status === 0) found.push("claude");
@@ -127,16 +132,24 @@ export function detectAgents(run = spawnSync) {
   return found;
 }
 
-/** Without the API key variables, so the call runs on the plan, not a key billed by the token. */
-function planEnv(env = process.env) {
+const KEY_VARS = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "OPENAI_API_KEY", "CODEX_API_KEY"];
+
+/**
+ * The environment a call runs in. Without a key: none of the API key variables, so the call runs
+ * on the plan, not a key billed by the token. With one (GET-1310): only that key, for that agent,
+ * so the call is billed to the person's own API account, whatever else is set. Pure.
+ */
+export function callEnv({ agent = null, apiKey = null } = {}, env = process.env) {
   const clean = { ...env, DISABLE_AUTOUPDATER: "1" };
-  for (const k of ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "OPENAI_API_KEY", "CODEX_API_KEY"]) delete clean[k];
+  for (const k of KEY_VARS) delete clean[k];
+  if (apiKey && agent === "claude") clean.ANTHROPIC_API_KEY = apiKey;
+  if (apiKey && agent === "codex") { clean.CODEX_API_KEY = apiKey; clean.OPENAI_API_KEY = apiKey; }
   return clean;
 }
 
-function runCommand({ cmd, args, input }, cwd) {
+function runCommand({ cmd, args, input }, cwd, env = callEnv()) {
   return new Promise((resolve, reject) => {
-    const p = spawn(cmd, args, { cwd, env: planEnv(), stdio: ["pipe", "pipe", "pipe"] });
+    const p = spawn(cmd, args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
     let out = "", err = "";
     p.stdout.on("data", (d) => { out += d; });
     p.stderr.on("data", (d) => { err += d; });
@@ -255,9 +268,10 @@ export async function runBackfill({ api, agent, jobId, run, sleep, log, now = Da
 }
 
 /** The real pieces for runBackfill. */
-export function liveRun() {
+export function liveRun({ agent = null, apiKey = null } = {}) {
   const cwd = mkdtempSync(join(tmpdir(), "nous-backfill-"));
-  return (command) => runCommand(command, cwd);
+  const env = callEnv({ agent, apiKey });
+  return (command) => runCommand(command, cwd, env);
 }
 
 /**

package/src/index.js

@@ -7,7 +7,7 @@
 // the 7 MCP primitives — the CLI never duplicates them.
 
 import { program, Command } from "commander";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync, readdirSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync, readdirSync, chmodSync } from "fs";
 import { homedir, hostname } from "os";
 import { join, resolve, dirname, relative, sep } from "path";
 import { createInterface } from "readline";
@@ -104,7 +104,9 @@ function writeConfig(cfg) {
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+  // Only you can read it: it holds your Ownable key, and a runner's model API key (GET-1310).
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+  try { chmodSync(CONFIG_PATH, 0o600); } catch { /* best effort on filesystems without modes */ }
 }
 
 /** A key is there to use: from the environment, or saved by a sign-in. */
@@ -655,22 +657,28 @@ program
 // starts it at login; the app's "Your plan" page shows it as connected once it has polled.
 const runnerCmd = program
   .command("runner")
-  .description("Keep reading your new calls and email on your own Claude or ChatGPT plan")
+  .description("Keep reading your new calls and email on your own Claude or ChatGPT plan, or your own API key")
   .option("--agent <agent>", "claude or codex (default: whichever you're signed in to)")
+  .option("--api-key", "read on your own Anthropic or OpenAI API key instead of your plan")
   .option("--workspace <id>", "the workspace to read; the app's command fills this in")
   .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
   .action(async (opts) => {
-    const { detectAgents, liveRun, NO_AGENT } = await import("./backfill.js");
+    const { detectAgents, installedAgents, liveRun, NO_AGENT } = await import("./backfill.js");
     const { runRunner } = await import("./runner.js");
-    const agent = await pickAgent(opts.agent, detectAgents, NO_AGENT);
+    const agent = await pickAgent(opts.agent, opts.apiKey ? installedAgents : detectAgents, NO_AGENT);
+    const apiKey = opts.apiKey ? savedModelKey(agent) : null;
+    if (opts.apiKey && !apiKey) {
+      console.error(`No ${agent === "codex" ? "OpenAI" : "Anthropic"} API key saved. Run \`npx @opennous/cli@latest runner install --api-key\` first.`);
+      process.exit(1);
+    }
     const host = await runnerHost();
     const key = await runnerKey(opts);
     const api = apiClient(key);
     const service = process.env.NOUS_RUNNER_SERVICE === "1";
     const stamp = (line) => (service ? `${new Date().toISOString()} ${line}` : line);
-    console.log(stamp(`Reading on your ${agent} plan. ${service ? "" : "Stop with Ctrl-C; `nous runner install` keeps it going on its own."}`.trim()));
+    console.log(stamp(`Reading on your ${apiKey ? `${agent === "codex" ? "OpenAI" : "Anthropic"} API key` : `${agent} plan`}. ${service ? "" : "Stop with Ctrl-C; `nous runner install` keeps it going on its own."}`.trim()));
     await runRunner({
-      agent, host, version, run: liveRun(), log: (l) => console.log(stamp(l)),
+      agent, host, version, auth: apiKey ? "api_key" : "plan", run: liveRun({ agent, apiKey }), log: (l) => console.log(stamp(l)),
       sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
       api: {
         poll: (body) => api.softPost("/v2/runner/poll", body),
@@ -684,12 +692,15 @@ runnerCmd
   .command("install")
   .description("Start the runner now and every time you log in")
   .option("--agent <agent>", "claude or codex (default: whichever you're signed in to)")
+  .option("--api-key", "read on your own Anthropic or OpenAI API key instead of your plan (asked for once, kept only on this machine)")
   .option("--workspace <id>", "the workspace to read; the app's command fills this in")
   .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
   .action(async (opts) => {
-    const { detectAgents, NO_AGENT } = await import("./backfill.js");
+    const { detectAgents, installedAgents, NO_AGENT } = await import("./backfill.js");
     const { installService } = await import("./runner.js");
-    const agent = await pickAgent(opts.agent, detectAgents, NO_AGENT);
+    const agent = await pickAgent(opts.agent, opts.apiKey ? installedAgents : detectAgents, NO_AGENT);
+    // Your own API key (GET-1310): from the environment, or asked for now, and kept in ~/.nous (yours only).
+    if (opts.apiKey) await saveModelKey(agent);
     const key = await runnerKey(opts);
     // One poll before installing, so a bad key or plan fails here and not silently in the background.
     try {
@@ -699,8 +710,9 @@ runnerCmd
       process.exit(1);
     }
     try {
-      const where = installService({ agent, workspace: opts.workspace ?? null });
-      console.log(`Connected. Your calls and email are read on your ${agent} plan: your history first, then everything new. It starts every time you log in.`);
+      const where = installService({ agent, workspace: opts.workspace ?? null, apiKey: !!opts.apiKey });
+      const on = opts.apiKey ? `your ${agent === "codex" ? "OpenAI" : "Anthropic"} API key` : `your ${agent} plan`;
+      console.log(`Connected. Your calls and email are read on ${on}: your history first, then everything new. It starts every time you log in.`);
       if (where.log) console.log(`Log: ${where.log}`);
       console.log("Check on it with `npx @opennous/cli@latest runner status`. Stop it with `npx @opennous/cli@latest runner uninstall`.");
     } catch (e) {
@@ -731,13 +743,41 @@ runnerCmd
     if (s.log) console.log(`Log: ${s.log}`);
   });
 
-/** This machine's name for its runner, kept in the config so it is the same every run (GET-1308). */
+const KEY_ENV = { claude: "ANTHROPIC_API_KEY", codex: "OPENAI_API_KEY" };
+
+/** The model API key this machine's runner reads with, or null (GET-1310). */
+function savedModelKey(agent) {
+  return readConfig().runnerKeys?.[agent] ?? null;
+}
+
+/** Take the key from the environment, or ask for it without echoing it, and keep it in ~/.nous. */
+async function saveModelKey(agent) {
+  let value = process.env[KEY_ENV[agent]] || "";
+  if (!value) {
+    const label = agent === "codex" ? "OpenAI" : "Anthropic";
+    process.stdout.write(`${label} API key (kept only on this machine): `);
+    value = await new Promise((resolve) => {
+      const stdin = process.stdin;
+      let typed = "";
+      stdin.setRawMode?.(true); stdin.resume(); stdin.setEncoding("utf8");
+      const onData = (ch) => {
+        if (ch === "\r" || ch === "\n" || ch === "\u0004") { stdin.setRawMode?.(false); stdin.pause(); stdin.off("data", onData); process.stdout.write("\n"); resolve(typed.trim()); }
+        else if (ch === "\u0003") { process.stdout.write("\n"); process.exit(130); }
+        else if (ch === "\u007f") typed = typed.slice(0, -1);
+        else typed += ch;
+      };
+      stdin.on("data", onData);
+    });
+  }
+  if (!value) { console.error("No key given."); process.exit(1); }
+  const cfg = readConfig();
+  writeConfig({ ...cfg, runnerKeys: { ...cfg.runnerKeys, [agent]: value } });
+}
+
+/** This machine's name for its runner, the same every run (GET-1308). */
 async function runnerHost() {
   const { machineName } = await import("./runner.js");
-  const cfg = readConfig();
-  const name = machineName({ saved: cfg.runnerHost ?? null });
-  if (name !== cfg.runnerHost) writeConfig({ ...cfg, runnerHost: name });
-  return name;
+  return machineName();
 }
 
 /** The agent to read with: the one asked for, or whichever is signed in. Exits with what to do. */

package/src/runner.js

@@ -37,12 +37,14 @@ export const RUN_COMMAND = "npx -y @opennous/cli@latest runner";
 /**
  * This machine's name for Ownable (GET-1308), the same every run. `os.hostname()` on a Mac follows
  * the network ("Mac.lan" on one, "Bennets-MacBook-Air.local" on another), which made one machine
- * two runners. The Mac's own name (System Settings → General → About) is asked once and kept.
+ * two runners. The Mac's own name (System Settings → General → About) is the same every run, so it
+ * is asked each time; elsewhere the hostname is stable. Nothing is saved: 0.18.1 saved a fallback.
  */
 export function machineName({ saved = null, os = platform(), run = spawnSync, host = hostname } = {}) {
   if (saved) return saved;
   if (os === "darwin") {
-    const r = run("scutil", ["--get", "ComputerName"], { encoding: "utf8" });
+    // By its full path: a launchd service's PATH has no /usr/sbin (GET-1308, 0.18.2).
+    const r = run("/usr/sbin/scutil", ["--get", "ComputerName"], { encoding: "utf8" });
     const name = r.status === 0 ? String(r.stdout).trim() : "";
     if (name) return name;
   }
@@ -73,7 +75,7 @@ export function pauseLine(agent, reason, until, now = Date.now()) {
  * The loop. Injected: `api` ({ poll, answer }), `run` (one command → stdout), `sleep`, `log`.
  * `stop()` → true ends it (tests; the real one runs until the process is stopped).
  */
-export async function runRunner({ api, agent, host = hostname(), version = null, run, sleep, log, now = Date.now,
+export async function runRunner({ api, agent, host = hostname(), version = null, auth = "plan", run, sleep, log, now = Date.now,
   workers = WORKERS, limitWaitMs = LIMIT_WAIT_MS, stop = () => false }) {
   let limitedUntil = 0, limitReason = null, answered = 0, lastLine = null, lastError = null, backfillAt = -Infinity;
   const answerOne = async (call, models) => {
@@ -104,7 +106,7 @@ export async function runRunner({ api, agent, host = hostname(), version = null,
     let page;
     const asked = now();
     try {
-      page = await api.poll({ agent, host, version, answered, limit: workers, wait_ms: WAIT_MS,
+      page = await api.poll({ agent, host, version, auth, answered, limit: workers, wait_ms: WAIT_MS,
         limited_until: limitedUntil > now() ? new Date(limitedUntil).toISOString() : null,
         limit_reason: limitedUntil > now() ? limitReason : null });
       if (lastError) { log("Back online."); lastError = null; }
@@ -159,8 +161,8 @@ export function servicePath(binaries) {
 const xml = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 
 /** The launchd agent for macOS. Pure. */
-export function launchdPlist({ npx, agent, workspace = null, path, log }) {
-  const args = [npx, "-y", "@opennous/cli@latest", "runner", "--agent", agent, ...(workspace ? ["--workspace", workspace] : [])];
+export function launchdPlist({ npx, agent, workspace = null, apiKey = false, path, log }) {
+  const args = [npx, "-y", "@opennous/cli@latest", "runner", "--agent", agent, ...(workspace ? ["--workspace", workspace] : []), ...(apiKey ? ["--api-key"] : [])];
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -186,8 +188,8 @@ ${args.map((a) => `    <string>${xml(a)}</string>`).join("\n")}
 }
 
 /** The systemd user unit for Linux. Pure. */
-export function systemdUnit({ npx, agent, workspace = null, path }) {
-  const args = [npx, "-y", "@opennous/cli@latest", "runner", "--agent", agent, ...(workspace ? ["--workspace", workspace] : [])];
+export function systemdUnit({ npx, agent, workspace = null, apiKey = false, path }) {
+  const args = [npx, "-y", "@opennous/cli@latest", "runner", "--agent", agent, ...(workspace ? ["--workspace", workspace] : []), ...(apiKey ? ["--api-key"] : [])];
   return `[Unit]
 Description=Ownable runner: reads on your own ${agent === "codex" ? "ChatGPT" : "Claude"} plan
 After=network-online.target
@@ -212,7 +214,7 @@ export function servicePaths(os = platform(), home = homedir()) {
 }
 
 /** Install and start the runner as a service. Returns { kind, file, log } or throws with what to do. */
-export function installService({ agent, workspace = null, run = spawnSync, os = platform(), home = homedir() } = {}) {
+export function installService({ agent, workspace = null, apiKey = false, run = spawnSync, os = platform(), home = homedir() } = {}) {
   const where = servicePaths(os, home);
   if (!where) throw new Error(`Starting at login isn't supported on ${os} yet. Run \`${RUN_COMMAND}\` in a terminal you keep open instead.`);
   const npx = which("npx", run);
@@ -221,12 +223,12 @@ export function installService({ agent, workspace = null, run = spawnSync, os =
   mkdirSync(dirname(where.file), { recursive: true });
   if (where.kind === "launchd") {
     mkdirSync(dirname(where.log), { recursive: true });
-    writeFileSync(where.file, launchdPlist({ npx, agent, workspace, path, log: where.log }));
+    writeFileSync(where.file, launchdPlist({ npx, agent, workspace, apiKey, path, log: where.log }));
     run("launchctl", ["unload", where.file], { stdio: "ignore" });
     const r = run("launchctl", ["load", "-w", where.file], { encoding: "utf8" });
     if (r.status !== 0) throw new Error(`launchctl couldn't start it: ${(r.stderr || "").trim()}`);
   } else {
-    writeFileSync(where.file, systemdUnit({ npx, agent, workspace, path }));
+    writeFileSync(where.file, systemdUnit({ npx, agent, workspace, apiKey, path }));
     run("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
     const r = run("systemctl", ["--user", "enable", "--now", "opennous-runner.service"], { encoding: "utf8" });
     if (r.status !== 0) throw new Error(`systemd couldn't start it: ${(r.stderr || "").trim()}`);