privateer-agent 0.12.18 → 0.12.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "privateer-agent",
-  "version": "0.12.18",
+  "version": "0.12.19",
   "description": "Privacy-first terminal coding agent — bring your own model across 20 providers (Anthropic, OpenAI, OpenRouter, Google, local Ollama…). Safe-by-default permissions, MCP, sub-agents, workflows, and verifiable TEE inference. Built on the Pi toolkit.",
   "type": "module",
   "license": "MIT",

package/src/harbor/index.ts

@@ -651,6 +651,16 @@ export class Harbor {
   }
 
   private async tick(): Promise<void> {
+    // Retry the relay every tick, not just at startup. syncRelay() bails when the
+    // account isn't signed in on this machine — and a harbor that came up in that
+    // state used to stay off the relay FOREVER, because start() was the only caller
+    // that mattered (the three IPC commands that also call it are ones the desktop
+    // app never sends). Signing in afterwards wrote credentials.json and changed
+    // nothing: the harbor kept answering IPC, so the app called it running, while
+    // its relay socket had never been opened — the permanent "Connecting" with a
+    // harbor that fires no routine and answers no spawn. Cheap and idempotent: it
+    // returns immediately once a client exists, or while remote access is off.
+    this.syncRelay();
     void this.flushPendingCloud();
     const now = Date.now();
     for (const r of loadRoutines()) {
@@ -1269,19 +1279,35 @@ export class Harbor {
   private relayStatus(): RelayStatus {
     const termId = routineRelayId();
     if (this.relayTerminated) {
-      return { termId, connected: false, detail: "remote access was turned off from the app — restart the harbor to re-enable it" };
+      return { termId, connected: false, reason: "terminated", detail: "remote access was turned off from the app — restart the harbor to re-enable it" };
     }
     if (!this.relay) {
+      // "relay not started" with credentials present is now a sub-tick window, not a
+      // permanent state: tick() re-runs syncRelay(), so a harbor that came up signed
+      // out connects on its own once you sign in. Reported as "connecting" because
+      // that is what it now is.
+      const signedIn = hasCredentials();
       return {
         termId,
         connected: false,
-        detail: hasCredentials()
+        reason: signedIn ? "connecting" : "signed-out",
+        detail: signedIn
           ? "relay not started"
-          : "no account signed in on this machine — run `privateer` and /login, then restart the harbor",
+          : "no account signed in on this machine — run `privateer` and /login",
       };
     }
     const conn = this.relay.connectionStatus();
-    if (!conn.connected) return { termId, connected: false, detail: "connecting…" };
+    // The client knows why it isn't up — a refused ticket, an unreachable server —
+    // and reporting a flat "connecting…" over the top of that is what made a harbor
+    // that will never connect look like one that is about to.
+    if (!conn.connected) {
+      return {
+        termId,
+        connected: false,
+        reason: conn.refused ? "refused" : "connecting",
+        detail: conn.detail ?? "connecting…",
+      };
+    }
     return { termId, connected: true, upSec: conn.upSec, quietSec: conn.quietSec };
   }
 

package/src/harbor/ipc.ts

@@ -42,6 +42,21 @@ export type IpcRequest =
   | { cmd: "run-now"; idOrName: string }
   | { cmd: "reload" };
 
+/**
+ * Why a harbor isn't on the relay, as a code rather than a sentence.
+ *
+ * `detail` below is written for a terminal — it names CLI commands and is English
+ * only — so the app can't put it in front of a user. It used to have nothing else
+ * to go on, and said "give it a moment" about every one of these, including the
+ * three that never clear on their own. This is the machine-readable half.
+ *
+ *   terminated  remote access was switched off from the app; needs a restart
+ *   signed-out  no account credentials on this machine
+ *   refused     the server said no (plan's agent cap, rejected ticket) — standing
+ *   connecting  genuinely still trying; this one really is worth a moment
+ */
+export type RelayReason = "terminated" | "signed-out" | "refused" | "connecting";
+
 /**
  * The harbor's view of its own relay connection, reported by `status`.
  *
@@ -62,6 +77,8 @@ export interface RelayStatus {
   quietSec?: number;
   /** Why it isn't connected, when we know: signed out, turned off from the app, … */
   detail?: string;
+  /** The same fact as `detail`, for a caller that has to localize it. */
+  reason?: RelayReason;
 }
 
 export interface IpcResponse {

package/src/remote/relayClient.ts

@@ -383,6 +383,11 @@ export class RelayClient {
   private reconnectDelay = RECONNECT_MS;
   // Last refusal reason reported, so a 4xx is logged once instead of on every retry.
   private refusal: string | null = null;
+  // Why the last connection attempt failed, kept for connectionStatus(). A refusal
+  // (4xx) outranks it — that one is a decision, not a hiccup — but without either,
+  // every un-connected relay reports as a bare "connecting…", which is the same
+  // sentence whether the socket opens in two seconds or never opens again.
+  private lastFailure: string | null = null;
   // Ordered delta buffer (text/reasoning) coalesced into one frame per flush.
   private bufKind: "text" | "reasoning" | null = null;
   private buf = "";
@@ -518,6 +523,7 @@ export class RelayClient {
       ws.on("open", () => {
         opened = true;
         this.refusal = null; // a later refusal is news again
+        this.lastFailure = null; // whatever kept us out is history
         this.reconnectDelay = RECONNECT_MS; // reachable again — next blip retries fast
         this.connectedAt = Date.now();
         this.startHeartbeat(ws);
@@ -537,6 +543,9 @@ export class RelayClient {
         // attach/detach frame said. Re-learned on the next attach or inbound frame.
         this.controllerHere = false;
         this.cb.onDisconnected?.();
+        // A socket that never opened failed for a reason worth reporting; one that
+        // opened and dropped is an ordinary blip the reconnect handles.
+        this.lastFailure = opened ? null : lastErr || "the relay connection closed before it opened";
         if (!this.closed) {
           this.cb.onStatus?.(
             opened
@@ -560,6 +569,7 @@ export class RelayClient {
       const status = (err as { status?: number })?.status;
       const refused = typeof status === "number" && status >= 400 && status < 500;
       if (refused) {
+        this.lastFailure = msg;
         this.settleFirstConnect(err instanceof Error ? err : new Error(msg));
         // A refusal is a decision, not a hiccup: hammering the same request every few
         // seconds can't change it, and for a harbor — whose onStatus goes to a log file,
@@ -578,6 +588,7 @@ export class RelayClient {
       }
       // Transient (network/route/5xx): stay on the fast retry.
       this.refusal = null;
+      this.lastFailure = msg;
       this.cb.onStatus?.(`Remote access couldn't reach the relay (${msg}) — retrying…`);
       this.scheduleReconnect();
     } finally {
@@ -970,8 +981,19 @@ export class RelayClient {
   // quiet for longer than the server's 25s ping cadence is the shape of the half-open
   // failure the watchdog exists to catch, so it is worth showing rather than a bare
   // "connected".
-  connectionStatus(): { connected: boolean; upSec?: number; quietSec?: number } {
-    if (!this.isConnected()) return { connected: false };
+  connectionStatus(): { connected: boolean; upSec?: number; quietSec?: number; detail?: string; refused?: boolean } {
+    // Not connected: say WHY when we know. A standing refusal (the plan's agent cap,
+    // a rejected ticket) is the answer that matters most — it will not clear on its
+    // own, and it's the one case a caller should present as a decision rather than a
+    // wait — so it wins over the last transient error and is flagged as itself.
+    if (!this.isConnected()) {
+      const detail = this.refusal ?? this.lastFailure;
+      return {
+        connected: false,
+        ...(detail ? { detail } : {}),
+        ...(this.refusal ? { refused: true } : {}),
+      };
+    }
     const now = Date.now();
     return {
       connected: true,