@opennous/cli 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @opennous/cli changelog
 
+## 0.18.0
+
+### Changed: one command sets everything up, and the runner is quiet when idle
+
+`runner install` is the only command you need: with no history read yet, the runner starts that read
+itself (six months, on your plan), then keeps everything new current. Idle, it checks in about once a
+minute and still picks up new work within seconds. `runner uninstall` tells Ownable this machine
+stopped, so with no runner left your reading goes back to credits (GET-1307).
+
+## 0.17.1
+
+### Fixed: a sign-out or an outage no longer fails your reads
+
+Signed out of Claude or Codex, or the model not answering: `runner` and `backfill` now wait instead
+of marking every conversation unreadable, and tell you what to run. At your plan's limit they wait
+until the reset time the limit message names, not a fixed 30 minutes (GET-1303).
+
 ## 0.17.0
 
 ### Added: `runner`, reading on your own plan all the time

package/README.md

@@ -21,7 +21,7 @@ npx @opennous/cli@latest backfill          # your history, once
 npx @opennous/cli@latest runner install    # what's new, from now on; starts at login
 ```
 
-`runner status` says whether it's running, `runner uninstall` stops it. Settings → Your plan in the app shows each runner and what's waiting to be read.
+`runner status` says whether it's running, `runner uninstall` stops it. Settings → AI subscription in the app shows each runner and what's waiting to be read.
 
 ## Event tracking
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennous/cli",
-  "version": "0.17.0",
+  "version": "0.18.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

@@ -53,14 +53,16 @@ export function parseAnswer(agent, out) {
     if (j.is_error) throw new Error(String(j.result));
     return { text: j.result, usage: { input_tokens: j.usage?.input_tokens ?? 0, output_tokens: j.usage?.output_tokens ?? 0 } };
   }
-  let text = "", usage = null;
+  let text = "", usage = null, error = null;
   for (const line of out.split("\n")) {
     let e;
     try { e = JSON.parse(line); } catch { continue; }
     if (e.item?.type === "agent_message") text = e.item.text;
     if (e.usage) usage = e.usage;
+    // An error event says why (a limit, a sign-out), which the runner needs (GET-1303).
+    if (e.type === "error" || e.type === "turn.failed") error = e.message ?? e.error?.message ?? error;
   }
-  if (!text) throw new Error("codex gave no answer");
+  if (!text) throw new Error(error || "codex gave no answer");
   return { text, usage: { input_tokens: usage?.input_tokens ?? 0, output_tokens: usage?.output_tokens ?? 0 } };
 }
 
@@ -69,6 +71,55 @@ export function isPlanLimit(message) {
   return /usage limit|rate.?limit|hit your .*limit|limit reached|too many requests|\b429\b|quota/i.test(String(message));
 }
 
+/**
+ * What an error says about the plan, not the call (GET-1303): 'limit' (passes at its reset),
+ * 'signed_out' (passes when the person signs in again), 'outage' (the model is down; passes by
+ * itself), or null for a bad call. A call that fails for any of these is not unreadable, so it must
+ * not be marked failed. Pure.
+ */
+export function troubleOf(message) {
+  const m = String(message ?? "");
+  if (isPlanLimit(m)) return "limit";
+  if (/not logged in|please (run )?\/?login|log ?in again|sign ?in again|invalid api key|authentication[_ ](error|failed)|oauth token|token (has )?expired|unauthori[sz]ed|\b401\b|codex login/i.test(m)) return "signed_out";
+  if (/overloaded|\b529\b|\b503\b|\b502\b|service unavailable|internal server error|api error: 5\d\d|econnreset|etimedout|enotfound|network error|socket hang up|stream disconnected/i.test(m)) return "outage";
+  return null;
+}
+
+const MIN_WAIT_MS = 60_000;
+const MAX_WAIT_MS = 7 * 86_400_000;
+
+/**
+ * When the plan's limit lifts, from its own message (GET-1303), or null when it doesn't say.
+ * Claude: "…limit reached|1731470400" or "resets 3pm" / "resets 3:30pm". Codex: "try again in 2 hours
+ * 5 minutes" or "try again at 3:04 PM". Clock times are this machine's local time, the next one to
+ * come. A minute is added, so the retry lands after the reset, not on it. Pure.
+ */
+export function resetAt(message, now = Date.now()) {
+  const m = String(message ?? "");
+  const clamp = (t) => (Number.isFinite(t) && t > now ? Math.min(now + MAX_WAIT_MS, Math.max(now + MIN_WAIT_MS, t + 60_000)) : null);
+  const unix = /\|(\d{10})\b/.exec(m);
+  if (unix) return clamp(Number(unix[1]) * 1000);
+  const inMatch = /try again in\s+(?:(\d+)\s*d(?:ays?)?\s*)?(?:(\d+)\s*h(?:ours?|rs?)?\s*)?(?:(\d+)\s*m(?:in(?:utes?)?)?)?/i.exec(m);
+  if (inMatch && (inMatch[1] || inMatch[2] || inMatch[3])) {
+    const ms = ((+inMatch[1] || 0) * 24 * 60 + (+inMatch[2] || 0) * 60 + (+inMatch[3] || 0)) * 60_000;
+    return clamp(now + ms);
+  }
+  const clock = /(?:resets?|try again at)\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i.exec(m);
+  if (clock) {
+    let h = Number(clock[1]);
+    const min = Number(clock[2] ?? 0);
+    const ap = clock[3]?.toLowerCase();
+    if (h > 23 || min > 59 || (ap && (h < 1 || h > 12))) return null;
+    if (ap === "pm" && h < 12) h += 12;
+    if (ap === "am" && h === 12) h = 0;
+    const d = new Date(now);
+    d.setHours(h, min, 0, 0);
+    if (d.getTime() <= now) d.setDate(d.getDate() + 1);
+    return clamp(d.getTime());
+  }
+  return null;
+}
+
 export function detectAgents(run = spawnSync) {
   const found = [];
   if (run("claude", ["auth", "status"], { encoding: "utf8" }).status === 0) found.push("claude");
@@ -167,9 +218,19 @@ export async function runBackfill({ api, agent, jobId, run, sleep, log, now = Da
         answered++;
         return;
       } catch (err) {
-        if (isPlanLimit(err.message)) {
-          if (now() >= waitUntil) log(`Your ${agent} plan hit its limit. Waiting ${Math.round(limitWaitMs / 60000)} minutes, then carrying on. You can stop now and run this again later instead.`);
-          waitUntil = Math.max(waitUntil, now() + limitWaitMs);
+        // A limit, a sign-out or an outage (GET-1303) is not this call's fault: wait, then try it again.
+        const trouble = troubleOf(err.message);
+        if (trouble) {
+          const until = trouble === "limit" ? (resetAt(err.message, now()) ?? now() + limitWaitMs) : now() + 5 * 60_000;
+          if (now() >= waitUntil) {
+            const mins = Math.max(1, Math.round((until - now()) / 60000));
+            log(trouble === "signed_out"
+              ? `You're signed out of ${agent}. Run \`${agent === "codex" ? "codex login" : "claude"}\` in another terminal and sign in; this carries on by itself.`
+              : trouble === "outage"
+                ? `${agent} isn't answering right now. Trying again in ${mins} minutes.`
+                : `Your ${agent} plan hit its limit. Waiting ${mins} minutes, until it resets, then carrying on. You can stop now and run this again later instead.`);
+          }
+          waitUntil = Math.max(waitUntil, until);
           continue;
         }
         if (attempt >= RETRIES) { await api.answer(call.id, { error: err.message }); return; }

package/src/index.js

@@ -154,6 +154,7 @@ function apiClient(key) {
     get: (path, query) => request("GET", path, { query }),
     post: (path, body) => request("POST", path, { body }),
     softPost: (path, body) => request("POST", path, { body, soft: true }),
+    softDelete: (path, body) => request("DELETE", path, { body, soft: true }),
   };
 }
 
@@ -673,6 +674,7 @@ const runnerCmd = program
       api: {
         poll: (body) => api.softPost("/v2/runner/poll", body),
         answer: (id, body) => api.softPost(`/v2/runner/calls/${id}`, body),
+        startBackfill: (body) => api.softPost("/v2/backfill/own", body),
       },
     });
   });
@@ -697,7 +699,7 @@ runnerCmd
     }
     try {
       const where = installService({ agent, workspace: opts.workspace ?? null });
-      console.log(`Connected. The runner reads on your ${agent} plan and starts every time you log in.`);
+      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.`);
       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) {
@@ -711,7 +713,10 @@ runnerCmd
   .description("Stop the runner and stop it starting at login")
   .action(async () => {
     const { uninstallService } = await import("./runner.js");
-    console.log(uninstallService() ? "Stopped. It won't start at login any more." : "No runner is installed on this machine.");
+    const removed = uninstallService();
+    // The server stops waiting on this machine (GET-1307): with no runner left, your reading goes back to credits.
+    if (hasKey()) await apiClient().softDelete("/v2/runner", { host: hostname() }).catch(() => {});
+    console.log(removed ? "Stopped. It won't start at login any more, and your reading is back on credits unless another machine runs it." : "No runner is installed on this machine.");
   });
 
 runnerCmd

package/src/runner.js

@@ -8,16 +8,26 @@ import { 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, isPlanLimit } from "./backfill.js";
+import { commandFor, parseAnswer, troubleOf, resetAt } from "./backfill.js";
 
 export const WORKERS = 3;
-/** Busy: there is a read going, so ask again soon. */
+/**
+ * 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.
+ */
+export const WAIT_MS = 45_000;
+/** A server that answers at once (one without long polls): ask again after this. */
 export const BUSY_MS = 2000;
-/** Idle: nothing going. A heartbeat still has to land well inside the server's two minutes. */
 export const IDLE_MS = 20_000;
+/** A history read the runner started that the server could not start yet: try again after this. */
+export const BACKFILL_RETRY_MS = 30 * 60_000;
+export const BACKFILL_DAYS = 180;
 /** At the plan's limit: take nothing, keep the heartbeat. */
 export const LIMITED_POLL_MS = 60_000;
+/** A limit whose message gives no reset time is tried again after this. */
 export const LIMIT_WAIT_MS = 30 * 60_000;
+/** Signed out, or the model down: look again after this (GET-1303). */
+export const RECHECK_MS = 5 * 60_000;
 const RETRIES = 2;
 const ERROR_BACKOFF_MS = 30_000;
 
@@ -34,26 +44,41 @@ export function readingLine(reading) {
   return `${what}.`;
 }
 
+/** What the log says when reading stops for a while, by why. Pure. */
+export function pauseLine(agent, reason, until, now = Date.now()) {
+  const name = agent === "codex" ? "Codex" : "Claude";
+  const at = new Date(until).toLocaleString([], until - now > 20 * 3_600_000
+    ? { weekday: "short", hour: "2-digit", minute: "2-digit" } : { hour: "2-digit", minute: "2-digit" });
+  if (reason === "signed_out") return `You're signed out of ${name}. Run \`${agent === "codex" ? "codex login" : "claude"}\` and sign in; reading carries on by itself. Nothing is lost meanwhile.`;
+  if (reason === "outage") return `${name} isn't answering right now. Trying again at ${at}. Nothing is lost meanwhile.`;
+  return `Your ${name} plan hit its limit. Reading carries on at ${at}, when it resets. Nothing is lost meanwhile.`;
+}
+
 /**
  * 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,
   workers = WORKERS, limitWaitMs = LIMIT_WAIT_MS, stop = () => false }) {
-  let limitedUntil = 0, answered = 0, lastLine = null, lastError = null, toldBackfill = false;
+  let limitedUntil = 0, limitReason = null, answered = 0, lastLine = null, lastError = null, backfillAt = -Infinity;
   const answerOne = async (call, models) => {
     for (let attempt = 0; ; attempt++) {
       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 });
         answered++;
+        if (limitReason) { log(limitReason === "signed_out" ? "Signed in again. Reading." : "Reading again."); limitReason = null; }
         return;
       } catch (err) {
-        // The plan's limit: drop the call (its lease runs out and it comes back) and stop taking
-        // more until the limit lifts. The heartbeat keeps going, so the app shows why.
-        if (isPlanLimit(err.message)) {
-          if (now() >= limitedUntil) log(`Your ${agent} plan hit its limit. Reading waits ${Math.round(limitWaitMs / 60000)} minutes, then carries on by itself.`);
-          limitedUntil = Math.max(limitedUntil, now() + limitWaitMs);
+        // 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.
+        const reason = troubleOf(err.message);
+        if (reason) {
+          const until = reason === "limit" ? (resetAt(err.message, now()) ?? now() + limitWaitMs) : now() + RECHECK_MS;
+          if (now() >= limitedUntil || reason !== limitReason) log(pauseLine(agent, reason, until, now()));
+          limitedUntil = Math.max(limitedUntil, until);
+          limitReason = reason;
           return;
         }
         if (attempt >= RETRIES) { await api.answer(call.id, { error: err.message }).catch(() => {}); return; }
@@ -62,9 +87,11 @@ export async function runRunner({ api, agent, host = hostname(), version = null,
   };
   while (!stop()) {
     let page;
+    const asked = now();
     try {
-      page = await api.poll({ agent, host, version, answered, limit: workers,
-        limited_until: limitedUntil > now() ? new Date(limitedUntil).toISOString() : null });
+      page = await api.poll({ agent, host, version, 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; }
     } catch (err) {
       if (err.message !== lastError) log(`Waiting on Ownable: ${err.message}. Trying again every ${ERROR_BACKOFF_MS / 1000} seconds.`);
@@ -72,15 +99,27 @@ export async function runRunner({ api, agent, host = hostname(), version = null,
       await sleep(ERROR_BACKOFF_MS);
       continue;
     }
-    if (page.needs_backfill && !toldBackfill) {
-      toldBackfill = true;
-      log("Your history hasn't been read yet. Run `npx @opennous/cli@latest backfill` once; after that this keeps it current.");
+    // 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) {
+      backfillAt = now();
+      try {
+        await api.startBackfill({ days: BACKFILL_DAYS, confirm: "yes" });
+        log(`Reading your last ${BACKFILL_DAYS / 30} months of calls and email on your plan. This can take a while; everything new is read after.`);
+      } catch (err) {
+        log(`Your history read can't start yet (${err.message}). Trying again in ${BACKFILL_RETRY_MS / 60000} minutes.`);
+      }
     }
     const line = readingLine(page.reading);
     if (line && line !== lastLine) { log(line); }
     lastLine = line;
     const calls = page.calls ?? [];
-    if (!calls.length) { await sleep(limitedUntil > now() ? LIMITED_POLL_MS : page.reading ? BUSY_MS : IDLE_MS); continue; }
+    if (!calls.length) {
+      if (limitedUntil > now()) { await sleep(LIMITED_POLL_MS); continue; }
+      // The server held the poll open: ask again at once. One that answered at once: wait a little.
+      if (now() - asked < 5000) await sleep(page.reading ? BUSY_MS : IDLE_MS);
+      continue;
+    }
     await Promise.all(calls.map((c) => answerOne(c, page.models)));
   }
   return { answered };