From 127b9e882249e4e8e159e8969623c4aed617efe2 Mon Sep 17 00:00:00 2001 From: tiisetso Date: Tue, 20 Oct 2026 09:02:34 +0200 Subject: [PATCH] fix(app): release closed session transcripts The client data cache kept every session's transcript and pending rows after its tab closed, and late reads, older pages and later events could bring evicted rows back. createSessionRetention, wired in createServerController, evicts a session family once no open tab, session route, running work or attention request has kept it for one second with no navigation pending. Rows that return after eviction are released at the next deadline. Eviction keeps unacknowledged submissions and sessions still being created, so the policy retries until they settle. Adds data.session.cached, which lists sessions holding transcript or pending rows and notifies only when that set changes. Refs #77 --- packages/app/e2e/regression/tabs.spec.ts | 36 ++ packages/app/src/runtime/server/runtime.tsx | 41 +- .../src/runtime/server/session-retention.ts | 62 +++ .../test-browser/session-retention.test.ts | 362 ++++++++++++++++++ packages/client/src/solid/data.ts | 6 + 5 files changed, 506 insertions(+), 1 deletion(-) create mode 100644 packages/app/src/runtime/server/session-retention.ts create mode 100644 packages/app/test-browser/session-retention.test.ts diff --git a/packages/app/e2e/regression/tabs.spec.ts b/packages/app/e2e/regression/tabs.spec.ts index f72b093331..d6fad7ddaa 100644 --- a/packages/app/e2e/regression/tabs.spec.ts +++ b/packages/app/e2e/regression/tabs.spec.ts @@ -692,6 +692,42 @@ test("inactive tabs load attention and inbox, but read the transcript only on se expect(errors).toEqual([]) }) +test("closing a tab releases its transcript, and reopening it reads the transcript again", async ({ page }) => { + const reads: string[] = [] + const errors: string[] = [] + page.on("pageerror", (error) => errors.push(error.message)) + page.on("request", (request) => { + if (request.method() === "GET") reads.push(new URL(request.url()).pathname) + }) + const history = (id: string) => + page.locator(`[data-timeline-row="UserMessage"][data-message-id="msg_${id}_history"]`) + await openSession(page, { + name: "TabRetention", + sessions: [a, b], + pageMessages: (id) => ({ + items: [{ id: `msg_${id}_history`, type: "user", text: `History of ${id}`, time: { created: 1 } }], + }), + }) + await expect(history(a.id)).toContainText(`History of ${a.id}`) + + await page.locator(`[data-titlebar-tab-link][href="${sessionHref(b.id)}"]`).click() + await expect(history(b.id)).toContainText(`History of ${b.id}`) + await page.keyboard.press("Control+w") + await expect(page.locator(`[data-titlebar-tab-slot]:has(a[href="${sessionHref(b.id)}"])`)).toHaveCount(0) + await expectSessionTitle(page, a.title) + + // A release has no visible signal, so wait past the retention delay. The open tab keeps its transcript. + await page.waitForTimeout(2_000) + await expect(history(a.id)).toContainText(`History of ${a.id}`) + + await page.keyboard.press("Control+Shift+T") + await expectSessionTitle(page, b.title) + await expect(history(b.id)).toContainText(`History of ${b.id}`) + await expect.poll(() => reads.filter((path) => path === `/api/session/${b.id}/message`).length).toBe(2) + expect(reads.filter((path) => path === `/api/session/${a.id}/message`)).toHaveLength(1) + expect(errors).toEqual([]) +}) + test("five loaded workspace tabs stay rendered and reactive through repeated switches", async ({ page }) => { await page.setViewportSize({ width: 1440, height: 900 }) diff --git a/packages/app/src/runtime/server/runtime.tsx b/packages/app/src/runtime/server/runtime.tsx index 13e686e8c3..d4b30b549e 100644 --- a/packages/app/src/runtime/server/runtime.tsx +++ b/packages/app/src/runtime/server/runtime.tsx @@ -1,6 +1,20 @@ import { createSimpleContext } from "@opencode/ui/context" -import { Accessor, batch, createEffect, createMemo, createResource, createRoot, getOwner, untrack } from "solid-js" +import { + Accessor, + batch, + createEffect, + createMemo, + createResource, + createRoot, + getOwner, + untrack, + useTransition, +} from "solid-js" +import { useLocation } from "@solidjs/router" import { createServerProjects, RECENTLY_CLOSED_DISPLAY_LIMIT, ServerConnection, useServers } from "./registry" +import { createSessionRetention } from "./session-retention" +import { sessionHref } from "@/shell/routes/session" +import { useTabs } from "@/shell/tabs/tabs" import { pathKey } from "@/workspaces/path-key" import { useServerHealth } from "@/runtime/server/health" import { createServerSdkContext } from "./client" @@ -198,6 +212,31 @@ function createServerController( createPermissionAutoApprover({ sdk, data }) const notification = createServerNotificationState({ sdk, data, key: connKey, coordinator: notificationCoordinator }) + const tabs = useTabs() + const location = useLocation() + // Parsed here because the shared route parser throws on routes it does not recognise. + const routes = sessionHref(connKey, "") + createSessionRetention({ + session: data.session, + ready: tabs.ready, + visible: () => { + const routed = location.pathname.startsWith(routes) + ? location.pathname.slice(routes.length).split("/")[0] + : undefined + return [ + ...(routed ? [routed] : []), + ...tabs.store.flatMap((tab) => + tab.type === "session" && tab.server === connKey + ? [tab.sessionId, tab.routeSessionId, tab.routeParentId].flatMap((id) => (id ? [id] : [])) + : [], + ), + ] + }, + navigating: useTransition()[0], + // Covers an open path whose transcript read lands before the transition adding its tab commits. + delay: 1_000, + }) + function enrich(project: { worktree: string; expanded: boolean }) { const [childStore] = sync.child(project.worktree, { bootstrap: false }) const projectID = childStore.project diff --git a/packages/app/src/runtime/server/session-retention.ts b/packages/app/src/runtime/server/session-retention.ts new file mode 100644 index 0000000000..3169876e86 --- /dev/null +++ b/packages/app/src/runtime/server/session-retention.ts @@ -0,0 +1,62 @@ +import { createEffect, onCleanup, type Accessor } from "solid-js" +import type { Data } from "@opencode/client/solid" + +type Session = Pick + +/** + * Releases the cached transcripts of session families that no open tab, session route, running work or attention + * request keeps. A family is released once it has stayed unkept for `delay` with no transition pending, since an open + * path can read a transcript before the transition that adds its tab or route commits. Late reads and events that + * bring rows back to a released family start a new delay, so they cannot keep it cached. + */ +export function createSessionRetention(input: { + session: Session + /** Persisted tabs have loaded. */ + ready: Accessor + /** Sessions shown by open tabs or the current route. */ + visible: Accessor + navigating: Accessor + delay: number +}) { + const timers = new Map>() + onCleanup(() => timers.forEach((timer) => clearTimeout(timer))) + const unkept = () => new Set(input.ready() && !input.navigating() ? unkeptRoots(input.session, input.visible()) : []) + + const release = (root: string) => { + timers.set( + root, + setTimeout(() => { + timers.delete(root) + input.session.evict(root) + // Eviction keeps unacknowledged submissions and sessions still being created, and settling them need not + // change the cached set this policy tracks. Retry while the family stays unkept and cached. + if (!timers.has(root) && unkept().has(root)) release(root) + }, input.delay), + ) + } + + createEffect(() => { + const roots = unkept() + timers.forEach((timer, root) => { + if (roots.has(root)) return + clearTimeout(timer) + timers.delete(root) + }) + // A family that keeps receiving rows still releases at its first deadline. + roots.forEach((root) => { + if (!timers.has(root)) release(root) + }) + }) +} + +function unkeptRoots(session: Session, visible: readonly string[]) { + const kept = new Set( + [...visible, ...session.active(), ...session.permission.sessions(), ...session.form.sessions()].map((id) => + session.root(id), + ), + ) + return session + .cached() + .map((id) => session.root(id)) + .filter((root) => !kept.has(root)) +} diff --git a/packages/app/test-browser/session-retention.test.ts b/packages/app/test-browser/session-retention.test.ts new file mode 100644 index 0000000000..92dbf5fd04 --- /dev/null +++ b/packages/app/test-browser/session-retention.test.ts @@ -0,0 +1,362 @@ +import { expect, test } from "bun:test" +import { OpenCode, type OpenCodeEvent, type SessionInfo } from "@opencode/client/promise" +import { createData, type CreateDataInput } from "@opencode/client/solid" +import { createRoot, createSignal } from "solid-js" +import { unwrap } from "solid-js/store" +import { createSessionRetention } from "@/runtime/server/session-retention" + +// Runs under the browser build: the server build of Solid never runs the policy's effect. +const delay = 10 + +test("releases unkept families after the delay and keeps visible, running and attention families", async () => { + const ids = ["ses_open", "ses_open_child", "ses_closed", "ses_closed_child", "ses_running", "ses_asked"] + const scope = setup({ visible: ["ses_open_child"] }) + try { + scope.remember("ses_open") + scope.remember("ses_open_child", "ses_open") + scope.remember("ses_closed") + scope.remember("ses_closed_child", "ses_closed") + scope.remember("ses_running") + scope.remember("ses_asked") + scope.data.session.setStatus("ses_running", "running") + scope.emit(permissionAsked("ses_asked")) + for (const id of ids) await scope.data.session.message.sync(id) + await settle() + + expect(ids.filter(scope.cached)).toEqual(["ses_open", "ses_open_child", "ses_running", "ses_asked"]) + // Eviction drops only transcript rows. + expect(scope.data.session.get("ses_closed_child")?.parentID).toBe("ses_closed") + expect(scope.data.session.family("ses_closed")).toEqual(["ses_closed", "ses_closed_child"]) + expect(scope.data.session.status("ses_running")).toBe("running") + expect(scope.data.session.permission.list("ses_asked")?.[0]?.id).toBe("per_ses_asked") + + scope.data.session.setStatus("ses_running", "idle") + await settle() + expect(ids.filter(scope.cached)).toEqual(["ses_open", "ses_open_child", "ses_asked"]) + } finally { + scope.dispose() + } +}) + +test("closing a child tab keeps its still-visible parent and sibling family", async () => { + const ids = ["ses_parent", "ses_child", "ses_sibling"] + const scope = setup({ visible: ["ses_parent", "ses_child"] }) + try { + scope.remember("ses_parent") + scope.remember("ses_child", "ses_parent") + scope.remember("ses_sibling", "ses_parent") + for (const id of ids) await scope.data.session.message.sync(id) + + scope.setVisible(["ses_parent"]) + await settle() + expect(ids.filter(scope.cached)).toEqual(ids) + + scope.setVisible([]) + await settle() + expect(ids.filter(scope.cached)).toEqual([]) + } finally { + scope.dispose() + } +}) + +test("waits for persisted tabs, and keeps a read that lands before its tab or navigation commits", async () => { + const scope = setup({ ready: false }) + try { + scope.remember("ses_opening") + await scope.data.session.message.sync("ses_opening") + await settle() + expect(scope.cached("ses_opening")).toBe(true) + + // Home reads the transcript before its transition adds the tab. + scope.setReady(true) + scope.setVisible(["ses_opening"]) + await settle() + expect(scope.cached("ses_opening")).toBe(true) + + scope.setNavigating(true) + scope.setVisible([]) + await settle() + expect(scope.cached("ses_opening")).toBe(true) + + scope.setNavigating(false) + await settle() + expect(scope.cached("ses_opening")).toBe(false) + } finally { + scope.dispose() + } +}) + +test("late reads, late pages and later events are released again, and reopening reads the transcript", async () => { + const late = Promise.withResolvers() + const older = Promise.withResolvers() + const ids = ["ses_paged", "ses_late"] + const scope = setup({ + visible: ids, + read(url) { + if (url.searchParams.has("cursor")) return older.promise + if (url.pathname.endsWith("/ses_late/message")) return late.promise + return undefined + }, + }) + try { + scope.remember("ses_paged") + scope.remember("ses_late") + await scope.data.session.message.sync("ses_paged") + await scope.data.session.pending.sync("ses_late") + const reads = Promise.allSettled([ + scope.data.session.message.sync("ses_late"), + scope.data.session.message.loadMore("ses_paged"), + ]) + + scope.setVisible([]) + await settle() + expect(ids.filter(scope.cached)).toEqual([]) + + late.resolve() + older.resolve() + await reads + // Both reads publish after their family was evicted. + expect(ids.filter(scope.cached)).toEqual(ids) + await settle() + expect(ids.filter(scope.cached)).toEqual([]) + + scope.emit(agentSelected("ses_paged")) + expect(scope.cached("ses_paged")).toBe(true) + await settle() + expect(scope.cached("ses_paged")).toBe(false) + + scope.setVisible(["ses_paged"]) + await scope.data.session.message.sync("ses_paged") + await settle() + expect(scope.transcriptReads("ses_paged")).toBe(2) + expect(scope.data.session.message.list("ses_paged").map((item) => item.id)).toEqual(["msg_ses_paged"]) + } finally { + late.resolve() + older.resolve() + scope.dispose() + } +}) + +test.each(["echo", "reject"] as const)( + "keeps a closed session's optimistic prompt past the deadline and releases it after its %s", + async (mode) => { + const answer = Promise.withResolvers() + const scope = setup({ + async read(url) { + if (!url.pathname.endsWith("/prompt")) return undefined + await answer.promise + return mode === "reject" + ? Response.json({ message: "rejected" }, { status: 400 }) + : Response.json({ id: "msg_local" }) + }, + }) + try { + scope.remember("ses_submit") + const prompt = Promise.allSettled([ + scope.data.session.prompt({ sessionID: "ses_submit", id: "msg_local", text: "local" }), + ]) + await settle() + // The deadline passed while the submission awaited its acknowledgement. + expect(scope.data.session.message.list("ses_submit").map((item) => item.id)).toEqual(["msg_local"]) + + if (mode === "echo") scope.emit(enqueued("ses_submit", "msg_local")) + answer.resolve() + await prompt + await settle() + expect(scope.cached("ses_submit")).toBe(false) + expect(scope.data.session.pending.list("ses_submit")).toEqual([]) + } finally { + answer.resolve() + scope.dispose() + } + }, +) + +test("keeps a closed session's first prompt while its creation is unacknowledged, then releases it", async () => { + const created = Promise.withResolvers() + const scope = setup({ + read(url) { + if (url.pathname === "/api/session") return created.promise + if (url.pathname.endsWith("/prompt")) return Promise.resolve(Response.json({ id: "msg_first" })) + return undefined + }, + }) + try { + const session = scope.data.session.create({}) + const prompt = Promise.allSettled([ + scope.data.session.prompt({ sessionID: session.id, id: "msg_first", text: "first" }), + ]) + await settle() + // Eviction skips a session whose creation the server has not acknowledged. + expect(scope.data.session.message.list(session.id).map((item) => item.id)).toEqual(["msg_first"]) + + created.resolve(Response.json({ data: info(session.id) })) + await session.request + scope.emit(enqueued(session.id, "msg_first")) + await prompt + await settle() + expect(scope.cached(session.id)).toBe(false) + expect(scope.data.session.pending.list(session.id)).toEqual([]) + expect(scope.data.session.get(session.id)?.id).toBe(session.id) + } finally { + scope.dispose() + } +}) + +test("closed transcripts and the rows later events bring back do not stay on the heap", async () => { + const count = 48 + const size = 512 * 1024 + const ids = Array.from({ length: count }, (_, index) => `ses_heavy_${index}`) + const scope = setup({ text: "x".repeat(size) }) + try { + ids.forEach((id) => scope.remember(id)) + scope.setVisible(ids) + const base = heap() + for (const id of ids) await scope.data.session.message.sync(id) + const rows = ids.map((id) => new WeakRef(unwrap(scope.data.session.message.list(id))[0]!)) + const loaded = heap() + + scope.setVisible([]) + await settle() + ids.forEach((id) => scope.emit(agentSelected(id))) + expect(ids.filter(scope.cached)).toEqual(ids) + await settle() + const released = heap() + + console.info(`[session-retention heap] base=${base} loaded=${loaded} released=${released}`) + expect(ids.filter(scope.cached)).toEqual([]) + expect(loaded - base).toBeGreaterThan(count * size * 0.8) + expect(released - base).toBeLessThan((loaded - base) * 0.1) + expect(rows.filter((row) => row.deref() !== undefined)).toHaveLength(0) + } finally { + scope.dispose() + } +}) + +function settle() { + return Bun.sleep(delay * 5) +} + +function heap() { + Bun.gc(true) + return process.memoryUsage().heapUsed +} + +function setup( + input: { + visible?: string[] + ready?: boolean + text?: string + /** Delays a request, or answers it when the promise resolves to a response. */ + read?: (url: URL) => Promise | undefined + } = {}, +) { + const listeners = new Set[0]>() + const reads: URL[] = [] + const api = OpenCode.make({ + baseUrl: "http://opencode.local", + fetch: async (request) => { + const url = new URL(request instanceof Request ? request.url : String(request)) + reads.push(url) + const response = await input.read?.(url) + if (response) return response + const sessionID = url.pathname.split("/")[3] + if (url.pathname.endsWith("/inbox")) + return Response.json({ + data: [ + { + id: `inb_${sessionID}`, + sessionID, + type: "user", + delivery: "steer", + payload: { text: "pending" }, + time: { created: 2 }, + }, + ], + }) + const older = url.searchParams.has("cursor") + return Response.json({ + data: [ + { + id: older ? `msg_${sessionID}_older` : `msg_${sessionID}`, + type: "user", + text: input.text ?? "transcript", + time: { created: older ? 0 : 1 }, + }, + ], + cursor: older ? {} : { next: "older" }, + }) + }, + }) + return createRoot((dispose) => { + const data = createData({ + api: () => api, + directory: "/project", + event: { + on: () => () => {}, + listen(handler) { + listeners.add(handler) + return () => listeners.delete(handler) + }, + }, + }) + const [visible, setVisible] = createSignal(input.visible ?? []) + const [ready, setReady] = createSignal(input.ready ?? true) + const [navigating, setNavigating] = createSignal(false) + createSessionRetention({ session: data.session, ready, visible, navigating, delay }) + return { + data, + dispose, + setVisible, + setReady, + setNavigating, + emit: (details: OpenCodeEvent) => listeners.forEach((listener) => listener({ name: details.type, details })), + remember: (id: string, parentID?: string) => data.session.remember(info(id, parentID)), + cached: (id: string) => data.session.message.list(id).length > 0, + // Reads of the newest transcript page, not of older pages. + transcriptReads: (id: string) => + reads.filter((url) => url.pathname.endsWith(`/${id}/message`) && !url.searchParams.has("cursor")).length, + } + }) +} + +function info(id: string, parentID?: string): SessionInfo { + return { + id, + parentID, + projectID: "project", + cost: 0, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 0, updated: 0 }, + location: { directory: "/project" }, + } +} + +function agentSelected(sessionID: string): OpenCodeEvent { + return { + id: `evt_agent_${sessionID}`, + created: 1, + type: "session.agent.selected", + durable: { aggregateID: sessionID, seq: 1, version: 1 }, + data: { sessionID, agent: "build" }, + } +} + +function permissionAsked(sessionID: string): OpenCodeEvent { + return { + id: `evt_permission_${sessionID}`, + created: 1, + type: "permission.asked", + data: { id: `per_${sessionID}`, sessionID, action: "bash", resources: ["bun test"] }, + } +} + +function enqueued(sessionID: string, inboxID: string): OpenCodeEvent { + return { + id: `evt_${inboxID}`, + created: 1, + type: "session.inbox.enqueued", + durable: { aggregateID: sessionID, seq: 1, version: 1 }, + data: { sessionID, inboxID, item: { type: "user", delivery: "steer", payload: { text: "echoed" } } }, + } +} diff --git a/packages/client/src/solid/data.ts b/packages/client/src/solid/data.ts index c5036a03f4..9b9300d9ec 100644 --- a/packages/client/src/solid/data.ts +++ b/packages/client/src/solid/data.ts @@ -1428,6 +1428,12 @@ export function createData(config: CreateDataInput) { status === "running" ? [sessionID] : [], ) }, + /** Sessions holding transcript or pending rows. Notifies only when that set changes, not per streamed row. */ + cached: createMemo( + () => [...new Set([...Object.keys(store.session.message), ...Object.keys(store.session.pending)])].toSorted(), + [], + { equals: (a, b) => a.length === b.length && a.every((id, index) => id === b[index]) }, + ), // Inputs are the pending user and synthetic items; compactions are control items. input: { list(sessionID: string) {