@appchy/jarvis 0.1.6 → 0.1.8

package/dist/bin.js

@@ -2519,14 +2519,77 @@ function createUpstreamClient(config) {
   let ws = null;
   let messageHandler = null;
   let reconnectTimer = null;
+  let refreshTimer = null;
   let closed = false;
+  let authFailures = 0;
+  let retries = 0;
+  let currentToken = config.token;
+  const MAX_AUTH_RETRIES = 3;
+  const MAX_RETRIES = 3;
+  const REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+  function getRefreshUrl() {
+    if (config.refreshUrl) return config.refreshUrl;
+    if (!config.refreshToken) return null;
+    return config.apiUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:") + "/refresh";
+  }
+  function getTokenExpiry(token) {
+    try {
+      const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+      return payload.exp ?? null;
+    } catch {
+      return null;
+    }
+  }
+  function scheduleRefresh() {
+    if (refreshTimer) clearTimeout(refreshTimer);
+    if (!config.refreshToken) return;
+    const exp = getTokenExpiry(currentToken);
+    if (!exp) return;
+    const msUntilExpiry = exp * 1e3 - Date.now();
+    const refreshIn = Math.max(msUntilExpiry - REFRESH_BUFFER_MS, 0);
+    logger.sys.info("[Upstream] Token refresh scheduled", {
+      expiresIn: `${Math.round(msUntilExpiry / 1e3)}s`,
+      refreshIn: `${Math.round(refreshIn / 1e3)}s`
+    });
+    refreshTimer = setTimeout(refreshToken, refreshIn);
+  }
+  async function refreshToken() {
+    const url = getRefreshUrl();
+    if (!url || !config.refreshToken) return false;
+    try {
+      logger.sys.info("[Upstream] Refreshing token...");
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refreshToken: config.refreshToken })
+      });
+      if (!res.ok) {
+        logger.sys.error("[Upstream] Token refresh failed", { status: res.status });
+        return false;
+      }
+      const { token } = await res.json();
+      currentToken = token;
+      logger.sys.info("[Upstream] Token refreshed successfully");
+      ws?.close();
+      scheduleRefresh();
+      return true;
+    } catch (err) {
+      logger.sys.error("[Upstream] Token refresh error", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return false;
+    }
+  }
   function connect() {
     if (closed) return;
     ws = new WebSocket2(config.apiUrl, {
-      headers: { authorization: `Bearer ${config.token}` }
+      headers: { authorization: `Bearer ${currentToken}` }
     });
     ws.on("open", () => {
+      authFailures = 0;
+      retries = 0;
       logger.sys.info("[Upstream] Connected to cloud", { apiUrl: config.apiUrl });
+      scheduleRefresh();
     });
     ws.on("message", (raw) => {
       try {
@@ -2539,11 +2602,56 @@ function createUpstreamClient(config) {
       } catch {
       }
     });
-    ws.on("close", () => {
-      if (!closed) {
-        logger.sys.info("[Upstream] Disconnected, reconnecting in 3s...");
+    ws.on("close", (code) => {
+      if (closed) return;
+      if (code === 4001 || code === 4003) {
+        if (config.refreshToken) {
+          refreshToken().then((ok) => {
+            if (ok) {
+              reconnectTimer = setTimeout(connect, 1e3);
+            } else {
+              authFailures++;
+              if (authFailures >= MAX_AUTH_RETRIES) {
+                logger.sys.error("[Upstream] Auth failed after max retries, giving up", {
+                  code,
+                  attempts: authFailures
+                });
+                return;
+              }
+              reconnectTimer = setTimeout(connect, 3e3);
+            }
+          });
+          return;
+        }
+        authFailures++;
+        if (authFailures >= MAX_AUTH_RETRIES) {
+          logger.sys.error("[Upstream] Auth failed after max retries, giving up", {
+            code,
+            attempts: authFailures
+          });
+          return;
+        }
+        logger.sys.warn("[Upstream] Auth failed, retrying...", {
+          code,
+          attempt: authFailures,
+          maxRetries: MAX_AUTH_RETRIES
+        });
         reconnectTimer = setTimeout(connect, 3e3);
+        return;
+      }
+      retries++;
+      if (retries >= MAX_RETRIES) {
+        logger.sys.error("[Upstream] Max reconnect attempts reached, giving up", {
+          attempts: retries
+        });
+        return;
       }
+      logger.sys.info("[Upstream] Disconnected, reconnecting in 3s...", {
+        code,
+        attempt: retries,
+        maxRetries: MAX_RETRIES
+      });
+      reconnectTimer = setTimeout(connect, 3e3);
     });
     ws.on("error", (err) => {
       logger.sys.error("[Upstream] Connection error", {
@@ -2565,6 +2673,7 @@ function createUpstreamClient(config) {
   function close() {
     closed = true;
     if (reconnectTimer) clearTimeout(reconnectTimer);
+    if (refreshTimer) clearTimeout(refreshTimer);
     ws?.close();
   }
   return { connect, send, onMessage, isConnected, close };
@@ -4705,6 +4814,7 @@ function createCli() {
         ...existing,
         apiUrl: parsed.apiUrl,
         token: parsed.jwt,
+        refreshToken: parsed.refreshToken,
         userId: parsed.userId,
         envId: parsed.envId,
         ...opts.workspace ? { workspacePath: opts.workspace } : {},
@@ -4744,7 +4854,14 @@ function createCli() {
         anthropicApiKey,
         useSubscription: !anthropicApiKey,
         userId,
-        upstream: opts.upstream && config?.apiUrl && config?.token ? { apiUrl: config.apiUrl, token: config.token } : void 0
+        upstream: (() => {
+          const apiUrl = process.env.JARVIS_UPSTREAM_URL ?? config?.apiUrl;
+          const token = process.env.JARVIS_UPSTREAM_TOKEN ?? config?.token;
+          if (opts.upstream && apiUrl && token) {
+            return { apiUrl, token, refreshToken: config?.refreshToken };
+          }
+          return void 0;
+        })()
       });
       return;
     }