fix(session): restore terminal input after page refresh

pallyoung · pallyoung · commit 83dc94e6539c · 2026-04-13T09:30:57.000+08:00
- Fix upsertWorkspaceSnapshot preserving activeTabId when uiState is absent
  (background reattach was overwriting route workspace to first tab)
- Fix auth_status_handler and rpc_handler blocking Tokio async runtime
  by wrapping synchronous DB reads in spawn_blocking
- Fix terminal_channel_input error events passing real workspace_id
  instead of fixed "terminal-channel" string
- Add workspace://input_error subscription with auto-recovery:
  detect stale runtime/binding errors, force reattach, restart if needed
- Add runtimeLiveness check before sending input (require attached state)
- Add regression test for activeTabId preservation across snapshots
diff --git a/apps/server/src/command/http.rs b/apps/server/src/command/http.rs
@@ -1634,20 +1634,29 @@ pub(crate) async fn auth_status_handler(
     ConnectInfo(client_addr): ConnectInfo<std::net::SocketAddr>,
     AxumState(state): AxumState<HttpServerState>,
 ) -> Response {
-    match auth_status(
-        &state.app,
-        &headers,
-        client_addr,
-        request_forces_public_mode(&uri),
-    ) {
-        Ok(data) => json_success(serde_json::to_value(data).unwrap_or(Value::Null)),
-        Err(error) => error.into_response(&RequestContext {
-            ip: client_addr.ip().to_string(),
+    let app = state.app.clone();
+    let headers = headers.clone();
+    let force_public = request_forces_public_mode(&uri);
+    let ip = client_addr.ip().to_string();
+
+    let blocking_result = tokio::task::spawn_blocking(move || {
+        auth_status(&app, &headers, client_addr, force_public)
+    })
+    .await;
+
+    match blocking_result {
+        Ok(Ok(data)) => json_success(serde_json::to_value(data).unwrap_or(Value::Null)),
+        Ok(Err(error)) => error.into_response(&RequestContext {
+            ip,
             user_agent: String::new(),
             is_local_host: client_addr.ip().is_loopback(),
             is_secure_transport: false,
             public_mode: true,
         }),
+        Err(error) => json_error(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("auth_status_task_join_failed: {error}"),
+        ),
     }
 }
 
@@ -1740,6 +1749,13 @@ pub(crate) async fn rpc_handler(
     AxumState(state): AxumState<HttpServerState>,
     Json(payload): Json<Value>,
 ) -> Response {
+    let request_context = RequestContext {
+        ip: client_addr.ip().to_string(),
+        user_agent: String::new(),
+        is_local_host: client_addr.ip().is_loopback(),
+        is_secure_transport: false,
+        public_mode: true,
+    };
     let authorized = match require_session(
         &state.app,
         &headers,
@@ -1748,19 +1764,23 @@ pub(crate) async fn rpc_handler(
     ) {
         Ok(authorized) => authorized,
         Err(error) => {
-            return error.into_response(&RequestContext {
-                ip: client_addr.ip().to_string(),
-                user_agent: String::new(),
-                is_local_host: client_addr.ip().is_loopback(),
-                is_secure_transport: false,
-                public_mode: true,
-            })
+            return error.into_response(&request_context)
         }
     };
 
-    match dispatch_rpc(&state.app, &command, payload, &authorized) {
-        Ok(data) => json_success(data),
-        Err(error) => json_error(error.status, error.error),
+    let app = state.app.clone();
+    let blocking_result = tokio::task::spawn_blocking(move || {
+        dispatch_rpc(&app, &command, payload, &authorized)
+    })
+    .await;
+
+    match blocking_result {
+        Ok(Ok(data)) => json_success(data),
+        Ok(Err(error)) => json_error(error.status, error.error),
+        Err(error) => json_error(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("rpc_task_join_failed: {error}"),
+        ),
     }
 }
 
diff --git a/apps/server/src/ws/server.rs b/apps/server/src/ws/server.rs
@@ -470,7 +470,7 @@ fn handle_ws_client_envelope(
                 }),
             )
             .map_err(|error| {
-                ws_input_error_envelope("terminal-channel", "terminal_channel_input", &error)
+                ws_input_error_envelope(&workspace_id, "terminal_channel_input", &error)
             })?;
             Ok(None)
         }
diff --git a/apps/web/src/command/index.ts b/apps/web/src/command/index.ts
@@ -3,5 +3,6 @@ export { subscribeTerminalEvents } from "./terminal.command";
 export {
   subscribeWorkspaceArtifactsDirty,
   subscribeWorkspaceController,
+  subscribeWorkspaceInputError,
   subscribeWorkspaceRuntimeState,
 } from "./workspace.command";
diff --git a/apps/web/src/command/workspace.command.ts b/apps/web/src/command/workspace.command.ts
@@ -1,5 +1,6 @@
 import type {
   ArtifactsDirtyEvent,
+  WorkspaceInputErrorEvent,
   WorkspaceRuntimeControllerEvent,
   WorkspaceRuntimeStateEvent,
 } from "../types/app";
@@ -13,3 +14,6 @@ export const subscribeWorkspaceController = (handler: (payload: WorkspaceRuntime
 
 export const subscribeWorkspaceRuntimeState = (handler: (payload: WorkspaceRuntimeStateEvent) => void) =>
   subscribeWsEvent<WorkspaceRuntimeStateEvent>("workspace://runtime_state", handler);
+
+export const subscribeWorkspaceInputError = (handler: (payload: WorkspaceInputErrorEvent) => void) =>
+  subscribeWsEvent<WorkspaceInputErrorEvent>("workspace://input_error", handler);
diff --git a/apps/web/src/features/workspace/WorkspaceScreen.tsx b/apps/web/src/features/workspace/WorkspaceScreen.tsx
@@ -103,6 +103,9 @@ import {
 } from "./workspace-view-persistence";
 import { createWorkspaceSessionActions } from "./session-actions";
 import { useWorkspaceArtifactsSync } from "./workspace-sync-hooks";
+import {
+  subscribeWorkspaceInputError,
+} from "../../command";
 import { startWorkspaceLaunch } from "./workspace-launch-actions";
 import {
   browseWorkspaceOverlayDirectory,
@@ -129,9 +132,9 @@ import {
   withWorkspaceFileSearchDropdownStyle
 } from "./file-search-actions";
 import { startSessionRuntime } from "../../services/http/session-runtime.service.ts";
+import { writeTerminal as writeTerminalRequest } from "../../services/http/terminal.service";
 import {
   consumeTerminalChannelInputFragment,
-  sendTerminalChannelInput,
 } from "../../services/terminal-channel/client.ts";
 import { withFallback } from "../../services/http/client";
 import {
@@ -224,6 +227,12 @@ import type {
 
 const withServiceFallback = async <T,>(operation: () => Promise<T>, fallback: T): Promise<T> => withFallback(operation, fallback);
 
+const STALE_SESSION_INPUT_ERRORS = new Set([
+  "terminal_runtime_not_found",
+  "session_runtime_unbound",
+  "terminal_stdin_closed",
+]);
+
 type WorkspaceScreenProps = {
   locale: Locale;
   appSettings: AppSettings;
@@ -700,30 +709,40 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
         }
 
         if (uiState && runtimeSnapshot) {
-          updateState((current) => applyWorkspaceBootstrapResult(
-            current,
-            bootstrap,
-            locale,
-            appSettings,
-            {
-              deviceId,
-              clientId,
-              uiState,
-              runtimeSnapshot,
-            },
-          ));
+          updateState((current) => {
+            const next = applyWorkspaceBootstrapResult(
+              current,
+              bootstrap,
+              locale,
+              appSettings,
+              {
+                deviceId,
+                clientId,
+                uiState,
+                runtimeSnapshot,
+              },
+            );
+            return next.tabs.some((tab) => tab.id === routeWorkspaceId)
+              ? { ...next, activeTabId: routeWorkspaceId }
+              : next;
+          });
         } else {
-          updateState((current) => applyWorkspaceBootstrapResult(
-            current,
-            bootstrap,
-            locale,
-            appSettings,
-            {
-              deviceId,
-              clientId,
-              uiState,
-            },
-          ));
+          updateState((current) => {
+            const next = applyWorkspaceBootstrapResult(
+              current,
+              bootstrap,
+              locale,
+              appSettings,
+              {
+                deviceId,
+                clientId,
+                uiState,
+              },
+            );
+            return next.tabs.some((tab) => tab.id === routeWorkspaceId)
+              ? { ...next, activeTabId: routeWorkspaceId }
+              : next;
+          });
         }
       } else {
         updateState((current) => applyWorkspaceBootstrapResult(
@@ -753,7 +772,12 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
           switchWorkspaceLocally(routeWorkspaceId);
           void withServiceFallback(() => activateWorkspaceRequest(routeWorkspaceId, deviceId, clientId), null).then((uiState) => {
             if (!uiState || cancelled || !isWorkspaceSyncVersionCurrent(routeWorkspaceId, syncVersion)) return;
-            updateState((current) => applyWorkbenchUiState(current, uiState));
+            updateState((current) => {
+              const next = applyWorkbenchUiState(current, uiState);
+              return next.tabs.some((tab) => tab.id === routeWorkspaceId)
+                ? { ...next, activeTabId: routeWorkspaceId }
+                : next;
+            });
           });
         }
         void ensureWorkspaceTerminal(routeWorkspaceId);
@@ -800,15 +824,20 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
           navigate("/workspace", { replace: true });
           return;
         }
-        updateState((current) => applyWorkspaceRuntimeSnapshot(
-          current,
-          runtimeSnapshot,
-          locale,
-          appSettings,
-          deviceId,
-          clientId,
-          uiState,
-        ));
+        updateState((current) => {
+          const next = applyWorkspaceRuntimeSnapshot(
+            current,
+            runtimeSnapshot,
+            locale,
+            appSettings,
+            deviceId,
+            clientId,
+            uiState,
+          );
+          return next.tabs.some((tab) => tab.id === routeWorkspaceId)
+            ? { ...next, activeTabId: routeWorkspaceId }
+            : next;
+        });
         void ensureWorkspaceTerminal(routeWorkspaceId);
       })();
       return () => {
@@ -1821,9 +1850,41 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
     return { tab: nextTab, session: nextSession };
   };
 
+  const isSessionRuntimeWritable = (session: Session | null | undefined) => (
+    Boolean(session?.terminalRuntimeId) && session?.runtimeLiveness === "attached"
+  );
+
+  const refreshWorkspaceRuntimeSnapshot = useCallback(async (workspaceId: string) => {
+    const syncVersion = advanceWorkspaceSyncVersion(workspaceId);
+    const runtimeSnapshot = await attachWorkspaceRuntimeWithRetry(
+      workspaceId,
+      deviceId,
+      clientId,
+      withServiceFallback,
+      {
+        force: true,
+        successReuseMs: 0,
+      },
+    );
+    if (runtimeSnapshot && isWorkspaceSyncVersionCurrent(workspaceId, syncVersion)) {
+      updateState((current) => applyWorkspaceRuntimeSnapshot(
+        current,
+        runtimeSnapshot,
+        locale,
+        appSettings,
+        deviceId,
+        clientId,
+      ));
+    }
+    if (!isWorkspaceSyncVersionCurrent(workspaceId, syncVersion)) return null;
+    return stateRef.current.tabs.find((tab) => tab.id === workspaceId) ?? null;
+  }, [appSettings, clientId, deviceId, locale, updateState]);
+
   const sendAgentRawChunk = async (tab: Tab, session: Session, input: string) => {
     if (!guardWorkspaceMutation("agent_input", tab.id, session.id)) return false;
-    if (!session.terminalRuntimeId) return false;
+    if (!session.terminalRuntimeId || session.runtimeLiveness !== "attached" || !session.terminalId) return false;
+    const numericTerminalId = Number(session.terminalId.replace("term-", ""));
+    if (!Number.isFinite(numericTerminalId)) return false;
     const lastActiveAt = Date.now();
     updateTab(tab.id, (current) => ({
       ...current,
@@ -1832,8 +1893,12 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
       )
     }));
     void syncSessionPatch(tab.id, session.id, { last_active_at: lastActiveAt });
-    sendTerminalChannelInput(tab.id, tab.controller.deviceId, tab.controller.clientId, tab.controller.fencingToken, session.terminalRuntimeId, input);
-    return true;
+    try {
+      await writeTerminalRequest(tab.id, tab.controller, numericTerminalId, input);
+      return true;
+    } catch {
+      return false;
+    }
   };
 
   const onRecoverActiveSession = async () => {
@@ -2373,13 +2438,28 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
     let sessionSnapshot = materialized?.session ?? activeSessionSnapshot;
     if (!tabSnapshot || !sessionSnapshot) return null;
 
-    if (!sessionSnapshot.terminalRuntimeId) {
+    if (!isSessionRuntimeWritable(sessionSnapshot)) {
+      const needsRefresh = Boolean(sessionSnapshot.terminalRuntimeId)
+        || sessionSnapshot.runtimeLiveness === "runtime_missing"
+        || sessionSnapshot.runtimeLiveness === "provider_exited"
+        || !sessionSnapshot.runtimeLiveness;
+      if (needsRefresh) {
+        const refreshedTab = await refreshWorkspaceRuntimeSnapshot(tabSnapshot.id);
+        if (refreshedTab) {
+          tabSnapshot = refreshedTab;
+          sessionSnapshot = refreshedTab.sessions.find((session) => session.id === sessionSnapshot.id) ?? sessionSnapshot;
+        }
+      }
+    }
+
+    if (!isSessionRuntimeWritable(sessionSnapshot)) {
       const started = await startSessionRuntimeInPane(paneId, tabSnapshot, sessionSnapshot);
       if (!started) return null;
       tabSnapshot = started.tab;
       sessionSnapshot = started.session;
     }
 
+    if (!isSessionRuntimeWritable(sessionSnapshot)) return null;
     touchSession(tabSnapshot.id, sessionSnapshot.id);
     return { tab: tabSnapshot, session: sessionSnapshot };
   };
@@ -2450,6 +2530,33 @@ export default function WorkspaceScreen({ locale, appSettings, onOpenSettings }:
     focusWorkspaceAgentPane(paneId);
   };
 
+  useEffect(() => {
+    const unsubscribe = subscribeWorkspaceInputError((payload) => {
+      if (!STALE_SESSION_INPUT_ERRORS.has(payload.error)) return;
+      const tab = stateRef.current.tabs.find((item) => item.id === payload.workspace_id);
+      if (!tab) return;
+      void (async () => {
+        let refreshedTab = await refreshWorkspaceRuntimeSnapshot(tab.id);
+        if (!refreshedTab) {
+          refreshedTab = stateRef.current.tabs.find((item) => item.id === tab.id) ?? null;
+        }
+        if (!refreshedTab || stateRef.current.activeTabId !== refreshedTab.id) return;
+        const paneSessionId = findPaneSessionId(refreshedTab.paneLayout, refreshedTab.activePaneId) ?? refreshedTab.activeSessionId;
+        const session = refreshedTab.sessions.find((item) => item.id === paneSessionId);
+        if (!session || session.unavailableReason || isSessionRuntimeWritable(session)) return;
+        const restarted = await startSessionRuntimeInPane(refreshedTab.activePaneId, refreshedTab, session);
+        if (!restarted) {
+          addToast({
+            id: createId("toast"),
+            text: `Session input recovery failed: ${payload.error}`,
+            sessionId: session.id,
+          });
+        }
+      })();
+    });
+    return () => unsubscribe();
+  }, [addToast, refreshWorkspaceRuntimeSnapshot]);
+
   useEffect(() => {
     return () => {
       for (const timer of agentTerminalInputFlushTimerRef.current.values()) {
diff --git a/apps/web/src/shared/utils/workspace.ts b/apps/web/src/shared/utils/workspace.ts
@@ -563,10 +563,14 @@ export const upsertWorkspaceSnapshot = (
   }
   const tabs = orderTabsByUiState(Array.from(tabMap.values()), openWorkspaceIds);
 
+  const nextActiveWorkspaceId = uiState
+    ? uiState.active_workspace_id
+    : (current.activeTabId || nextTab.id);
+
   const nextState = {
     ...current,
     tabs,
-    activeTabId: resolveActiveWorkspaceId(tabs, uiState?.active_workspace_id ?? nextTab.id),
+    activeTabId: resolveActiveWorkspaceId(tabs, nextActiveWorkspaceId),
     layout: uiState ? workbenchLayoutFromBackend(uiState.layout) : current.layout,
     overlay: {
       ...current.overlay,
diff --git a/apps/web/src/types/app.ts b/apps/web/src/types/app.ts
diff --git a/tests/workbench-state-sync.test.ts b/tests/workbench-state-sync.test.ts

Original file line number	Diff line number	Diff line change
`@@ -470,7 +470,7 @@ fn handle_ws_client_envelope(`
`470`	`470`	`}),`
`471`	`471`	`)`
`472`	`472`	`.map_err(\|error\| {`
`473`		`- ws_input_error_envelope("terminal-channel", "terminal_channel_input", &error)`
	`473`	`+ ws_input_error_envelope(&workspace_id, "terminal_channel_input", &error)`
`474`	`474`	`})?;`
`475`	`475`	`Ok(None)`
`476`	`476`	`}`