orchestrating 0.4.0 → 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);
   };

package/package.json

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