From 1addb95724f086c34b1cda9ba4f18da568bc2966 Mon Sep 17 00:00:00 2001 From: James Long Date: Tue, 17 Nov 2026 15:36:55 -0500 Subject: [PATCH] fix(app): reload Recent only when a root session is created (#64503) --- packages/app/e2e/regression/tabs.spec.ts | 58 ++++++++++++++++--- .../titlebar/recent-sessions-model.test.ts | 54 ++++++----------- .../shell/titlebar/recent-sessions-model.ts | 25 ++------ .../src/shell/titlebar/recent-sessions.tsx | 18 +----- 4 files changed, 73 insertions(+), 82 deletions(-) diff --git a/packages/app/e2e/regression/tabs.spec.ts b/packages/app/e2e/regression/tabs.spec.ts index 17123ea050c..5966c6750dd 100644 --- a/packages/app/e2e/regression/tabs.spec.ts +++ b/packages/app/e2e/regression/tabs.spec.ts @@ -824,7 +824,7 @@ test("Recent shows the last 7 days, and Show more reveals 30 more rows, fetching await expect(more).toBeHidden() }) -test("Recent keeps the server's order from its last reload, which a run end or window focus triggers", async ({ +test("Recent keeps the server's order through renames, run ends and window focus, and reloads for a new session", async ({ page, }) => { const t = Date.now() - 60_000 @@ -841,6 +841,11 @@ test("Recent keeps the server's order from its last reload, which a run end or w }, }) + let pageOneLoads = 0 + page.on("request", (request) => { + if (/\/api\/session\?.*archived=false/.test(request.url())) pageOneLoads++ + }) + await page.clock.install() await page.goto( `/e2e/utils/windows-menu.html?${new URLSearchParams({ server: SERVER, path: sessionHref(a.id, "sidecar") })}`, ) @@ -874,22 +879,57 @@ test("Recent keeps the server's order from its last reload, which a run end or w await expect(rows.first()).toContainText("Tab B session") await expect(rows.last()).toContainText("Renamed A session") - // The window coming back reloads the list, as the iOS app does when it returns to the foreground. - await page.evaluate(() => window.dispatchEvent(new Event("focus"))) - await expect(rows).toHaveText([/Renamed A session/, /Tab B session/]) - - advance(b.id, { updated: t + 3, idle: t + 3 }) + // A run end and the window coming back leave the order alone; the rename after the run end shows it arrived. + advance(a.id, { updated: t + 3, idle: t + 3 }, "Finished A session") await workspace.push([ { id: "evt_recent_order_run_end", created: t + 3, type: "session.execution.succeeded", location: { directory: workspace.directory }, - durable: { aggregateID: b.id, seq: 1, version: 1 }, - data: { sessionID: b.id }, + durable: { aggregateID: a.id, seq: 2, version: 1 }, + data: { sessionID: a.id }, } satisfies Extract, + { + id: "evt_recent_order_rename_after_run", + created: t + 3, + type: "session.renamed", + location: { directory: workspace.directory }, + durable: { aggregateID: a.id, seq: 3, version: 1 }, + data: { sessionID: a.id, title: "Finished A session" }, + } satisfies Extract, ]) - await expect(rows).toHaveText([/Tab B session/, /Renamed A session/]) + await expect(rows).toHaveText([/Tab B session/, /Finished A session/]) + await page.evaluate(() => { + window.dispatchEvent(new Event("focus")) + document.dispatchEvent(new Event("visibilitychange")) + }) + // Past the reload debounce, so a reload either trigger had queued would have requested page one by now. + await page.clock.runFor(1_000) + await expect(rows).toHaveText([/Tab B session/, /Finished A session/]) + expect(pageOneLoads).toBe(1) + + // A new root session reloads page one, which brings in A's newer server time too. + const created = session({ id: "ses_tab_new", title: "Fresh session", directory: workspace.directory, created: t + 4 }) + workspace.sessions.push(created) + await workspace.push([ + { + id: "evt_recent_order_created", + created: t + 4, + type: "session.created", + location: { directory: workspace.directory }, + durable: { aggregateID: created.id, seq: 1, version: 1 }, + data: { + sessionID: created.id, + projectID: workspace.projectID, + location: { directory: workspace.directory }, + slug: created.slug, + version: created.version, + }, + } satisfies Extract, + ]) + await expect(rows).toHaveText([/Fresh session/, /Finished A session/, /Tab B session/]) + expect(pageOneLoads).toBe(2) }) test("an unfocused window preserves a restored manual unread reminder", async ({ page }) => { diff --git a/packages/app/src/shell/titlebar/recent-sessions-model.test.ts b/packages/app/src/shell/titlebar/recent-sessions-model.test.ts index 6a163f2d850..8ba7396af7d 100644 --- a/packages/app/src/shell/titlebar/recent-sessions-model.test.ts +++ b/packages/app/src/shell/titlebar/recent-sessions-model.test.ts @@ -611,36 +611,13 @@ test("a reload supersedes Show more's page and keeps the older rows already load }) }) -test("run ends reload Recent except a known subagent's or a shutdown, as do new root sessions and archiving", () => { - const sessions = new Map([ - ["ses_root", session("ses_root", 10)], - ["ses_child", session("ses_child", 10, { parentID: "ses_root" })], - ]) - +test("only a new root session reloads Recent", () => { const envelope = (sessionID: string) => ({ id: `evt_${sessionID}`, created: 1, durable: { aggregateID: sessionID, seq: 1, version: 1 as const }, }) - const ended = (sessionID: string) => ({ - ...envelope(sessionID), - type: "session.execution.succeeded" as const, - data: { sessionID }, - }) - - const failed = (sessionID: string) => ({ - ...envelope(sessionID), - type: "session.execution.failed" as const, - data: { sessionID, error: { type: "unknown", message: "failed" } }, - }) - - const interrupted = (sessionID: string, reason: "user" | "shutdown") => ({ - ...envelope(sessionID), - type: "session.execution.interrupted" as const, - data: { sessionID, reason }, - }) - const created = (sessionID: string, parentID?: string) => ({ ...envelope(sessionID), type: "session.created" as const, @@ -648,24 +625,27 @@ test("run ends reload Recent except a known subagent's or a shutdown, as do new }) const cases: [OpenCodeEvent, boolean][] = [ - [ended("ses_root"), true], - [failed("ses_root"), true], - [interrupted("ses_root", "user"), true], - [ended("ses_unknown"), true], - [ended("ses_child"), false], - [failed("ses_child"), false], - [interrupted("ses_child", "user"), false], - [interrupted("ses_root", "shutdown"), false], [created("ses_new"), true], [created("ses_sub", "ses_root"), false], - [{ ...envelope("ses_root"), type: "session.archived", data: { sessionID: "ses_root" } }, true], - [{ ...envelope("ses_root"), type: "session.unarchived", data: { sessionID: "ses_root" } }, true], + [{ ...envelope("ses_root"), type: "session.execution.succeeded", data: { sessionID: "ses_root" } }, false], + [ + { + ...envelope("ses_root"), + type: "session.execution.failed", + data: { sessionID: "ses_root", error: { type: "unknown", message: "failed" } }, + }, + false, + ], + [ + { ...envelope("ses_root"), type: "session.execution.interrupted", data: { sessionID: "ses_root", reason: "user" } }, + false, + ], + [{ ...envelope("ses_root"), type: "session.archived", data: { sessionID: "ses_root" } }, false], + [{ ...envelope("ses_root"), type: "session.unarchived", data: { sessionID: "ses_root" } }, false], [{ ...envelope("ses_root"), type: "session.renamed", data: { sessionID: "ses_root", title: "Renamed" } }, false], ] - expect(cases.map(([value]) => recentReloadsOn(value, (id) => sessions.get(id)))).toEqual( - cases.map(([, expected]) => expected), - ) + expect(cases.map(([value]) => recentReloadsOn(value))).toEqual(cases.map(([, expected]) => expected)) }) test("removing a server clears its page", () => { diff --git a/packages/app/src/shell/titlebar/recent-sessions-model.ts b/packages/app/src/shell/titlebar/recent-sessions-model.ts index c9774f6840c..10f77a89fff 100644 --- a/packages/app/src/shell/titlebar/recent-sessions-model.ts +++ b/packages/app/src/shell/titlebar/recent-sessions-model.ts @@ -136,7 +136,7 @@ type RecentPageBase = { /** * How a load joins the rows already held. `refresh` is a reconnect snapshot, which also re-reads pins it does not - * cover; `reload` is the same snapshot taken while connected (run end, new session, focus, archive). + * cover; `reload` is the same snapshot taken while connected (a new root session). */ type RecentPageKind = "first" | "next" | "refresh" | "reload" @@ -288,26 +288,11 @@ function finishLoading( } /** - * Whether an event changes which root sessions page one holds or their order, so Recent reloads it: a run that ended - * (except a shutdown, which leaves the server's times alone), a new root session, archive and unarchive. A run end - * from a known subagent session does not; an unknown session may be a root, so it does. + * Whether an event makes Recent reload page one: only a new root session. Other changes (run ends, renames, archive) + * reach the rows through the live store, so the order stays put until the next reconnect refresh. */ -export function recentReloadsOn(event: OpenCodeEvent, session: (sessionID: string) => SessionInfo | undefined) { - if (event.type === "session.created") return !event.data.parentID - - if (event.type === "session.archived" || event.type === "session.unarchived") return true - - if (event.type === "session.execution.interrupted" && event.data.reason === "shutdown") return false - - if ( - event.type !== "session.execution.succeeded" && - event.type !== "session.execution.failed" && - event.type !== "session.execution.interrupted" - ) { - return false - } - - return !session(event.data.sessionID)?.parentID +export function recentReloadsOn(event: OpenCodeEvent) { + return event.type === "session.created" && !event.data.parentID } /** One server's page lifecycle. I/O lives in the driver; this only says what to fetch and what the rows become. */ diff --git a/packages/app/src/shell/titlebar/recent-sessions.tsx b/packages/app/src/shell/titlebar/recent-sessions.tsx index 98535720e4d..e6d85bb7cf6 100644 --- a/packages/app/src/shell/titlebar/recent-sessions.tsx +++ b/packages/app/src/shell/titlebar/recent-sessions.tsx @@ -130,8 +130,7 @@ export function RecentSessions() { reloads.delete(server) } - // Order follows each server's last snapshot, so the moments the iOS app reloads its list reload page one here: - // run end, a new root session, archive and unarchive, and the window coming back. Bursts coalesce per server. + // Order follows each server's last snapshot, so only a new root session reloads page one. Bursts coalesce per server. const reload = (item: Connection) => { cancelReload(item.server) reloads.set( @@ -331,19 +330,6 @@ export function RecentSessions() { reloads.forEach((timer) => clearTimeout(timer)) }) - const reloadAll = () => connections().forEach(reload) - - const onVisible = () => { - if (document.visibilityState === "visible") reloadAll() - } - - window.addEventListener("focus", reloadAll) - document.addEventListener("visibilitychange", onVisible) - onCleanup(() => { - window.removeEventListener("focus", reloadAll) - document.removeEventListener("visibilitychange", onVisible) - }) - // The store is local and long-lived; drop duplicates a previous version or a manual edit left behind. createEffect(() => { if (!ready()) return @@ -477,7 +463,7 @@ export function RecentSessions() { connections().forEach((item) => { onCleanup( item.ctx.data.listen(({ details }) => { - if (recentReloadsOn(details, item.ctx.data.session.get)) reload(item) + if (recentReloadsOn(details)) reload(item) }), ) })