Skip to content

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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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]);