orchestrating 0.3.3 → 0.4.1

package/bin/orch

@@ -57,12 +57,17 @@ function clearAuth() {
 const SUPABASE_URL = process.env.SUPABASE_URL || "https://vhyqfzdskgrmnxrdaqql.supabase.co";
 const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZoeXFmemRza2dybW54cmRhcXFsIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzE1NjU5NTYsImV4cCI6MjA4NzE0MTk1Nn0.hWAceFshHoeTlnwThM08enNWG-ZeXICl3uyi-AmIJEk";
 
+// Returns one of:
+//   { ok: true, token }             — refreshed successfully
+//   { ok: false, permanent: true }  — refresh token invalid/revoked; re-auth required
+//   { ok: false, permanent: false } — transient failure (network/5xx); safe to retry with backoff
 async function refreshAuthToken() {
   const auth = loadStoredAuth();
-  if (!auth || !auth.refresh_token) return null;
+  if (!auth || !auth.refresh_token) return { ok: false, permanent: true };
 
+  let res;
   try {
-    const res = await fetch(`${SUPABASE_URL}/auth/v1/token?grant_type=refresh_token`, {
+    res = await fetch(`${SUPABASE_URL}/auth/v1/token?grant_type=refresh_token`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -70,20 +75,30 @@ async function refreshAuthToken() {
       },
       body: JSON.stringify({ refresh_token: auth.refresh_token }),
     });
+  } catch {
+    // Network error / server unreachable — transient
+    return { ok: false, permanent: false };
+  }
 
-    if (!res.ok) return null;
-
-    const data = await res.json();
-    if (data.access_token) {
+  if (res.ok) {
+    let data;
+    try { data = await res.json(); } catch { return { ok: false, permanent: false }; }
+    if (data && data.access_token) {
       saveAuth({
         access_token: data.access_token,
         refresh_token: data.refresh_token || auth.refresh_token,
         expires_at: data.expires_at || 0,
       });
-      return data.access_token;
+      return { ok: true, token: data.access_token };
     }
-  } catch {}
-  return null;
+    return { ok: false, permanent: true };
+  }
+
+  // 400/401/403 → refresh token rejected (permanent). 408/429/5xx/522 → transient.
+  if (res.status === 400 || res.status === 401 || res.status === 403) {
+    return { ok: false, permanent: true };
+  }
+  return { ok: false, permanent: false };
 }
 
 function getAuthToken() {
@@ -480,12 +495,16 @@ async function handleDaemon(projectsDir) {
     process.exit(1);
   }
   if (isTokenExpired()) {
-    const refreshed = await refreshAuthToken();
-    if (refreshed) {
-      token = refreshed;
-    } else {
+    const r = await refreshAuthToken();
+    if (r.ok) {
+      token = r.token;
+    } else if (r.permanent) {
       console.error(`${RED}Session expired. Run 'orch login' to re-authenticate.${RESET}`);
       process.exit(1);
+    } else {
+      // Auth server unreachable at startup — keep the (stale) token and let the
+      // reconnect loop retry with backoff rather than crash-loop under launchd.
+      console.error(`${RED}Could not reach auth server — will keep retrying in the background.${RESET}`);
     }
   }
 
@@ -497,11 +516,17 @@ async function handleDaemon(projectsDir) {
   const PING_INTERVAL_MS = 30_000;
   const PONG_TIMEOUT_MS = 10_000;
   const HEARTBEAT_TIMEOUT_MS = 65_000; // expect server heartbeat every 30s, allow 2 missed + margin
+  const RECONNECT_BASE_SEC = 2;        // initial reconnect delay
+  const RECONNECT_MAX_SEC = 300;       // cap backoff at 5 min so a down server isn't hammered
+  const REAUTH_POLL_SEC = 300;         // while paused for re-auth, re-check the token every 5 min
   let ws = null;
   let pingTimer = null;
   let pongTimer = null;
   let reconnectTimer = null;
   let heartbeatTimer = null;
+  let reauthTimer = null;
+  let reconnectAttempts = 0;           // grows on consecutive failures; reset on a successful connect
+  let needsReauth = false;             // true once the refresh token is rejected; pauses the reconnect loop
 
   // Scan project directories
   const homeDir = os.homedir();
@@ -536,25 +561,59 @@ async function handleDaemon(projectsDir) {
     }, HEARTBEAT_TIMEOUT_MS);
   }
 
-  function scheduleReconnect(delaySec) {
-    if (reconnecting) return;
+  function scheduleReconnect(minSec) {
+    if (reconnecting || needsReauth) return;
     reconnecting = true;
+    // Exponential backoff with full jitter, capped — bounds the request rate when the
+    // server or auth endpoint is down (a fixed delay meant relentless retries forever).
+    const exp = Math.min(RECONNECT_MAX_SEC, RECONNECT_BASE_SEC * 2 ** reconnectAttempts);
+    const ceil = Math.max(minSec, exp);
+    const delay = Math.round(ceil / 2 + Math.random() * (ceil / 2));
+    reconnectAttempts++;
     if (reconnectTimer) clearTimeout(reconnectTimer);
     reconnectTimer = setTimeout(() => {
       reconnecting = false;
       connect();
-    }, delaySec * 1000);
+    }, delay * 1000);
+  }
+
+  // Refresh token was rejected. Stop reconnecting (no point hammering the server) and
+  // wait for the user to run `orch login`. Staying alive — rather than exiting — avoids a
+  // launchd/systemd KeepAlive respawn loop that would just re-trigger the request flood.
+  function enterReauthWait() {
+    if (needsReauth) return;
+    needsReauth = true;
+    if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+    process.stderr.write(`${RED}${PREFIX} Session invalid — run 'orch login' to re-authenticate.${RESET}\n`);
+    process.stderr.write(`${DIM}${PREFIX} Paused; will resume automatically once re-authenticated.${RESET}\n`);
+    const check = () => {
+      const auth = loadStoredAuth();
+      if (auth && auth.access_token && !isTokenExpired()) {
+        needsReauth = false;
+        reconnectAttempts = 0;
+        token = auth.access_token;
+        process.stderr.write(`${GREEN}${PREFIX} Re-authenticated — reconnecting${RESET}\n`);
+        connect();
+      } else {
+        reauthTimer = setTimeout(check, REAUTH_POLL_SEC * 1000);
+      }
+    };
+    reauthTimer = setTimeout(check, REAUTH_POLL_SEC * 1000);
   }
 
   async function connect() {
+    if (needsReauth) return; // paused until the user re-authenticates
     // Refresh token if needed before connecting
     if (isTokenExpired()) {
-      const refreshed = await refreshAuthToken();
-      if (refreshed) {
-        token = refreshed;
+      const r = await refreshAuthToken();
+      if (r.ok) {
+        token = r.token;
         process.stderr.write(`${DIM}${PREFIX} Token refreshed${RESET}\n`);
+      } else if (r.permanent) {
+        enterReauthWait();
+        return;
       } else {
-        process.stderr.write(`${RED}${PREFIX} Token refresh failed — retrying in 10s${RESET}\n`);
+        process.stderr.write(`${RED}${PREFIX} Token refresh failed (auth server unreachable) — backing off${RESET}\n`);
         scheduleReconnect(10);
         return;
       }
@@ -568,6 +627,7 @@ async function handleDaemon(projectsDir) {
     ws = sock;
 
     sock.on("open", () => {
+      reconnectAttempts = 0; // healthy connection — reset backoff
       sock.send(JSON.stringify({
         type: "register_daemon",
         token,
@@ -610,14 +670,14 @@ async function handleDaemon(projectsDir) {
         process.stderr.write(`${RED}${PREFIX} Server: ${msg.error}${RESET}\n`);
         if (/unauthorized|auth|token/i.test(msg.error || "")) {
           // Don't reconnect from here — let the close handler do it after refreshing
-          refreshAuthToken().then((refreshed) => {
-            if (refreshed) {
-              token = refreshed;
+          refreshAuthToken().then((r) => {
+            if (r.ok) {
+              token = r.token;
               process.stderr.write(`${DIM}${PREFIX} Token refreshed — will reconnect${RESET}\n`);
-            } else {
-              process.stderr.write(`${RED}${PREFIX} Auth failed. Run 'orch login'.${RESET}\n`);
-              process.exit(1);
+            } else if (r.permanent) {
+              enterReauthWait();
             }
+            // transient: leave it — the close handler's backoff retry will try again
           });
         }
         return;
@@ -769,6 +829,7 @@ async function handleDaemon(projectsDir) {
     if (pongTimer) clearTimeout(pongTimer);
     if (heartbeatTimer) clearTimeout(heartbeatTimer);
     if (reconnectTimer) clearTimeout(reconnectTimer);
+    if (reauthTimer) clearTimeout(reauthTimer);
     if (ws) ws.close();
     process.exit(0);
   };
@@ -1057,6 +1118,7 @@ if (adapter) {
   // Spawn claude with bidirectional stdin/stdout (stream-json mode)
   // Follow-ups are sent via stdin — no more kill/respawn.
   let claudeSessionId = null; // Claude's internal session ID (from init event)
+  let pendingRespawn = null; // { prompt } — set when permission grant needs respawn
 
   function spawnClaude(claudeArgs) {
     const proc = spawn(command, claudeArgs, {
@@ -1104,8 +1166,8 @@ if (adapter) {
         if (yoloMode && event.kind === "permission_denied") {
           process.stderr.write(`${GREEN}[yolo] Auto-approving: ${event.toolName}${RESET}\n`);
           approvePermission(event.toolName, "session");
-          // Permissions are file-based — need respawn for Claude to pick them up
-          respawnWithContinue(`Permission for ${event.toolName} was granted. Please retry your last action.`);
+          // Queue respawn — Claude will exit after this turn, then we respawn with -c
+          pendingRespawn = { prompt: `Permission for ${event.toolName} was granted. Please retry your last action.` };
         }
       }
     });
@@ -1117,8 +1179,23 @@ if (adapter) {
     proc.on("exit", (code) => {
       childRunning = false;
       const exitCode = code ?? 0;
-      sendToServer({ type: "exit", sessionId, exitCode });
-      setTimeout(() => process.exit(exitCode), 200);
+
+      if (exitCode !== 0 || exitRequested) {
+        // Non-zero exit or user requested stop — terminate
+        sendToServer({ type: "exit", sessionId, exitCode });
+        setTimeout(() => process.exit(exitCode), 200);
+      } else if (pendingRespawn) {
+        // Permission grant/deny triggered a respawn — do it now
+        const { prompt: respawnPrompt } = pendingRespawn;
+        pendingRespawn = null;
+        respawnWithContinue(respawnPrompt);
+      } else {
+        // Normal exit (turn complete) — stay alive, emit idle, wait for follow-ups
+        sendToServer({
+          type: "agent_event", sessionId,
+          event: { kind: "status", status: "idle" },
+        });
+      }
     });
 
     proc.on("error", (err) => {
@@ -1283,10 +1360,9 @@ if (adapter) {
 
   handleServerMessage = (msg) => {
     if (msg.type === "agent_input" && (msg.text || msg.images)) {
-      // Follow-up from dashboard — send via stdin (no respawn!)
+      // Follow-up from dashboard
       if (childRunning) {
         process.stderr.write(`${DIM}[orch] Queuing input — claude is still processing${RESET}\n`);
-        // TODO: queue and send after current turn completes
         return;
       }
       let promptText = msg.text || "continue";
@@ -1303,17 +1379,33 @@ if (adapter) {
         const fileList = imagePaths.map((p) => `[Attached image: ${p} — use Read tool to view]`).join("\n");
         promptText = `${fileList}\n\n${promptText}`;
       }
-      sendFollowUp(promptText);
+      // If process is still alive, send via stdin; otherwise respawn
+      if (child && child.exitCode === null) {
+        sendFollowUp(promptText);
+      } else {
+        respawnWithContinue(promptText);
+      }
     } else if (msg.type === "agent_permission" && msg.tool && msg.action === "allow") {
       const scope = msg.scope || "session";
       approvePermission(msg.tool, scope);
       process.stderr.write(`${GREEN}Permission granted (${scope}): ${msg.tool}${RESET}\n`);
-      // Permissions are file-based in Claude Code — need to restart the process
-      // so it picks up the updated settings.local.json
-      respawnWithContinue(`Permission for ${msg.tool} was granted. Please retry your last action.`);
+      // Permissions are file-based — Claude needs restart to pick up settings.local.json
+      const respawnPrompt = `Permission for ${msg.tool} was granted. Please retry your last action.`;
+      if (child && child.exitCode === null) {
+        // Process still running — queue respawn for when it exits
+        pendingRespawn = { prompt: respawnPrompt };
+      } else {
+        // Process already exited — respawn now
+        respawnWithContinue(respawnPrompt);
+      }
     } else if (msg.type === "agent_permission" && msg.tool && msg.action === "deny") {
       process.stderr.write(`${RED}Permission denied: ${msg.tool}${RESET}\n`);
-      respawnWithContinue(`Permission for ${msg.tool} was denied by the user. Do not retry this tool — find an alternative approach or skip this step.`);
+      const denyPrompt = `Permission for ${msg.tool} was denied by the user. Do not retry this tool — find an alternative approach or skip this step.`;
+      if (child && child.exitCode === null) {
+        pendingRespawn = { prompt: denyPrompt };
+      } else {
+        respawnWithContinue(denyPrompt);
+      }
     } else if (msg.type === "agent_permission" && msg.tool && msg.action === "revoke") {
       removePermission(msg.tool);
       broadcastPermissions();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchestrating",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "description": "Stream terminal sessions to the orchestrat.ing dashboard",
   "type": "module",
   "bin": {