@cjhyy/code-shell-web 0.9.40 → 0.9.42

package/dist/hooks/useRemoteSocket.js

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { deviceStore } from "../lib/storage.js";
 import { generateSecret } from "../lib/deviceCredential.js";
 import { parsePairingToken } from "../lib/pairing.js";
+import { ConnectionLiveness, connectionPageHidden } from "../lib/connectionLiveness.js";
 const RECONNECT_BASE_MS = 800;
 const RECONNECT_MAX_MS = 8000;
 export function useRemoteSocket(handlers) {
@@ -12,6 +13,7 @@ export function useRemoteSocket(handlers) {
     const connectionGenerationRef = useRef(0);
     const retryRef = useRef(0);
     const closedByUs = useRef(false);
+    const stopSocket = useRef(undefined);
     const statusRef = useRef(status);
     statusRef.current = status;
     // Keep latest handlers without retriggering the connect effect.
@@ -36,7 +38,7 @@ export function useRemoteSocket(handlers) {
     const logout = useCallback(() => {
         deviceStore.clearId();
         closedByUs.current = true;
-        wsRef.current?.close();
+        stopSocket.current?.();
         // Drop the pairing token from the URL and reload into the unpaired state.
         window.history.replaceState(null, "", window.location.pathname);
         statusRef.current = "unpaired";
@@ -45,11 +47,11 @@ export function useRemoteSocket(handlers) {
     useEffect(() => {
         closedByUs.current = false;
         let retryTimer;
-        let openWatchdog;
+        let health;
         /** Schedule a reconnect with jittered exponential backoff. Cancels any
          *  pending timer so a manual/event-driven reconnect can pre-empt it. */
         const scheduleReconnect = () => {
-            if (closedByUs.current)
+            if (closedByUs.current || connectionPageHidden())
                 return;
             if (retryTimer)
                 clearTimeout(retryTimer);
@@ -60,54 +62,60 @@ export function useRemoteSocket(handlers) {
             retryRef.current += 1;
             retryTimer = setTimeout(connect, delay);
         };
+        const retire = (ws, retry = true) => {
+            if (wsRef.current !== ws)
+                return;
+            wsRef.current = null;
+            health?.stop();
+            health = undefined;
+            ws.onopen = ws.onmessage = ws.onclose = ws.onerror = null;
+            try {
+                ws.close();
+            }
+            catch {
+                /* already unusable */
+            }
+            if (!closedByUs.current) {
+                statusRef.current = "offline";
+                setStatus("offline");
+                if (retry)
+                    scheduleReconnect();
+            }
+        };
         /** Force an immediate reconnect (network back / tab visible again). */
         const reconnectNow = () => {
             if (closedByUs.current)
                 return;
             const ws = wsRef.current;
-            // If we already have a live, open socket, leave it alone.
-            if (ws && ws.readyState === WebSocket.OPEN)
+            if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
+                health?.resume();
                 return;
+            }
             if (retryTimer)
                 clearTimeout(retryTimer);
             retryRef.current = 0;
-            // Drop a half-open/connecting socket before redialing.
-            if (ws) {
-                ws.onclose = null;
-                ws.onerror = null;
-                try {
-                    ws.close();
-                }
-                catch {
-                    /* ignore */
-                }
-                wsRef.current = null;
-            }
+            if (ws)
+                retire(ws, false);
             connect();
         };
         const connect = () => {
+            if (closedByUs.current)
+                return;
+            retryTimer = undefined;
             const wsUrl = window.location.origin.replace(/^http/, "ws") + "/ws";
             const ws = new WebSocket(wsUrl);
             wsRef.current = ws;
             statusRef.current = "connecting";
             setStatus("connecting");
-            // Watchdog: a socket stuck in CONNECTING (dead network, captive portal)
-            // never fires onclose. Force-close after 10s so backoff kicks in.
-            if (openWatchdog)
-                clearTimeout(openWatchdog);
-            openWatchdog = setTimeout(() => {
-                if (ws.readyState === WebSocket.CONNECTING) {
-                    try {
-                        ws.close();
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-            }, 10_000);
+            const socketHealth = new ConnectionLiveness(
+            // Existing read-only protocol, answered by the Host's disk index. Never
+            // manufacture a ping, repeat a chat send or retry an approval decision.
+            () => ws.send(JSON.stringify({ type: "session.list" })), () => retire(ws), connectionPageHidden());
+            health = socketHealth;
             ws.onopen = () => {
-                if (openWatchdog)
-                    clearTimeout(openWatchdog);
+                if (wsRef.current !== ws || closedByUs.current)
+                    return;
+                socketHealth.authenticating();
                 retryRef.current = 0;
                 const pairingToken = parsePairingToken(window.location.search);
                 const secret = deviceStore.getOrCreateSecret(() => generateSecret());
@@ -133,12 +141,13 @@ export function useRemoteSocket(handlers) {
                     }));
                 }
                 else {
+                    socketHealth.stop();
                     statusRef.current = "unpaired";
                     setStatus("unpaired");
                 }
             };
             ws.onmessage = (e) => {
-                if (wsRef.current !== ws)
+                if (wsRef.current !== ws || closedByUs.current)
                     return;
                 let msg;
                 try {
@@ -147,7 +156,20 @@ export function useRemoteSocket(handlers) {
                 catch {
                     return;
                 }
+                if (!msg || typeof msg !== "object" || Array.isArray(msg))
+                    return;
                 const obj = msg;
+                // This legacy protocol has no request id on session.list. Only its
+                // concrete response (or an uncorrelated control rejection) can answer
+                // a health check; stream/approval notifications cannot clear a deadline.
+                if (obj.type === "session.list.ok" ||
+                    (obj.type === "error" &&
+                        !obj.approvalId &&
+                        !obj.clientMessageId &&
+                        !obj.clientRequestId &&
+                        !obj.sessionId &&
+                        !obj.roomId))
+                    socketHealth.received();
                 // Auth/pair lifecycle is handled here so the hook owns the state machine.
                 if (obj.type === "pair.ok") {
                     const device = obj.device;
@@ -160,6 +182,7 @@ export function useRemoteSocket(handlers) {
                     return;
                 }
                 if (obj.type === "auth.ok") {
+                    socketHealth.connected();
                     const device = obj.device;
                     if (device?.name)
                         setDeviceName(device.name);
@@ -172,11 +195,14 @@ export function useRemoteSocket(handlers) {
                     return;
                 }
                 if (obj.type === "auth.failed" || obj.type === "pair.failed") {
+                    closedByUs.current = true;
                     if (obj.type === "auth.failed")
                         deviceStore.clearId();
                     statusRef.current = "unpaired";
                     setStatus("unpaired");
                     handlersRef.current.onServerEvent?.(msg);
+                    retire(ws, false);
+                    stopSocket.current?.();
                     return;
                 }
                 // Typed server events carry a string `type`; raw worker lines carry a
@@ -188,34 +214,32 @@ export function useRemoteSocket(handlers) {
                     handlersRef.current.onRawLine?.(msg);
                 }
             };
-            ws.onclose = () => {
-                if (openWatchdog)
-                    clearTimeout(openWatchdog);
+            ws.onclose = (event) => {
                 if (wsRef.current !== ws)
                     return;
-                wsRef.current = null;
+                if (event?.code === 4401 || event?.code === 4403) {
+                    closedByUs.current = true;
+                    deviceStore.clearId();
+                    statusRef.current = "unpaired";
+                    setStatus("unpaired");
+                }
+                retire(ws);
                 if (closedByUs.current)
-                    return;
-                statusRef.current = "offline";
-                setStatus("offline");
-                scheduleReconnect();
+                    stopSocket.current?.();
             };
             ws.onerror = () => {
-                // onclose handles retry; closing here makes the failure deterministic.
-                try {
-                    ws.close();
-                }
-                catch {
-                    /* ignore */
-                }
+                retire(ws);
             };
         };
         // Reconnect proactively when the OS reports the network is back or the tab
         // becomes visible again (phones suspend the socket in the background — the
         // close event often doesn't fire until the user returns).
         const resyncOrReconnect = (reason) => {
+            if (closedByUs.current || connectionPageHidden())
+                return;
             const ws = wsRef.current;
             if (ws && ws.readyState === WebSocket.OPEN && statusRef.current === "online") {
+                health?.resume();
                 handlersRef.current.onResyncNeeded?.(reason);
                 return;
             }
@@ -225,6 +249,11 @@ export function useRemoteSocket(handlers) {
         const onVisible = () => {
             if (document.visibilityState === "visible")
                 resyncOrReconnect("visible");
+            else {
+                health?.pause();
+                if (retryTimer)
+                    clearTimeout(retryTimer);
+            }
         };
         const onFocus = () => resyncOrReconnect("focus");
         const onPageShow = () => resyncOrReconnect("pageshow");
@@ -233,34 +262,25 @@ export function useRemoteSocket(handlers) {
         window.addEventListener("pageshow", onPageShow);
         document.addEventListener("visibilitychange", onVisible);
         connect();
-        return () => {
+        const stop = () => {
             closedByUs.current = true;
             if (retryTimer)
                 clearTimeout(retryTimer);
-            if (openWatchdog)
-                clearTimeout(openWatchdog);
+            health?.stop();
+            health = undefined;
             window.removeEventListener("online", onOnline);
             window.removeEventListener("focus", onFocus);
             window.removeEventListener("pageshow", onPageShow);
             document.removeEventListener("visibilitychange", onVisible);
-            // Null ALL handlers before close: onmessage/onopen call setState without the
-            // closedByUs guard the close/error paths have, so an event landing in the
-            // close window would setState on the unmounted component. (Mirrors the
-            // reconnectNow teardown above, which already nulls handlers.)
             const ws = wsRef.current;
-            if (ws) {
-                ws.onmessage = null;
-                ws.onopen = null;
-                ws.onclose = null;
-                ws.onerror = null;
-                try {
-                    ws.close();
-                }
-                catch {
-                    /* ignore */
-                }
-                wsRef.current = null;
-            }
+            if (ws)
+                retire(ws, false);
+        };
+        stopSocket.current = stop;
+        return () => {
+            stop();
+            if (stopSocket.current === stop)
+                stopSocket.current = undefined;
         };
     }, []);
     return { status, deviceName, connectionGeneration, send, logout };

package/dist/lib/connectionLiveness.d.ts

@@ -0,0 +1,28 @@
+/** One instance per socket. Retired sockets and queued background timers cannot
+ * change the next connection's state. Any explicit response, including a denied
+ * read-only probe, proves transport liveness; it does not grant permission. */
+export declare class ConnectionLiveness {
+    private readonly sendProbe;
+    private readonly expire;
+    private timer?;
+    private revision;
+    private stopped;
+    private paused;
+    private ready;
+    private opened;
+    private probing;
+    constructor(sendProbe: () => void, expire: () => void, paused?: boolean);
+    connected(): void;
+    /** Native pairing/authentication gets its own bounded phase after open. */
+    authenticating(): void;
+    /** Return whether this frame answered the current single-flight health check. */
+    received(): boolean;
+    check(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private clear;
+    private arm;
+    private fail;
+}
+export declare function connectionPageHidden(): boolean;

package/dist/lib/connectionLiveness.js

@@ -0,0 +1,105 @@
+/** Connection health only: a long-running task is never given a deadline here. */
+const CONNECT_MS = 10_000;
+const CHECK_MS = 15_000;
+const PROBE_MS = 5_000;
+/** One instance per socket. Retired sockets and queued background timers cannot
+ * change the next connection's state. Any explicit response, including a denied
+ * read-only probe, proves transport liveness; it does not grant permission. */
+export class ConnectionLiveness {
+    sendProbe;
+    expire;
+    timer;
+    revision = 0;
+    stopped = false;
+    paused;
+    ready = false;
+    opened = false;
+    probing = false;
+    constructor(sendProbe, expire, paused = false) {
+        this.sendProbe = sendProbe;
+        this.expire = expire;
+        this.paused = paused;
+        this.arm(CONNECT_MS, () => this.fail());
+    }
+    connected() {
+        if (this.stopped)
+            return;
+        this.ready = true;
+        this.arm(CHECK_MS, () => this.check());
+    }
+    /** Native pairing/authentication gets its own bounded phase after open. */
+    authenticating() {
+        if (this.stopped || this.ready || this.opened)
+            return;
+        this.opened = true;
+        this.arm(CONNECT_MS, () => this.fail());
+    }
+    /** Return whether this frame answered the current single-flight health check. */
+    received() {
+        if (this.stopped || this.paused || !this.probing)
+            return false;
+        this.probing = false;
+        this.arm(CHECK_MS, () => this.check());
+        return true;
+    }
+    check() {
+        if (this.stopped || this.paused || this.probing || !this.ready)
+            return;
+        this.probing = true;
+        // Arm before send: a synchronous response must be able to clear this timer.
+        this.arm(PROBE_MS, () => this.fail());
+        try {
+            this.sendProbe();
+        }
+        catch {
+            this.fail();
+        }
+    }
+    pause() {
+        this.paused = true;
+        this.probing = false;
+        this.clear();
+    }
+    resume() {
+        if (this.stopped)
+            return;
+        const wasPaused = this.paused;
+        this.paused = false;
+        if (this.ready)
+            this.check();
+        else if (wasPaused)
+            this.arm(CONNECT_MS, () => this.fail());
+    }
+    stop() {
+        this.stopped = true;
+        this.probing = false;
+        this.clear();
+    }
+    clear() {
+        this.revision++;
+        if (this.timer !== undefined)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+    arm(ms, run) {
+        this.clear();
+        if (this.stopped || this.paused)
+            return;
+        const revision = this.revision;
+        this.timer = setTimeout(() => {
+            if (this.stopped || this.paused || revision !== this.revision)
+                return;
+            this.timer = undefined;
+            run();
+        }, ms);
+    }
+    fail() {
+        if (this.stopped)
+            return;
+        this.stop();
+        this.expire();
+    }
+}
+export function connectionPageHidden() {
+    return typeof document !== "undefined" && document.visibilityState === "hidden";
+}

package/dist/lib/streamReducer.js

@@ -55,6 +55,7 @@ function runStateForReason(reason) {
         case "model_error":
         case "image_error":
         case "replay_incomplete":
+        case "batch_incomplete":
         case "unverified_write":
             return "error";
         // "completed", "max_turns", "goal_budget_exhausted", "stop_hook_prevented",