shadok-ai 0.16.2 → 0.16.3

package/README.md

@@ -531,6 +531,17 @@ every 25s (tunable with `SHADOK_WS_PING_MS`) to keep the connection warm, so no
 proxy change is normally needed; if your proxy still cuts it, raise
 `proxy_read_timeout` above the ping interval.
 
+**Sleep / wake.** When a laptop sleeps, the socket's TCP connection usually dies
+without the browser ever seeing a `close`, so it keeps reporting the link as
+"open" while nothing flows. On wake the cockpit no longer trusts that stale
+state: a real wake — the page becoming visible after more than ~10s away, a
+network change (`online`), or a page restored from the back/forward cache —
+tears the suspect socket down and opens a fresh one at once, reattaching to the
+same session. A quick tab switch is left alone (the link is almost certainly
+fine), so you don't pay a reconnect every time you glance away. Previously a
+woken tab waited out the browser's own TCP timeout, tens of seconds to minutes,
+stuck on "reconnecting…".
+
 ### Cross-instance peers
 
 Agents can spawn and drive agents on **another** instance — another of yours, or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shadok-ai",
-  "version": "0.16.2",
+  "version": "0.16.3",
   "main": "dist/session.js",
   "scripts": {
     "test": "node --import tsx --test --test-timeout=120000 test/*.ts context/*/test/*.test.mjs",

package/public/index.html

@@ -7065,19 +7065,50 @@
   }
 
   /** Reconnect every dropped tab immediately (no backoff wait) — fired when the
-   *  machine/tab comes back (online / visible), the common laptop-wake case. */
-  function reconnectAllNow() {
+   *  machine/tab comes back (online / visible), the common laptop-wake case.
+   *  `force` replaces even a socket that still reports OPEN: after a laptop
+   *  sleep the TCP connection is usually dead while the browser has seen no
+   *  `close`, so `readyState` lies "OPEN" and the gentle path would skip the
+   *  tab — leaving it stranded until the browser's own TCP timeout fires
+   *  (tens of seconds to minutes), which is exactly the "stuck reconnecting,
+   *  very slow" symptom. A CONNECTING socket is always left alone: a link is
+   *  already in flight, and tearing it down would only restart the clock. */
+  function reconnectAllNow(force) {
     for (const t of tabs) {
       if (t.closing || !t.sessionId) continue;
       const st = t.ws && t.ws.readyState;
-      if (st === WebSocket.OPEN || st === WebSocket.CONNECTING) continue;
+      if (st === WebSocket.CONNECTING) continue;      // a link is already on its way
+      if (st === WebSocket.OPEN && !force) continue;  // healthy and no reason to doubt it
       if (t.reconnectTimer) clearTimeout(t.reconnectTimer);
       t.reconnectAttempts = 0;
-      openLink(t);
-    }
-  }
-  window.addEventListener("online", reconnectAllNow);
-  document.addEventListener("visibilitychange", () => { if (!document.hidden) reconnectAllNow(); });
+      const old = t.ws;
+      openLink(t);                                    // replaces t.ws with the fresh socket
+      // Close the suspected-zombie only after openLink swapped t.ws, so its
+      // `close` handler sees `t.ws !== ws` and does not schedule a competing
+      // reconnect. A no-op when `old` was already closed.
+      if (old && old !== t.ws) { try { old.close(); } catch {} }
+    }
+  }
+
+  // A real wake (laptop sleep, bfcache restore, a network change) must force a
+  // fresh link; a quick tab switch must not — forcing there would flash
+  // "reconnecting" and pay a resume round-trip every time you glance away.
+  // The tell is how long we were hidden: seconds for an alt-tab, minutes for a
+  // sleep. `online` and a bfcache `pageshow` are forced outright — the network
+  // or the page itself just changed under us.
+  const STALE_WAKE_MS = 10_000;
+  let hiddenAt = 0;
+  function wokeAfterLongAway() {
+    const away = hiddenAt ? Date.now() - hiddenAt : 0;
+    hiddenAt = 0;
+    return away > STALE_WAKE_MS;
+  }
+  window.addEventListener("online", () => reconnectAllNow(true));
+  window.addEventListener("pageshow", (e) => reconnectAllNow(!!e.persisted || wokeAfterLongAway()));
+  document.addEventListener("visibilitychange", () => {
+    if (document.hidden) { hiddenAt = Date.now(); return; }
+    reconnectAllNow(wokeAfterLongAway());
+  });
 
   /**
    * Lists the agents alive in the server right now — including ones spawned