@opennous/cli 0.17.1 → 0.18.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @opennous/cli changelog
 
+## 0.18.1
+
+### Fixed: one machine is one runner
+
+The runner named your machine by its network hostname, which on a Mac changes with the network, so
+one Mac could show up as two runners. It now uses the Mac's own name, saved once (GET-1308).
+
+## 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennous/cli",
-  "version": "0.17.1",
+  "version": "0.18.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/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 }),
   };
 }
 
@@ -662,17 +663,19 @@ const runnerCmd = program
     const { detectAgents, liveRun, NO_AGENT } = await import("./backfill.js");
     const { runRunner } = await import("./runner.js");
     const agent = await pickAgent(opts.agent, detectAgents, NO_AGENT);
+    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()));
     await runRunner({
-      agent, version, run: liveRun(), log: (l) => console.log(stamp(l)),
+      agent, host, version, run: liveRun(), log: (l) => console.log(stamp(l)),
       sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
       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),
       },
     });
   });
@@ -690,14 +693,14 @@ runnerCmd
     const key = await runnerKey(opts);
     // One poll before installing, so a bad key or plan fails here and not silently in the background.
     try {
-      await apiClient(key).softPost("/v2/runner/poll", { agent, host: hostname(), version, limit: 0 });
+      await apiClient(key).softPost("/v2/runner/poll", { agent, host: await runnerHost(), version, limit: 0 });
     } catch (e) {
       console.error(`Couldn't connect: ${e.message}`);
       process.exit(1);
     }
     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 +714,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: await runnerHost() }).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
@@ -725,6 +731,15 @@ 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). */
+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;
+}
+
 /** The agent to read with: the one asked for, or whichever is signed in. Exits with what to do. */
 async function pickAgent(asked, detectAgents, noAgent) {
   const agents = detectAgents();

package/src/runner.js

@@ -11,10 +11,17 @@ import { dirname, join } from "node:path";
 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. */
@@ -27,6 +34,21 @@ const ERROR_BACKOFF_MS = 30_000;
 export const LABEL = "cloud.opennous.runner";
 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.
+ */
+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" });
+    const name = r.status === 0 ? String(r.stdout).trim() : "";
+    if (name) return name;
+  }
+  return String(host()).replace(/\.(local|lan|home|localdomain)$/i, "");
+}
+
 /** What the status line says about the read in progress, or null. Pure. */
 export function readingLine(reading) {
   if (!reading) return null;
@@ -53,7 +75,7 @@ export function pauseLine(agent, reason, until, now = Date.now()) {
  */
 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, limitReason = null, 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 {
@@ -80,8 +102,9 @@ 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,
+      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; }
@@ -91,15 +114,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 };