fix(app): reload Recent only when a root session is created (#64503)

This commit is contained in:
James Long
2026-11-17 15:36:55 -05:00
committed by GitHub
Unverified
parent b9029e64a0
commit 1addb95724
4 changed files with 73 additions and 82 deletions
+49 -9
View File
@@ -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<OpenCodeEvent, { type: "session.execution.succeeded" }>,
{
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<OpenCodeEvent, { type: "session.renamed" }>,
])
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<OpenCodeEvent, { type: "session.created" }>,
])
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 }) => {
@@ -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", () => {
@@ -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. */
@@ -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)
}),
)
})