@cjhyy/code-shell-web 0.9.18 → 0.9.20

package/dist/hooks/useRemoteApp.d.ts

@@ -19,6 +19,8 @@ export interface PendingApproval {
     options?: string[];
     /** When true, the user must pick an option (no free text). */
     optionsOnly?: boolean;
+    /** A nonblocking question remains answerable after the run ends. */
+    asynchronous?: boolean;
     /** True for path-scoped tools (Read/Edit/Write/…) → show file/dir scope. */
     pathScoped: boolean;
 }

package/dist/hooks/useRemoteApp.js

@@ -72,6 +72,7 @@ export function useRemoteApp(options = {}) {
     const [approvals, setApprovals] = useState([]);
     const approvalsRef = useRef(approvals);
     approvalsRef.current = approvals;
+    const submittingAsyncApprovalsRef = useRef(new Set());
     // The SELECTED project (one-true-source for "what am I looking at"), distinct
     // from activeSessionCwd which is derived from the bound session. Drives session
     // list filtering AND ccRoom.listSessions.
@@ -219,6 +220,7 @@ export function useRemoteApp(options = {}) {
         setLoading((prev) => (prev[key] === value ? prev : { ...prev, [key]: value }));
     }, []);
     const clearApproval = useCallback((requestId) => {
+        submittingAsyncApprovalsRef.current.delete(requestId);
         approvalsRef.current = removeResolvedApproval(approvalsRef.current, requestId);
         setApprovals((prev) => removeResolvedApproval(prev, requestId));
     }, []);
@@ -240,8 +242,10 @@ export function useRemoteApp(options = {}) {
             const type = event?.type;
             return type === "turn_complete" || type === "error";
         })) {
-            approvalsRef.current = [];
-            setApprovals([]);
+            // Asynchronous questions outlive the current run. Only a resolution
+            // notification (or a new worker epoch) makes their answer stale.
+            approvalsRef.current = approvalsRef.current.filter((approval) => approval.asynchronous);
+            setApprovals((prev) => prev.filter((approval) => approval.asynchronous));
         }
     }, []);
     const appendSessionEvents = useCallback((sessionId, events) => {
@@ -558,6 +562,9 @@ export function useRemoteApp(options = {}) {
                 setNotice(event.message || t("mobile.notice.roomError"));
                 break;
             case "error":
+                if (event.approvalId) {
+                    submittingAsyncApprovalsRef.current.delete(event.approvalId);
+                }
                 if (event.clientMessageId) {
                     settleMessageAck(event.clientMessageId, new Error(event.message));
                 }
@@ -773,6 +780,7 @@ export function useRemoteApp(options = {}) {
                     risk,
                     options: askOptions?.options,
                     optionsOnly: askOptions?.optionsOnly,
+                    asynchronous: rq.toolName === "__ask_user__" && rq.args?.asynchronous === true,
                     pathScoped: PATH_SCOPED.has(rq.toolName ?? ""),
                 });
             }
@@ -811,18 +819,9 @@ export function useRemoteApp(options = {}) {
                 return;
             }
             dispatchChat({ kind: "raw", raw });
-            // A turn ending (or erroring) resolves any pending approval for this
-            // session — clear stale cards so a request the user already handled (or
-            // that the desktop answered) doesn't linger ("点了还存在").
-            const ev = params.event?.type;
-            if (ev === "turn_complete" || ev === "error") {
-                // We only ever hold bound-session approvals, so the turn ending clears
-                // them all (the request can no longer be answered).
-                approvalsRef.current = [];
-                setApprovals([]);
-            }
+            clearApprovalsIfTerminal([params.event]);
         }
-    }, [addApproval, clearApproval, sessionCwdById]);
+    }, [addApproval, clearApproval, clearApprovalsIfTerminal, sessionCwdById]);
     const requestActiveResync = useCallback(() => {
         const roomId = activeRoomIdRef.current;
         if (roomId) {
@@ -877,6 +876,7 @@ export function useRemoteApp(options = {}) {
     useEffect(() => {
         if (socket.status === "online")
             return;
+        submittingAsyncApprovalsRef.current.clear();
         const error = new Error("Remote connection was lost");
         for (const waiter of uploadWaitersRef.current.values()) {
             clearTimeout(waiter.timer);
@@ -1115,7 +1115,9 @@ export function useRemoteApp(options = {}) {
         // card unmounts). Sending again would violate the approve-once invariant.
         if (!a)
             return;
-        socket.send({
+        if (a.asynchronous && submittingAsyncApprovalsRef.current.has(requestId))
+            return;
+        const sent = socket.send({
             type: "approval.respond",
             approvalId: requestId,
             decision,
@@ -1125,6 +1127,14 @@ export function useRemoteApp(options = {}) {
             scope: opts?.scope,
             pathScope: opts?.pathScope,
         });
+        if (!sent)
+            return;
+        if (a.asynchronous) {
+            // Keep the card until the worker accepts this late answer. A rejected
+            // delivery unlocks it for retry without losing the user's question.
+            submittingAsyncApprovalsRef.current.add(requestId);
+            return;
+        }
         // Update the ref synchronously too so a second tap in the same tick (before
         // the async setApprovals commits) sees it gone and no-ops above.
         approvalsRef.current = approvalsRef.current.filter((p) => p.requestId !== requestId);

package/dist/lib/streamReducer.js

@@ -53,6 +53,7 @@ function runStateForReason(reason) {
         case "prompt_too_long":
         case "model_error":
         case "image_error":
+        case "replay_incomplete":
             return "error";
         // "completed", "max_turns", "goal_budget_exhausted", "stop_hook_prevented",
         // "hook_stopped", and any future/unknown terminal reason: a normal stop.