@opennous/cli 0.19.2 → 0.19.4

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @opennous/cli changelog
 
+## 0.19.4
+
+### Added: turn reading off, or remove a runner, from the app
+
+- Reading turned off in Settings → AI subscription: the runner reads nothing on your plan until
+  it's back on, and says so once in its log (GET-1356).
+- A runner removed in the app while it runs uninstalls itself on its next check-in: it stops, and
+  won't start at login again.
+
+## 0.19.3
+
+### Changed: history reads go faster
+
+- While your history is read, the runner keeps your Mac from idle-sleeping (closing the lid still
+  sleeps it), and lets go five minutes after the reading stops (GET-1353).
+- A call cut off by the machine sleeping is read again instead of failing.
+- Six calls are answered at once instead of three. `NOUS_RUNNER_WORKERS` sets it (1 to 8).
+
+## 0.19.2
+
+### Fixed: `runner install` keeps `--agent` and `--workspace`
+
+`runner install --agent codex --workspace <id>` installed a runner for whichever agent you were
+signed in to and the workspace of your saved key (GET-1345).
+
 ## 0.19.1
 
 ### Changed: the first history read goes as far back as your workspace chose

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennous/cli",
-  "version": "0.19.2",
+  "version": "0.19.4",
   "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/index.js

@@ -664,7 +664,7 @@ const runnerCmd = program
   .option("--url <url>", "API base URL (default: https://api.opennous.cloud)")
   .action(async (opts) => {
     const { detectAgents, installedAgents, liveRun, NO_AGENT } = await import("./backfill.js");
-    const { runRunner } = await import("./runner.js");
+    const { runRunner, keepAwake, removeSelf } = await import("./runner.js");
     const agent = await pickAgent(opts.agent, opts.apiKey ? installedAgents : detectAgents, NO_AGENT);
     const apiKey = opts.apiKey ? savedModelKey(agent) : null;
     if (opts.apiKey && !apiKey) {
@@ -679,7 +679,14 @@ const runnerCmd = program
     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, auth: apiKey ? "api_key" : "plan", run: liveRun({ agent, apiKey }), log: (l) => console.log(stamp(l)),
+      awake: keepAwake({ log: (l) => console.log(stamp(l)) }),
       sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+      // Removed in the app (GET-1356): the server forgets this machine, then it uninstalls itself.
+      onRemoved: async () => {
+        await api.softDelete("/v2/runner", { host }).catch(() => {});
+        removeSelf();
+        process.exit(0);
+      },
       api: {
         poll: (body) => api.softPost("/v2/runner/poll", body),
         answer: (id, body) => api.softPost(`/v2/runner/calls/${id}`, body),

package/src/runner.js

@@ -4,13 +4,60 @@
 // a call's prompt holds other people's words), and posts the answer back. The server decides what to
 // read; this only answers. `nous runner install` starts it at login, so it keeps going on its own.
 
-import { spawnSync } from "node:child_process";
+import { spawn as spawnChild, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { commandFor, parseAnswer, troubleOf, resetAt } from "./backfill.js";
 
-export const WORKERS = 3;
+/** Calls answered at once (GET-1353). NOUS_RUNNER_WORKERS overrides; the server hands out at most 8 a poll. */
+export const WORKERS = workersFrom(process.env.NOUS_RUNNER_WORKERS);
+/** How long without work before the Mac may sleep again. */
+export const AWAKE_IDLE_MS = 5 * 60_000;
+/** A call whose wall clock ran this much past the machine's own clock spanned a sleep. */
+export const SLEPT_MS = 60_000;
+
+/** NOUS_RUNNER_WORKERS as a count: 1 to 8, else 6. Pure. */
+export function workersFrom(value) {
+  const n = Math.floor(Number(value));
+  return Number.isFinite(n) && n >= 1 ? Math.min(n, 8) : 6;
+}
+
+/**
+ * Keeps a Mac from idle-sleeping while there is reading to do (GET-1353): a sleeping Mac answers no
+ * calls, and a three-month read took hours of naps. `caffeinate -i -w <pid>` holds off idle sleep
+ * only (closing the lid still sleeps) and lets go by itself when this process ends. `touch()` on
+ * work, `tick()` every loop: after AWAKE_IDLE_MS with no work it lets go. Not a Mac: does nothing.
+ */
+export function keepAwake({ os = platform(), spawn = spawnChild, pid = process.pid, log = () => {}, now = Date.now, idleMs = AWAKE_IDLE_MS } = {}) {
+  let child = null, lastWork = 0;
+  const release = () => {
+    if (!child) return;
+    try { child.kill(); } catch { /* already gone */ }
+    child = null;
+    log("Reading is idle. This Mac may sleep again.");
+  };
+  return {
+    touch() {
+      lastWork = now();
+      if (child || os !== "darwin") return;
+      try {
+        child = spawn("/usr/bin/caffeinate", ["-i", "-w", String(pid)], { stdio: "ignore" });
+        child.on?.("error", () => { child = null; });
+        child.unref?.();
+        log("Keeping this Mac awake while your history is read.");
+      } catch { child = null; }
+    },
+    tick() { if (child && now() - lastWork >= idleMs) release(); },
+    release,
+    get holding() { return !!child; },
+  };
+}
+
+/** Is there reading to do: calls in hand, or a history read under way. Pure. */
+export function hasWork(page) {
+  return (page?.calls?.length ?? 0) > 0 || !!(page?.reading && !page.reading.live && !page.reading.finished);
+}
 /**
  * How long the server may hold a poll open waiting for a call (GET-1307). Idle, the runner checks in
  * about once a minute and still picks up a new call within seconds.
@@ -76,10 +123,13 @@ export function pauseLine(agent, reason, until, now = Date.now()) {
  * `stop()` → true ends it (tests; the real one runs until the process is stopped).
  */
 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;
+  workers = WORKERS, limitWaitMs = LIMIT_WAIT_MS, stop = () => false, awake = null, clock = () => performance.now(), onRemoved = null }) {
+  let limitedUntil = 0, limitReason = null, answered = 0, lastLine = null, lastError = null, backfillAt = -Infinity, sleptNoted = false, offNoted = false;
   const answerOne = async (call, models) => {
     for (let attempt = 0; ; attempt++) {
+      // performance.now() stops while a Mac sleeps; the wall clock doesn't. A call that failed across
+      // a sleep (the CLI timed out, the network dropped) isn't the call's fault (GET-1353).
+      const wall0 = now(), mono0 = clock();
       try {
         const { text, usage } = parseAnswer(agent, await run(commandFor(agent, models[agent], call)));
         await api.answer(call.id, { answer: text, model: models[agent].model, usage });
@@ -90,6 +140,12 @@ export async function runRunner({ api, agent, host = hostname(), version = null,
         // The plan's limit, a sign-out or an outage (GET-1303): none of them is the call's fault, so
         // it is dropped, not failed (its lease runs out and it comes back), and nothing more is taken
         // until it passes. The heartbeat keeps going, so the app shows why.
+        if ((now() - wall0) - (clock() - mono0) > SLEPT_MS) {
+          // Dropped, not failed: its lease runs out and it comes back, the meeting stays unread.
+          if (!sleptNoted) log("This machine slept during a call. It's read again; nothing is lost.");
+          sleptNoted = true;
+          return;
+        }
         const reason = troubleOf(err.message);
         if (reason) {
           const until = reason === "limit" ? (resetAt(err.message, now()) ?? now() + limitWaitMs) : now() + RECHECK_MS;
@@ -116,6 +172,22 @@ export async function runRunner({ api, agent, host = hostname(), version = null,
       await sleep(ERROR_BACKOFF_MS);
       continue;
     }
+    // Removed in the app (GET-1356): this machine stops for good, and won't start at login.
+    if (page.uninstall) {
+      log("Removed in Ownable. This machine stops reading and won't start at login again.");
+      awake?.release();
+      if (onRemoved) await onRemoved();
+      return { answered, removed: true };
+    }
+    // Reading turned off in the app (GET-1356): nothing is read on this plan until it's back on.
+    if (page.reading_off) {
+      if (!offNoted) log("Reading is off in Ownable. Nothing is read on your plan until you turn it back on.");
+      offNoted = true;
+      awake?.release();
+      if (now() - asked < 5000) await sleep(IDLE_MS);
+      continue;
+    }
+    if (offNoted) { log("Reading is on again."); offNoted = false; }
     // One command sets everything up (GET-1307): with no history read yet, the runner starts that
     // read itself, on this plan, and answers its calls like any other.
     if (page.needs_backfill && api.startBackfill && now() - backfillAt >= BACKFILL_RETRY_MS) {
@@ -129,6 +201,7 @@ export async function runRunner({ api, agent, host = hostname(), version = null,
         log(`Your history read can't start yet (${err.message}). Trying again in ${BACKFILL_RETRY_MS / 60000} minutes.`);
       }
     }
+    if (awake) { if (hasWork(page)) awake.touch(); else awake.tick(); }
     const line = readingLine(page.reading);
     if (line && line !== lastLine) { log(line); }
     lastLine = line;
@@ -140,7 +213,9 @@ export async function runRunner({ api, agent, host = hostname(), version = null,
       continue;
     }
     await Promise.all(calls.map((c) => answerOne(c, page.models)));
+    sleptNoted = false;
   }
+  awake?.release();
   return { answered };
 }
 
@@ -252,6 +327,24 @@ export function uninstallService({ run = spawnSync, os = platform(), home = home
   return true;
 }
 
+/**
+ * Removed in the app (GET-1356), from inside the running service: the start-at-login file goes first,
+ * then the service manager stops this process (so last). Returns whether a service was there.
+ */
+export function removeSelf({ run = spawnSync, os = platform(), home = homedir() } = {}) {
+  const where = servicePaths(os, home);
+  if (!where || !existsSync(where.file)) return false;
+  if (where.kind === "launchd") {
+    rmSync(where.file, { force: true });
+    run("launchctl", ["remove", LABEL], { stdio: "ignore" });
+  } else {
+    run("systemctl", ["--user", "disable", "opennous-runner.service"], { stdio: "ignore" });
+    rmSync(where.file, { force: true });
+    run("systemctl", ["--user", "stop", "opennous-runner.service"], { stdio: "ignore" });
+  }
+  return true;
+}
+
 /** Whether the service is installed, and running as far as the OS says. */
 export function serviceStatus({ run = spawnSync, os = platform(), home = homedir() } = {}) {
   const where = servicePaths(os, home);