@opennous/cli 0.17.0 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @opennous/cli changelog
 
+## 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.17.1",
   "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/runner.js

@@ -8,7 +8,7 @@ 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. */
@@ -17,7 +17,10 @@ export const BUSY_MS = 2000;
 export const IDLE_MS = 20_000;
 /** 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 +37,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, toldBackfill = false;
   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; }
@@ -64,7 +82,8 @@ export async function runRunner({ api, agent, host = hostname(), version = null,
     let page;
     try {
       page = await api.poll({ agent, host, version, answered, limit: workers,
-        limited_until: limitedUntil > now() ? new Date(limitedUntil).toISOString() : null });
+        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.`);