A desktop coding agent with free access to frontier models.
TypeScript
fix(app): reload task lists after a server restart and confirm empty lists
ogsamrat55edc7eaac0e
diff --git a/apps/app/src/react-app/shell/route-refresh-control.ts b/apps/app/src/react-app/shell/route-refresh-control.tsindex b3dd390b..008b842f 100644--- a/apps/app/src/react-app/shell/route-refresh-control.ts+++ b/apps/app/src/react-app/shell/route-refresh-control.ts@@ -209,6 +209,25 @@ export function planRouteWorkspaceLoads(return [...selectedFirst, ...remaining];}+/**+ * Local workspaces whose session lists must be fetched again because the+ * built-in server came back from a restart: it published a different+ * URL/token, or the route saw a connection gap since the last connection.+ * Their lists were loaded (or failed) against the previous server, so they no+ * longer count as loaded. Remote workspaces live on their own servers and are+ * left alone. The first connection of a window reloads nothing extra.+ */+export function planSessionListReloadAfterReconnect(input: {+ previousConnectionKey: string;+ nextConnectionKey: string;+ connectionGapSeen: boolean;+ workspaces: ReadonlyArray<{ id: string; workspaceType?: string | null }>;+}): string[] {+ if (!input.previousConnectionKey || !input.nextConnectionKey) return [];+ if (input.previousConnectionKey === input.nextConnectionKey && !input.connectionGapSeen) return [];+ return input.workspaces.flatMap((workspace) => workspace.workspaceType === "remote" ? [] : [workspace.id]);+}+export function createRouteRefreshLifecycle(): RouteRefreshLifecycle {let latestGeneration = 0;let inFlightGeneration = 0;diff --git a/apps/app/src/react-app/shell/route-workspaces.ts b/apps/app/src/react-app/shell/route-workspaces.tsindex c25de051..f87e1f58 100644--- a/apps/app/src/react-app/shell/route-workspaces.ts+++ b/apps/app/src/react-app/shell/route-workspaces.ts@@ -561,6 +561,28 @@ export function sessionsAfterListFailure<T extends { id: string }>(input: {return [...current, ...(input.cached ?? []).filter((session) => !currentIds.has(session.id))];}+/**+ * Consecutive empty lists a workspace may return, while the renderer still+ * knows sessions for it, before the empty list replaces them. Each recheck+ * waits one step of the recovery schedule, so the known sessions stay shown+ * for about two minutes of empty answers.+ */+export const SESSION_LIST_EMPTY_RECHECKS = 5;++/**+ * An empty list that loaded fine is confirmed before it replaces sessions the+ * sidebar already knows (listed earlier in this window, or saved from an+ * earlier run). Until then the known sessions stay and the list is asked for+ * again, instead of the group dropping to "No tasks yet".+ */+export function shouldRecheckEmptySessionList(input: {+ fetchedCount: number;+ knownCount: number;+ recheckCount: number;+}): boolean {+ return input.fetchedCount === 0 && input.knownCount > 0 && input.recheckCount < SESSION_LIST_EMPTY_RECHECKS;+}+export function isActiveSessionStatus(status: unknown) {return status === "running" || status === "retry" || status === "busy" || status === "streaming";}diff --git a/apps/app/src/react-app/shell/session-memory.ts b/apps/app/src/react-app/shell/session-memory.tsindex 7fe526f3..a41652b3 100644--- a/apps/app/src/react-app/shell/session-memory.ts+++ b/apps/app/src/react-app/shell/session-memory.ts@@ -262,6 +262,18 @@ export function writeCachedWorkspaceSessions(writeWorkspaceSessionListCache(cache);}+/** Drop one deleted session from a workspace's saved list so it cannot come back from the cache. */+export function removeCachedWorkspaceSession(workspaceId: string | null | undefined, sessionId: string): void {+ const wsId = workspaceId?.trim();+ const id = sessionId.trim();+ if (!wsId || !id) return;+ const cache = readWorkspaceSessionListCache();+ const entry = cache[wsId];+ if (!entry || !entry.sessions.some((session) => session.id === id)) return;+ cache[wsId] = { ...entry, sessions: entry.sessions.filter((session) => session.id !== id) };+ writeWorkspaceSessionListCache(cache);+}+export function forgetWorkspaceMemory(workspaceId: string): void {const wsId = workspaceId?.trim();if (!wsId) return;diff --git a/apps/app/src/react-app/shell/use-workspace-route-state.ts b/apps/app/src/react-app/shell/use-workspace-route-state.tsindex 008c2983..9e0b694a 100644--- a/apps/app/src/react-app/shell/use-workspace-route-state.ts+++ b/apps/app/src/react-app/shell/use-workspace-route-state.ts@@ -55,6 +55,7 @@ import {mapRouteWorkspaceLoads,planRouteConnectionGap,planRouteWorkspaceLoads,+ planSessionListReloadAfterReconnect,routeWorkspaceSelectionCommitter,} from "./route-refresh-control";import {@@ -66,6 +67,7 @@ import {refreshRouteWorkspaceListState,sessionListRecoveryDelayMs,sessionsAfterListFailure,+ shouldRecheckEmptySessionList,stabilizeRouteWorkspaceOrder,type RouteSession,type RouteWorkspace,@@ -75,6 +77,7 @@ import {readActiveWorkspaceId,readCachedWorkspaceSessions,readWorkspaceOrderIds,+ removeCachedWorkspaceSession,writeActiveWorkspaceId,writeCachedWorkspaceSessions,writeWorkspaceOrderIds,@@ -259,6 +262,13 @@ export function useWorkspaceRouteState(input: UseWorkspaceRouteStateInput) {const sessionListRecoveryRef = useRef<Record<string, { timer: number | null; round: number }>>({});// Workspaces whose sidebar list came from a successful load in this window.const listedWorkspaceIdsRef = useRef(new Set<string>());+ // Consecutive empty lists per workspace that were not yet trusted over the+ // sessions the sidebar already knew for it.+ const emptyListRechecksRef = useRef<Record<string, number>>({});+ // The built-in server connection the session lists were last loaded+ // against, and whether a connection gap (server restart) happened since.+ const lastConnectionKeyRef = useRef("");+ const connectionGapSeenRef = useRef(false);const serverActiveWorkspaceIdRef = useRef("");const workspaceSelectionCommitTimerRef = useRef<number | null>(null);const commitStableWorkspaceOrder = useCallback((nextWorkspaces: RouteWorkspace[]) => {@@ -417,6 +427,50 @@ export function useWorkspaceRouteState(input: UseWorkspaceRouteStateInput) {normalizeDirectoryPath(session?.directory ?? "") === workspaceRoot,): fetchedItems;+ if (workspace.workspaceType !== "remote") {+ const currentItems = sessionsByWorkspaceIdRef.current[workspace.id] ?? [];+ const currentIsListed = listedWorkspaceIdsRef.current.has(workspace.id);+ const known = currentIsListed+ ? currentItems+ : sessionsAfterListFailure({+ current: currentItems,+ cached: readCachedWorkspaceSessions(workspace.id) as RouteSession[] | null,+ currentIsListed,+ });+ const recheckCount = emptyListRechecksRef.current[workspace.id] ?? 0;+ if (shouldRecheckEmptySessionList({ fetchedCount: items.length, knownCount: known.length, recheckCount })) {+ // The list answered but holds none of the sessions this+ // workspace is known to have. Keep showing them and ask again+ // on the recovery schedule; only a repeated empty answer+ // replaces them. It does not count as loaded, so a reconnect+ // refresh asks again too.+ emptyListRechecksRef.current[workspace.id] = recheckCount + 1;+ console.warn("[session-route] session list came back empty; keeping known sessions", {+ workspaceId: workspace.id,+ knownSessions: known.length,+ recheck: recheckCount + 1,+ });+ recordInspectorEvent("route.session_list.empty_recheck", {+ workspaceId: workspace.id,+ knownSessions: known.length,+ recheck: recheckCount + 1,+ });+ keepKnownSessionsAfterListFailure(workspace.id);+ loadedWorkspaceIdsRef.current.delete(workspace.id);+ setSessionListErrorsByWorkspaceId((current) => {+ if (!current[workspace.id]) return current;+ const next = { ...current };+ delete next[workspace.id];+ return next;+ });+ setRetryingWorkspaceIds((current) =>+ current.includes(workspace.id) ? current.filter((id) => id !== workspace.id) : current,+ );+ scheduleRecovery(workspace.id);+ return;+ }+ delete emptyListRechecksRef.current[workspace.id];+ }const current = sessionsByWorkspaceIdRef.current;const nextItems = mergeFetchedSessionsWithPending(workspace.id, items, current[workspace.id] ?? []);const next = { ...current, [workspace.id]: nextItems };@@ -613,6 +667,7 @@ export function useWorkspaceRouteState(input: UseWorkspaceRouteStateInput) {// this refresh. Only seed workspaces when the route has none so a// fresh renderer still shows the sidebar under the boot overlay.setConnectionPending(true);+ connectionGapSeenRef.current = true;updateLocalServer({ baseUrl: "", token: "" });setClient(null);setBaseUrl("");@@ -627,6 +682,7 @@ export function useWorkspaceRouteState(input: UseWorkspaceRouteStateInput) {return;}onHostInfo(hostInfo);+ connectionGapSeenRef.current = true;// Keep the workspace endpoint resolver in lockstep with the disconnected state.// Otherwise a previously-cached baseUrl/token would still resolve a// (now invalid) endpoint for any callback that consults the resolver ref.@@ -681,6 +737,27 @@ export function useWorkspaceRouteState(input: UseWorkspaceRouteStateInput) {const nextWorkspaces = commitStableWorkspaceOrder(workspaceListState.workspaces);serverActiveWorkspaceIdRef.current = workspaceListState.activeId ?? "";+ // A restarted built-in server (new URL/token, or a gap since the last+ // connection) answers for every local workspace afresh: lists loaded or+ // failed against the old one are fetched again. Groups that already+ // show sessions reload silently.+ const connectionKey = `${normalizedBaseUrl}\n${resolvedToken}`;+ const reconnectReloadIds = planSessionListReloadAfterReconnect({+ previousConnectionKey: lastConnectionKeyRef.current,+ nextConnectionKey: connectionKey,+ connectionGapSeen: connectionGapSeenRef.current,+ workspaces: nextWorkspaces,+ });+ lastConnectionKeyRef.current = connectionKey;+ connectionGapSeenRef.current = false;+ for (const workspaceId of reconnectReloadIds) loadedWorkspaceIdsRef.current.delete(workspaceId);+ const silentReloadIds = new Set(+ reconnectReloadIds.filter((workspaceId) => (sessionsByWorkspaceIdRef.current[workspaceId]?.length ?? 0) > 0),+ );+ if (reconnectReloadIds.length > 0) {+ recordInspectorEvent("route.session_list.reload_after_reconnect", { workspaces: reconnectReloadIds.length });+ }+// Preserve any sessions we already have cached so switching routes// doesn't erase the sidebar while we refetch.const alreadyLoadedWorkspaceIds = new Set(loadedWorkspaceIdsRef.current);@@ -732,7 +809,7 @@ export function useWorkspaceRouteState(input: UseWorkspaceRouteStateInput) {}return next;});- setRetryingWorkspaceIds(backgroundWorkspaceIds);+ setRetryingWorkspaceIds(backgroundWorkspaceIds.filter((workspaceId) => !silentReloadIds.has(workspaceId)));setLegacySelectedWorkspaceId(nextWorkspaceId);writeActiveWorkspaceId(nextWorkspaceId || null);recordInspectorEvent("route.refresh.complete", {@@ -858,6 +935,7 @@ export function useWorkspaceRouteState(input: UseWorkspaceRouteStateInput) {}, [rememberPendingCreatedSession, selectedWorkspaceId]);const handleRuntimeSessionDeleted = useCallback((sessionId: string) => {if (!selectedWorkspaceId) return;+ removeCachedWorkspaceSession(selectedWorkspaceId, sessionId);setSessionsByWorkspaceId((current) => {const list = current[selectedWorkspaceId] ?? [];const nextList = removeWorkspaceRouteSession(list, sessionId);diff --git a/apps/app/tests/session-read-transport-failure.test.ts b/apps/app/tests/session-read-transport-failure.test.tsindex 117ff4fe..aa367ea0 100644--- a/apps/app/tests/session-read-transport-failure.test.ts+++ b/apps/app/tests/session-read-transport-failure.test.ts@@ -17,7 +17,9 @@ import {readRouteSessionsWithRetry,ROUTE_SESSION_RETRY_DELAYS_MS,sessionListRecoveryDelayMs,+ SESSION_LIST_EMPTY_RECHECKS,sessionsAfterListFailure,+ shouldRecheckEmptySessionList,toSessionGroups,type RouteSession,type RouteSessionListTransport,@@ -26,8 +28,10 @@ import {import {forgetWorkspaceMemory,readCachedWorkspaceSessions,+ removeCachedWorkspaceSession,writeCachedWorkspaceSessions,} from "../src/react-app/shell/session-memory";+import { planSessionListReloadAfterReconnect } from "../src/react-app/shell/route-refresh-control";import { isWorkspaceTaskListUnavailable } from "../src/react-app/domains/session/sidebar/utils";const nativeEndpoint = {@@ -317,6 +321,63 @@ describe("failed session lists in the sidebar", () => {});});+describe("empty session lists and reconnects", () => {+ test("an empty list is asked for again while the workspace is known to have sessions", () => {+ expect(shouldRecheckEmptySessionList({ fetchedCount: 0, knownCount: 3, recheckCount: 0 })).toBe(true);+ expect(shouldRecheckEmptySessionList({ fetchedCount: 0, knownCount: 3, recheckCount: SESSION_LIST_EMPTY_RECHECKS - 1 }))+ .toBe(true);+ });++ test("a repeated empty answer, a non-empty list or an unknown workspace is taken as it is", () => {+ expect(shouldRecheckEmptySessionList({ fetchedCount: 0, knownCount: 3, recheckCount: SESSION_LIST_EMPTY_RECHECKS }))+ .toBe(false);+ expect(shouldRecheckEmptySessionList({ fetchedCount: 1, knownCount: 3, recheckCount: 0 })).toBe(false);+ expect(shouldRecheckEmptySessionList({ fetchedCount: 0, knownCount: 0, recheckCount: 0 })).toBe(false);+ });++ test("the rechecks span about two minutes of the recovery schedule", () => {+ let total = 0;+ for (let round = 0; round < SESSION_LIST_EMPTY_RECHECKS; round += 1) total += sessionListRecoveryDelayMs(round);+ expect(total).toBe(125_000);+ });++ const workspaces = [+ { id: "ws_helm", workspaceType: "local" },+ { id: "ws_taskforge" },+ { id: "ws_remote", workspaceType: "remote" },+ ];++ test("a restarted built-in server reloads every local list", () => {+ expect(planSessionListReloadAfterReconnect({+ previousConnectionKey: "http://127.0.0.1:1\ntoken-a",+ nextConnectionKey: "http://127.0.0.1:2\ntoken-b",+ connectionGapSeen: false,+ workspaces,+ })).toEqual(["ws_helm", "ws_taskforge"]);+ expect(planSessionListReloadAfterReconnect({+ previousConnectionKey: "http://127.0.0.1:1\ntoken-a",+ nextConnectionKey: "http://127.0.0.1:1\ntoken-a",+ connectionGapSeen: true,+ workspaces,+ })).toEqual(["ws_helm", "ws_taskforge"]);+ });++ test("the first connection and a plain refresh reload nothing extra", () => {+ expect(planSessionListReloadAfterReconnect({+ previousConnectionKey: "",+ nextConnectionKey: "http://127.0.0.1:1\ntoken-a",+ connectionGapSeen: true,+ workspaces,+ })).toEqual([]);+ expect(planSessionListReloadAfterReconnect({+ previousConnectionKey: "http://127.0.0.1:1\ntoken-a",+ nextConnectionKey: "http://127.0.0.1:1\ntoken-a",+ connectionGapSeen: false,+ workspaces,+ })).toEqual([]);+ });+});+describe("saved session lists", () => {const originalWindow = globalThis.window;@@ -367,6 +428,15 @@ describe("saved session lists", () => {expect(readCachedWorkspaceSessions("ws_other")).toBeNull();});+ test("lose a session deleted in the app", () => {+ installStorage();+ writeCachedWorkspaceSessions("ws_taskforge", [session, { ...session, id: "ses_2" }]);+ removeCachedWorkspaceSession("ws_taskforge", "ses_1");+ expect(readCachedWorkspaceSessions("ws_taskforge")?.map((item) => item.id)).toEqual(["ses_2"]);+ removeCachedWorkspaceSession("ws_missing", "ses_2");+ expect(readCachedWorkspaceSessions("ws_missing")).toBeNull();+ });+test("are dropped when the workspace is forgotten and tolerate bad storage", () => {const values = installStorage();writeCachedWorkspaceSessions("ws_taskforge", [session]);