fix(client): preserve live activity during hydration (#45975)

Merge session status changes received during activity hydration and ignore superseded reconnect responses. Cover terminal events, starts, deletion, and overlapping connections so idle sessions do not regain stale TUI spinners.
This commit is contained in:
Kit Langton
2026-08-28 12:30:21 -04:00
committed by GitHub
Unverified
parent 936c73b54d
commit e8fa7daed5
2 changed files with 115 additions and 7 deletions
+19 -7
View File
@@ -215,8 +215,10 @@ export function createData(config: CreateDataInput) {
)
const messageIndex = new Map<string, Map<string, number>>()
const sync = createSync()
let activeUpdates: Map<string, DataSessionStatus | undefined> | undefined
function setSessionActive(sessionID: string, status: DataSessionStatus) {
activeUpdates?.set(sessionID, status)
setStore("session", "active", sessionID, status)
}
@@ -473,6 +475,7 @@ export function createData(config: CreateDataInput) {
}
function removeSession(sessionID: string) {
activeUpdates?.set(sessionID, undefined)
store.session.pending[sessionID]?.forEach((item) => outbox.delete(item.id))
messageIndex.delete(sessionID)
sync.invalidate(`session:${sessionID}`)
@@ -504,17 +507,25 @@ export function createData(config: CreateDataInput) {
function handleEvent(event: OpenCodeEvent) {
switch (event.type) {
case "server.connected":
case "server.connected": {
const updates = new Map<string, DataSessionStatus | undefined>()
activeUpdates = updates
void api()
.session.active()
.then((active) => {
setStore(
"session",
"active",
reconcile(Object.fromEntries(Object.keys(active).map((sessionID) => [sessionID, "running" as const]))),
)
if (activeUpdates !== updates) return
// Lifecycle events received during hydration supersede the snapshot.
const snapshot = new Map<string, DataSessionStatus>(Object.keys(active).map((id) => [id, "running"]))
updates.forEach((status, id) => {
if (status === undefined) return snapshot.delete(id)
snapshot.set(id, status)
})
activeUpdates = undefined
setStore("session", "active", reconcile(Object.fromEntries(snapshot)))
})
.catch(() => {
if (activeUpdates === updates) activeUpdates = undefined
})
.catch(() => undefined)
void api()
.location.get({ location: locationQuery(defaultLocation()) })
.then((location) => {
@@ -525,6 +536,7 @@ export function createData(config: CreateDataInput) {
void result.location.vcs.sync().catch((error) => console.error("Failed to preload VCS info", error))
void result.project.sync().catch((error) => console.error("Failed to preload projects", error))
return
}
case "project.updated":
setStore("project", "info", event.data.id, reconcile(event.data))
return
+96
View File
@@ -485,6 +485,102 @@ test("preserves assistant content replacement events across an active message re
}
})
test.each([
"session.execution.succeeded",
"session.execution.failed",
"session.execution.interrupted",
"session.execution.started",
"session.deleted",
] as const)("preserves %s activity when an older snapshot arrives", async (type) => {
const release = Promise.withResolvers<void>()
const requested = Promise.withResolvers<void>()
const setup = activityFixture(async () => {
requested.resolve()
await release.promise
return Response.json({
data: {
...(type === "session.execution.started" ? {} : { ses_refresh: { type: "running" } }),
ses_hydrated: { type: "running" },
},
})
})
try {
if (type !== "session.execution.started") setup.data.session.setStatus("ses_refresh", "running")
setup.emit({ type: "server.connected", data: {} })
await requested.promise
setup.emit({
id: "evt_activity",
created: 2,
type,
durable: { aggregateID: "ses_refresh", seq: 2, version: 1 },
data: { sessionID: "ses_refresh", reason: "user" },
})
expect(setup.data.session.status("ses_refresh")).toBe(type === "session.execution.started" ? "running" : "idle")
release.resolve()
await wait(() => setup.data.session.status("ses_hydrated") === "running")
expect(setup.data.session.status("ses_refresh")).toBe(type === "session.execution.started" ? "running" : "idle")
} finally {
release.resolve()
setup.dispose()
}
})
test("ignores activity snapshots from an older connection", async () => {
const reads: ReturnType<typeof Promise.withResolvers<Response>>[] = []
const setup = activityFixture(() => {
const read = Promise.withResolvers<Response>()
reads.push(read)
return read.promise
})
try {
setup.emit({ type: "server.connected", data: {} })
await wait(() => reads.length === 1)
setup.emit({ type: "server.connected", data: {} })
await wait(() => reads.length === 2)
reads[1]?.resolve(Response.json({ data: { ses_new: { type: "running" } } }))
await wait(() => setup.data.session.status("ses_new") === "running")
reads[0]?.resolve(Response.json({ data: { ses_old: { type: "running" } } }))
await Bun.sleep(20)
expect(setup.data.session.status("ses_new")).toBe("running")
expect(setup.data.session.status("ses_old")).toBe("idle")
} finally {
reads.forEach((read) => read.resolve(Response.json({ data: {} })))
setup.dispose()
}
})
function activityFixture(read: () => Response | Promise<Response>) {
const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
const api = OpenCode.make({
baseUrl: "http://opencode.local",
fetch: async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init)
const path = new URL(request.url).pathname
if (path === "/api/session/active") return read()
if (path === "/api/project") return Response.json([])
if (path === "/api/location") return Response.json({ directory: "/project" })
return Response.json({ location: { directory: "/project" }, data: { branch: "main" } })
},
})
return createRoot((dispose) => ({
data: createData({
api: () => api,
directory: "/project",
event: {
on: () => () => {},
listen(handler) {
listeners.add(handler)
return () => listeners.delete(handler)
},
},
}),
emit: (details: OpenCodeEvent) => listeners.forEach((listener) => listener({ name: details.type, details })),
dispose,
}))
}
async function wait(check: () => boolean) {
const started = Date.now()
while (!check()) {