fix(app): select the session route view from one resolution machine (#61963)

This commit is contained in:
Luke Parker
2026-11-05 01:52:55 -06:00
committed by GitHub
Unverified
parent 883249d729
commit 008619ae06
8 changed files with 767 additions and 186 deletions
@@ -1,5 +1,15 @@
import { expect, test, type Page } from "@playwright/test"
import { REMOTE_SERVER, SERVER, expectPath, project, seed, session, sessionHref, type TabSeed } from "../utils/app"
import {
REMOTE_SERVER,
SERVER,
expectPath,
holdRoute,
project,
seed,
session,
sessionHref,
type TabSeed,
} from "../utils/app"
import { mockServers, type MockServerConfig } from "../utils/mock-server"
import { expectSessionTitle } from "../utils/waits"
@@ -151,7 +161,9 @@ test("a remote session whose server signed the app out asks to sign in again, th
})
await seed(page, {
storage: {
"opencode.global.dat:server": { list: [{ type: "http", http: { url: REMOTE_SERVER, password: "old-password" } }] },
"opencode.global.dat:server": {
list: [{ type: "http", http: { url: REMOTE_SERVER, password: "old-password" } }],
},
},
})
await page.goto(sessionHref(sessionB.id, REMOTE_SERVER))
@@ -176,6 +188,55 @@ test("a remote session whose server signed the app out asks to sign in again, th
await expect(signedOut).toHaveCount(0)
})
// The session route waits this long for an uncached session before it calls the server unreachable.
const RESOLUTION_TIMEOUT_MS = 30_000
// How often the app checks each server's health.
const SERVER_HEALTH_POLL_MS = 10_000
test("a session its server never answers for says the server is unreachable, then opens", async ({ page }) => {
const late = session({ id: "ses_server_a_late", directory: directoryA, title: "Late session" })
const sessions = [sessionA]
await setup(page, { tabs: [], a: { sessions } })
const metadata = await holdRoute(page, new RegExp(`/api/session/${late.id}(\\?|$)`), { method: "GET" })
await page.clock.install()
await page.goto(sessionHref(late.id))
await metadata.arrived
const unreachable = page.getByText("Can't reach this server", { exact: true })
await expect(unreachable).toHaveCount(0)
await page.clock.fastForward(RESOLUTION_TIMEOUT_MS)
await expect(unreachable).toBeVisible()
await expect(page.getByRole("button", { name: "Close Tab", exact: true })).toBeVisible()
// The request that hung still fills the cache when it answers.
sessions.push(late)
metadata.release()
await expectSessionTitle(page, late.title)
await expect(unreachable).toHaveCount(0)
})
test("an open session stays visible while its server stops answering", async ({ page }) => {
const late = session({ id: "ses_server_a_late", directory: directoryA, title: "Late session" })
await setup(page, { tabs: [sessionA.id, late.id], a: { sessions: [sessionA] } })
await holdRoute(page, new RegExp(`/api/session/${late.id}(\\?|$)`), { method: "GET" })
await page.clock.install()
await page.goto(sessionHref(sessionA.id))
await expectSessionTitle(page, sessionA.title)
await page.route(`${SERVER}/api/info`, (route) => route.fulfill({ status: 503, body: "" }))
await page.clock.fastForward(SERVER_HEALTH_POLL_MS)
const unreachable = page.getByText("Can't reach this server", { exact: true })
// An uncached session on the same server proves the app now considers the server down.
await page.locator(`[data-titlebar-tab-slot]:has(a[href="${sessionHref(late.id)}"])`).click()
await expect(unreachable).toBeVisible()
await page.locator(`[data-titlebar-tab-slot]:has(a[href="${sessionHref(sessionA.id)}"])`).click()
await expectSessionTitle(page, sessionA.title)
await expect(unreachable).toHaveCount(0)
})
test("auto-accept responds for an unfocused server session and its child", async ({ page }) => {
const view = await setup(page, { tabs: [sessionA.id, { session: sessionB.id, server: REMOTE_SERVER }] })
await page.goto(sessionHref(sessionA.id))
@@ -1,6 +1,6 @@
import { base64Encode } from "@opencode/util/encode"
import { expect, test } from "@playwright/test"
import { NO_PROVIDER, REMOTE_SERVER, SERVER, project, provider, session } from "../utils/app"
import { NO_PROVIDER, REMOTE_SERVER, SERVER, holdRoute, project, provider, session } from "../utils/app"
import { mockOpenCodeServer, mockServers } from "../utils/mock-server"
import { expectSessionTitle } from "../utils/waits"
@@ -250,3 +250,43 @@ test("an open session moves to the controller a new SSH sign-in creates", async
await editor.press("Enter")
await expect.poll(() => prompts).toEqual(["after sign-in"])
})
test("a session being created on an SSH host that turns out incompatible says so", async ({ page }) => {
const directory = "/home/box/project"
const box = session({ id: "ses_ssh_incompatible", directory, title: "SSH incompatible session" })
const config = {
directory,
project: project({ id: "proj_ssh_incompatible", directory }),
provider: provider(),
sessions: [box],
pageMessages: () => ({ items: [] }),
}
await mockServers(page, { [SERVER]: { ...config, sessions: [] }, [REMOTE_SERVER]: config })
const path = `/server/${base64Encode("ssh:box")}/session/${box.id}`
await page.goto(
`/e2e/utils/settings-wsl.html?${new URLSearchParams({ server: SERVER, mode: "ready", ssh: REMOTE_SERVER, path })}`,
)
await expectSessionTitle(page, box.title)
await page.getByRole("button", { name: "New session", exact: true }).click()
// The create request stays in flight, so the new session stays in preparation.
await holdRoute(page, new RegExp(`^${REMOTE_SERVER.replace(/[.]/g, "\\.")}/api/session(\\?|$)`), { method: "POST" })
const editor = page.locator('[data-component="composer-editor"]')
const send = page.getByRole("button", { name: "Send", exact: true })
await expect(page.locator('[data-component="new-session"]')).toBeVisible()
await expect(editor).toBeEditable()
await editor.fill("start on the box")
await expect(editor).toHaveText("start on the box")
await expect(send).toBeEnabled()
await send.click()
const preparing = page.locator('[data-component="session-preparing"]')
await expect(preparing).toBeVisible()
// The SSH plugin covers a host that is not ready; the route stays mounted beneath its cover.
await page.getByRole("button", { name: "Report incompatible SSH server" }).click()
await expect(page.getByRole("heading", { name: "SSH connection inactive", exact: true })).toBeVisible()
await expect(page.getByText("This server version isn't supported", { exact: true })).toBeAttached()
await expect(preparing).toHaveCount(0)
})
@@ -299,6 +299,16 @@ export function mount(input: {
>
Require SSH sign-in
</button>
{/* The remote server answering with a version this app does not support. */}
<button
type="button"
onClick={() => {
setSsh({ stage: "incompatible" })
publish("ssh")
}}
>
Report incompatible SSH server
</button>
<output aria-label="SSH connects">{store.connects}</output>
</Show>
<Show when={input.hold}>
@@ -2,8 +2,12 @@ import { expect, test } from "bun:test"
import type { ServerHealth } from "@/runtime/server/health-machine"
import {
createSessionResolutionState,
SESSION_RESOLUTION_TIMEOUT_MS,
sessionDocumentTitle,
sessionModelDirectory,
sessionRouteView,
transitionSessionResolution,
viewedSessionID,
type SessionResolutionEffect,
type SessionResolutionEvent,
type SessionResolutionState,
@@ -11,33 +15,53 @@ import {
type SessionRouteView,
} from "./resolution-machine"
type Session = { id: string }
type Session = { id: string; title?: string; location: { directory: string } }
type Event = SessionResolutionEvent<Session, string>
type Pending = { draft: { directory: string } }
type State = SessionResolutionState<Session, string>
type Event = SessionResolutionEvent<Session, string, Pending>
type State = SessionResolutionState<Session, string, Pending>
const target = (sessionID: string, scope = "server-a") => ({ scope, sessionID })
const info = (id: string, title?: string): Session => ({ id, title, location: { directory: `/work/${id}` } })
const timer = (attempt: number) => ({ type: "timer.start", attempt, delayMs: SESSION_RESOLUTION_TIMEOUT_MS }) as const
function open(
sessionID: string,
input: { cached?: Session; connected?: boolean; refresh?: boolean; scope?: string } = {},
input: { cached?: Session; pending?: Pending; connected?: boolean; refresh?: boolean; scope?: string } = {},
): Event {
return {
type: "target.changed",
target: target(sessionID, input.scope),
pending: input.pending,
cached: input.cached,
connected: input.connected ?? true,
refresh: input.refresh ?? true,
}
}
function replay(events: Event[]) {
const initial: SessionResolutionTransition<Session, string> = { state: createSessionResolutionState(), effects: [] }
function settledPending(sessionID: string, input: { cached?: Session; connected?: boolean } = {}): Event {
return {
type: "pending.changed",
target: target(sessionID),
pending: undefined,
cached: input.cached,
connected: input.connected ?? true,
refresh: true,
}
}
function replay(events: Event[], from: State = createSessionResolutionState()) {
const initial: SessionResolutionTransition<Session, string, Pending> = { state: from, effects: [] }
return events.reduce((current, event) => transitionSessionResolution(current.state, event), initial)
}
const types = (effects: readonly SessionResolutionEffect<string>[]) => effects.map((effect) => effect.type)
// The SDK rejects with the decoded response body.
const notFound = (sessionID: string) =>
JSON.parse(`{"_tag":"SessionNotFoundError","sessionID":"${sessionID}","message":"Session not found"}`)
@@ -50,19 +74,21 @@ test.each([
])("a $name session does not outlive a switch to another tab", ({ error, shown }) => {
const failed = replay([open("ses_a"), { type: "sync.failed", target: target("ses_a"), attempt: 1, error }])
expect(sessionRouteView(failed.state, undefined)).toMatchObject({ type: shown, sessionID: "ses_a" })
expect(failed.effects).toEqual([{ type: "timer.clear" }])
const next = transitionSessionResolution(failed.state, open("ses_b"))
expect(sessionRouteView(next.state, undefined)).toEqual({ type: "resolving", sessionID: "ses_b" })
expect(next.effects).toEqual([
{ type: "sync.transcript", target: target("ses_b") },
{ type: "sync.metadata", target: target("ses_b"), attempt: 2 },
timer(2),
])
const cached = transitionSessionResolution(failed.state, open("ses_b", { cached: { id: "ses_b" } }))
const cached = transitionSessionResolution(failed.state, open("ses_b", { cached: info("ses_b") }))
expect(sessionRouteView(cached.state, undefined)).toEqual({
type: "ready",
sessionID: "ses_b",
session: { id: "ses_b" },
session: info("ses_b"),
})
})
@@ -73,7 +99,9 @@ test("ignores results from an earlier visit to the same session", () => {
const late: Event[] = [
{ type: "sync.failed", target: target("ses_a"), attempt: 1, error: new Error("boom") },
{ type: "sync.settled", target: target("ses_a"), attempt: 1, session: undefined },
{ type: "sync.settled", target: target("ses_b"), attempt: 2, session: { id: "ses_b" } },
{ type: "sync.settled", target: target("ses_b"), attempt: 2, session: info("ses_b") },
{ type: "resolve.timed-out", attempt: 1 },
{ type: "resolve.timed-out", attempt: 2 },
]
late.forEach((event) => expect(transitionSessionResolution(returned.state, event).state).toBe(returned.state))
@@ -87,7 +115,7 @@ test("ignores results from an earlier visit to the same session", () => {
})
test("a replaced session store is a new target", () => {
const ready = replay([open("ses_a", { cached: { id: "ses_a" } })])
const ready = replay([open("ses_a", { cached: info("ses_a") })])
const replaced = transitionSessionResolution(ready.state, open("ses_a", { scope: "server-b" }))
expect(replaced.state).toEqual({ status: "resolving", target: target("ses_a", "server-b"), attempt: 2 })
@@ -98,17 +126,26 @@ test("a replaced session store is a new target", () => {
test.each<{ name: string; event: Event; effects: SessionResolutionEffect<string>["type"][] }>([
{
name: "a cached session without refresh loads only its transcript",
event: open("ses_a", { cached: { id: "ses_a" }, refresh: false }),
event: open("ses_a", { cached: info("ses_a"), refresh: false }),
effects: ["sync.transcript"],
},
{
name: "a cached session with refresh also reloads its metadata",
event: open("ses_a", { cached: { id: "ses_a" } }),
event: open("ses_a", { cached: info("ses_a") }),
effects: ["sync.transcript", "sync.metadata"],
},
{ name: "a disconnected route waits to load", event: open("ses_a", { connected: false }), effects: [] },
{
name: "a disconnected route waits to load, for a bounded time",
event: open("ses_a", { connected: false }),
effects: ["timer.start"],
},
{
name: "a pending session loads nothing while its promotion creates it",
event: open("ses_a", { pending: { draft: { directory: "/draft" } } }),
effects: [],
},
])("$name", ({ event, effects }) => {
expect(replay([event]).effects.map((effect) => effect.type)).toEqual(effects)
expect(types(replay([event]).effects)).toEqual(effects)
})
test("reconnecting retries a failed session and refreshes a resolved one in place", () => {
@@ -116,16 +153,16 @@ test("reconnecting retries a failed session and refreshes a resolved one in plac
const failed = replay([open("ses_a"), { type: "sync.failed", target: target("ses_a"), attempt: 1, error: "offline" }])
const retried = transitionSessionResolution(failed.state, connected)
expect(retried.state).toEqual({ status: "resolving", target: target("ses_a"), attempt: 2 })
expect(retried.effects.map((effect) => effect.type)).toEqual(["sync.transcript", "sync.metadata"])
expect(types(retried.effects)).toEqual(["sync.transcript", "sync.metadata", "timer.start"])
const ready = replay([open("ses_a", { cached: { id: "ses_a" } })])
const ready = replay([open("ses_a", { cached: info("ses_a") })])
const refreshed = transitionSessionResolution(ready.state, connected)
expect(refreshed.state).toBe(ready.state)
expect(refreshed.effects.map((effect) => effect.type)).toEqual(["sync.transcript", "sync.metadata"])
expect(types(refreshed.effects)).toEqual(["sync.transcript", "sync.metadata"])
})
test("a resolved session stays visible through a failed refresh until it leaves the cache", () => {
const ready = replay([open("ses_a", { cached: { id: "ses_a" } })])
const ready = replay([open("ses_a", { cached: info("ses_a") })])
const failure: Event = { type: "sync.failed", target: target("ses_a"), attempt: 1, error: new Error("boom") }
expect(transitionSessionResolution(ready.state, failure).state).toBe(ready.state)
@@ -137,17 +174,207 @@ test("a resolved session stays visible through a failed refresh until it leaves
})
})
test("unmounting ignores later results", () => {
test("unmounting ignores later results and stops the resolution timeout", () => {
const disposed = replay([open("ses_a"), { type: "disposed" }])
expect(disposed.state).toEqual({ status: "idle", attempt: 2 })
expect(disposed.effects).toEqual([{ type: "timer.clear" }])
const late: Event = { type: "sync.settled", target: target("ses_a"), attempt: 1, session: { id: "ses_a" } }
expect(transitionSessionResolution(disposed.state, late).state).toBe(disposed.state)
const late: Event[] = [
{ type: "sync.settled", target: target("ses_a"), attempt: 1, session: info("ses_a") },
{ type: "resolve.timed-out", attempt: 1 },
]
late.forEach((event) => expect(transitionSessionResolution(disposed.state, event).state).toBe(disposed.state))
})
// The route showed the preparing screen outside the machine, so a server that turned out to be incompatible while a
// new session was being created stayed on "Creating worktree" instead of saying so.
test("an incompatible server wins over a session that is still being prepared", () => {
const pending = { draft: { directory: "/draft" } }
const preparing = replay([open("ses_a", { pending })])
expect(preparing.state).toEqual({ status: "preparing", target: target("ses_a"), pending, attempt: 1 })
expect(sessionRouteView(preparing.state, { type: "checking", managed: false })).toEqual({
type: "preparing",
sessionID: "ses_a",
pending,
})
expect(sessionRouteView(preparing.state, { type: "incompatible" })).toEqual({
type: "incompatible",
sessionID: "ses_a",
})
})
// The created session reached the cache before the promotion settled, so the route briefly had both a pending
// session and a cached one: the model picker read neither directory, and the session counted as viewed early.
test("a prepared session stays prepared until its promotion settles, then shows without resolving", () => {
const pending = { draft: { directory: "/draft" } }
const preparing = replay([open("ses_a", { pending })])
const created = info("ses_a")
const early: Event[] = [
{ type: "cache.changed", target: target("ses_a"), session: created },
{ type: "connected", target: target("ses_a"), refresh: true },
{ type: "pending.changed", target: target("ses_a"), pending, cached: created, connected: true, refresh: true },
{ type: "sync.settled", target: target("ses_a"), attempt: 1, session: created },
]
early.forEach((event) => {
const next = transitionSessionResolution(preparing.state, event)
expect(next.state).toBe(preparing.state)
expect(next.effects).toEqual([])
})
expect(sessionModelDirectory(preparing.state)).toBe("/draft")
expect(viewedSessionID(sessionRouteView(preparing.state, { type: "healthy" }))).toBeUndefined()
const settled = transitionSessionResolution(preparing.state, settledPending("ses_a", { cached: created }))
expect(settled.state).toEqual({ status: "ready", target: target("ses_a"), session: created, attempt: 2 })
expect(types(settled.effects)).toEqual(["sync.transcript", "sync.metadata"])
expect(sessionModelDirectory(settled.state)).toBe("/work/ses_a")
expect(viewedSessionID(sessionRouteView(settled.state, { type: "healthy" }))).toBe("ses_a")
})
test("a promotion that settles before the session is cached resolves it", () => {
const preparing = replay([open("ses_a", { pending: { draft: { directory: "/draft" } } })])
const settled = transitionSessionResolution(preparing.state, settledPending("ses_a"))
expect(settled.state).toEqual({ status: "resolving", target: target("ses_a"), attempt: 2 })
expect(settled.effects).toEqual([
{ type: "sync.transcript", target: target("ses_a") },
{ type: "sync.metadata", target: target("ses_a"), attempt: 2 },
timer(2),
])
expect(sessionModelDirectory(settled.state)).toBeUndefined()
})
// A contributed server waiting for sign-in or stopped never answers, so an uncached session stayed blank forever.
test.each<{ health: ServerHealth; view: SessionRouteView<Session>["type"] }>([
{ health: { type: "auth" }, view: "signed-out" },
{ health: { type: "unauthorized" }, view: "signed-out" },
{ health: { type: "stopped" }, view: "unreachable" },
])("an uncached session on a $health.type server explains it, a cached one stays", ({ health, view }) => {
expect(sessionRouteView(replay([open("ses_a")]).state, health)).toMatchObject({ type: view, sessionID: "ses_a" })
expect(sessionRouteView(replay([open("ses_a", { cached: info("ses_a") })]).state, health).type).toBe("ready")
})
// A server that answers its health check while its event stream never connects, or a metadata request that hangs,
// left the route on a bare header with no explanation and no way to close the tab.
test("a session that does not resolve in time shows as unreachable and recovers", () => {
const resolving = replay([open("ses_a", { connected: false })])
expect(resolving.effects).toEqual([timer(1)])
const mismatched = transitionSessionResolution(resolving.state, { type: "resolve.timed-out", attempt: 99 })
expect(mismatched.state).toBe(resolving.state)
const timedOut = transitionSessionResolution(resolving.state, { type: "resolve.timed-out", attempt: 1 })
expect(timedOut.state).toEqual({ status: "unreachable", target: target("ses_a"), attempt: 1 })
expect(timedOut.effects).toEqual([{ type: "timer.clear" }])
expect(sessionRouteView(timedOut.state, { type: "healthy" })).toEqual({ type: "unreachable", sessionID: "ses_a" })
expect(sessionRouteView(timedOut.state, { type: "incompatible" }).type).toBe("incompatible")
const repeated = transitionSessionResolution(timedOut.state, { type: "resolve.timed-out", attempt: 1 })
expect(repeated.state).toBe(timedOut.state)
expect(repeated.effects).toEqual([])
const reconnected = transitionSessionResolution(timedOut.state, {
type: "connected",
target: target("ses_a"),
refresh: true,
})
expect(reconnected.state).toEqual({ status: "resolving", target: target("ses_a"), attempt: 2 })
expect(types(reconnected.effects)).toEqual(["sync.transcript", "sync.metadata", "timer.start"])
// The request the reconnect replaced no longer answers.
const stale: Event = { type: "sync.failed", target: target("ses_a"), attempt: 1, error: new Error("stale") }
expect(transitionSessionResolution(reconnected.state, stale).state).toBe(reconnected.state)
// A request that hung past the timeout still fills the cache when it finally answers.
const cached = transitionSessionResolution(timedOut.state, {
type: "cache.changed",
target: target("ses_a"),
session: info("ses_a"),
})
expect(cached.state).toEqual({ status: "ready", target: target("ses_a"), session: info("ses_a"), attempt: 1 })
expect(cached.effects).toEqual([])
})
// The timeout used to advance the attempt, so a hung request that finally answered 404 or failed was dropped and the
// tab kept saying the server was unreachable although it had answered.
test.each<{ name: string; event: Event; state: State }>([
{
name: "metadata",
event: { type: "sync.settled", target: target("ses_a"), attempt: 1, session: info("ses_a") },
state: { status: "ready", target: target("ses_a"), session: info("ses_a"), attempt: 1 },
},
{
name: "a missing session",
event: { type: "sync.settled", target: target("ses_a"), attempt: 1, session: undefined },
state: { status: "not-found", target: target("ses_a"), attempt: 1 },
},
{
name: "a not-found error",
event: { type: "sync.failed", target: target("ses_a"), attempt: 1, error: notFound("ses_a") },
state: { status: "not-found", target: target("ses_a"), attempt: 1 },
},
{
name: "a failure",
event: { type: "sync.failed", target: target("ses_a"), attempt: 1, error: "boom" },
state: { status: "error", target: target("ses_a"), error: "boom", attempt: 1 },
},
])("a request that answers with $name after the timeout decides the outcome", ({ event, state }) => {
const timedOut = replay([open("ses_a"), { type: "resolve.timed-out", attempt: 1 }])
expect(timedOut.state.status).toBe("unreachable")
const answered = transitionSessionResolution(timedOut.state, event)
expect(answered.state).toEqual(state)
expect(answered.effects).toEqual([])
})
test.each<{ name: string; event: Event }>([
{
name: "metadata arrives",
event: { type: "sync.settled", target: target("ses_a"), attempt: 1, session: info("ses_a") },
},
{
name: "metadata fails",
event: { type: "sync.failed", target: target("ses_a"), attempt: 1, error: new Error("x") },
},
{ name: "the cache fills", event: { type: "cache.changed", target: target("ses_a"), session: info("ses_a") } },
{
name: "a promotion starts",
event: {
type: "pending.changed",
target: target("ses_a"),
pending: { draft: { directory: "/draft" } },
cached: undefined,
connected: true,
refresh: true,
},
},
{
name: "the route loses its target",
event: { type: "target.changed", target: undefined, cached: undefined, connected: false, refresh: true },
},
{ name: "the route unmounts", event: { type: "disposed" } },
])("leaving resolving when $name stops the timeout", ({ event }) => {
const next = transitionSessionResolution(replay([open("ses_a")]).state, event)
expect(next.state.status).not.toBe("resolving")
expect(next.effects.at(-1)).toEqual({ type: "timer.clear" })
})
test("the document title names only a shown session with a real title", () => {
const ready = (title?: string) => replay([open("ses_a", { cached: info("ses_a", title) })]).state
expect(sessionDocumentTitle(sessionRouteView(ready("Fix the build"), undefined))).toBe("Fix the build")
expect(sessionDocumentTitle(sessionRouteView(ready(), undefined))).toBeUndefined()
expect(sessionDocumentTitle(sessionRouteView(ready("Fix the build"), { type: "incompatible" }))).toBeUndefined()
expect(sessionDocumentTitle(sessionRouteView(replay([open("ses_a")]).state, undefined))).toBeUndefined()
})
const resolving: State = { status: "resolving", target: target("ses_a"), attempt: 1 }
const resolved: State = { status: "ready", target: target("ses_a"), session: { id: "ses_a" }, attempt: 1 }
const resolved: State = { status: "ready", target: target("ses_a"), session: info("ses_a"), attempt: 1 }
const missing: State = { status: "not-found", target: target("ses_a"), attempt: 1 }
@@ -165,14 +392,14 @@ test.each<{ name: string; health: ServerHealth; state: State; view: SessionRoute
view: "unreachable",
},
{
name: "a running health check keeps waiting",
health: { type: "checking", managed: true },
state: resolving,
view: "resolving",
name: "an unreachable server keeps a resolved session visible",
health: { type: "unreachable" },
state: resolved,
view: "ready",
},
{
name: "a rejected credential keeps waiting",
health: { type: "unauthorized" },
name: "a running health check keeps waiting",
health: { type: "checking", managed: true },
state: resolving,
view: "resolving",
},
+180 -54
View File
@@ -1,17 +1,30 @@
import { isFallbackTitle } from "@opencode/util/session-title-fallback"
import { isSessionNotFoundError } from "@/runtime/server/errors"
import type { ServerHealth } from "@/runtime/server/health-machine"
/** How long an uncached session may wait for a connection or its metadata before the route calls the server unreachable. */
export const SESSION_RESOLUTION_TIMEOUT_MS = 30_000
// One routed session: its ID within the session store that resolves it. A replaced store is a new target.
export type SessionTarget<Scope> = {
readonly scope: Scope
readonly sessionID: string
}
// `attempt` correlates a metadata sync with the target it was started for: it advances whenever the
// target changes, a reconnect retries an unresolved target, or the route unmounts, so a late result is ignored.
export type SessionResolutionState<T, Scope> =
// `attempt` correlates a metadata sync and the resolution timeout with the target they were started for: it advances
// whenever the target changes, a pending session starts or settles, a reconnect retries an unresolved target, or the
// route unmounts, so a late result is ignored. A timeout keeps the attempt: the request it gave up on may still answer.
// `preparing` is a new session whose tab promotion still owns its creation (`pending`); nothing loads until it settles.
export type SessionResolutionState<T, Scope, P = never> =
| { readonly status: "idle"; readonly attempt: number }
| {
readonly status: "preparing"
readonly target: SessionTarget<Scope>
readonly pending: P
readonly attempt: number
}
| { readonly status: "resolving"; readonly target: SessionTarget<Scope>; readonly attempt: number }
| { readonly status: "unreachable"; readonly target: SessionTarget<Scope>; readonly attempt: number }
| { readonly status: "ready"; readonly target: SessionTarget<Scope>; readonly session: T; readonly attempt: number }
| { readonly status: "not-found"; readonly target: SessionTarget<Scope>; readonly attempt: number }
| {
@@ -21,10 +34,19 @@ export type SessionResolutionState<T, Scope> =
readonly attempt: number
}
export type SessionResolutionEvent<T, Scope> =
export type SessionResolutionEvent<T, Scope, P = never> =
| {
readonly type: "target.changed"
readonly target: SessionTarget<Scope> | undefined
readonly pending?: P
readonly cached: T | undefined
readonly connected: boolean
readonly refresh: boolean
}
| {
readonly type: "pending.changed"
readonly target: SessionTarget<Scope>
readonly pending: P | undefined
readonly cached: T | undefined
readonly connected: boolean
readonly refresh: boolean
@@ -43,135 +65,228 @@ export type SessionResolutionEvent<T, Scope> =
readonly attempt: number
readonly error: unknown
}
| { readonly type: "resolve.timed-out"; readonly attempt: number }
| { readonly type: "disposed" }
export type SessionResolutionEffect<Scope> =
| { readonly type: "sync.transcript"; readonly target: SessionTarget<Scope> }
| { readonly type: "sync.metadata"; readonly target: SessionTarget<Scope>; readonly attempt: number }
| { readonly type: "timer.start"; readonly attempt: number; readonly delayMs: number }
| { readonly type: "timer.clear" }
export type SessionResolutionTransition<T, Scope> = {
readonly state: SessionResolutionState<T, Scope>
export type SessionResolutionTransition<T, Scope, P = never> = {
readonly state: SessionResolutionState<T, Scope, P>
readonly effects: readonly SessionResolutionEffect<Scope>[]
}
export type SessionRouteView<T> =
export type SessionRouteView<T, P = never> =
| { readonly type: "idle" }
| { readonly type: "incompatible"; readonly sessionID: string }
| { readonly type: "preparing"; readonly sessionID: string; readonly pending: P }
| { readonly type: "signed-out"; readonly sessionID: string }
| { readonly type: "unreachable"; readonly sessionID: string }
| { readonly type: "resolving"; readonly sessionID: string }
| { readonly type: "ready"; readonly sessionID: string; readonly session: T }
| { readonly type: "not-found"; readonly sessionID: string }
| { readonly type: "error"; readonly sessionID: string; readonly error: unknown }
type Targeted<T, Scope> = Exclude<SessionResolutionState<T, Scope>, { readonly status: "idle" }>
type Targeted<T, Scope, P> = Exclude<SessionResolutionState<T, Scope, P>, { readonly status: "idle" }>
export function createSessionResolutionState<T, Scope>(): SessionResolutionState<T, Scope> {
const NO_EFFECTS: readonly SessionResolutionEffect<never>[] = []
const IDLE_VIEW: SessionRouteView<never, never> = { type: "idle" }
export function createSessionResolutionState<T, Scope, P = never>(): SessionResolutionState<T, Scope, P> {
return { status: "idle", attempt: 0 }
}
export function transitionSessionResolution<T, Scope>(
state: SessionResolutionState<T, Scope>,
event: SessionResolutionEvent<T, Scope>,
): SessionResolutionTransition<T, Scope> {
export function transitionSessionResolution<T, Scope, P = never>(
state: SessionResolutionState<T, Scope, P>,
event: SessionResolutionEvent<T, Scope, P>,
): SessionResolutionTransition<T, Scope, P> {
if (event.type === "disposed") return released(state)
if (event.type === "target.changed") return targetChanged(state, event)
if (event.type === "resolve.timed-out") {
if (state.status !== "resolving" || state.attempt !== event.attempt) return unchanged(state)
// Same attempt: the metadata request still in flight may answer late, and its answer still decides the outcome.
return changed(state, { status: "unreachable", target: state.target, attempt: state.attempt })
}
if (state.status === "idle" || !sameTarget(state.target, event.target)) return unchanged(state)
if (event.type === "pending.changed") return pendingChanged(state, event)
// The tab promotion owns a preparing session: it creates the session, so neither its early cache entry nor a
// reconnect starts loading before the promotion settles.
if (state.status === "preparing") return unchanged(state)
if (event.type === "cache.changed") return cacheChanged(state, event.session)
if (event.type === "connected") return reconnected(state, event.refresh)
// Only the sync started for the current attempt answers a target that is still resolving: once the
// cache holds the session it is authoritative, and a deleted session is evicted from it.
if (state.status !== "resolving" || state.attempt !== event.attempt) return unchanged(state)
// Only the sync started for the current attempt answers a target that is still resolving, or that timed out
// waiting for it: once the cache holds the session it is authoritative, and a deleted session is evicted from it.
if ((state.status !== "resolving" && state.status !== "unreachable") || state.attempt !== event.attempt) {
return unchanged(state)
}
if (event.type === "sync.settled") {
if (event.session === undefined) {
return changed({ status: "not-found", target: state.target, attempt: state.attempt })
return changed(state, { status: "not-found", target: state.target, attempt: state.attempt })
}
return changed({ status: "ready", target: state.target, session: event.session, attempt: state.attempt })
return changed(state, { status: "ready", target: state.target, session: event.session, attempt: state.attempt })
}
if (isSessionNotFoundError(event.error, state.target.sessionID)) {
return changed({ status: "not-found", target: state.target, attempt: state.attempt })
return changed(state, { status: "not-found", target: state.target, attempt: state.attempt })
}
return changed({ status: "error", target: state.target, error: event.error, attempt: state.attempt })
return changed(state, { status: "error", target: state.target, error: event.error, attempt: state.attempt })
}
export function sessionRouteView<T, Scope>(
state: SessionResolutionState<T, Scope>,
export function sessionRouteView<T, Scope, P = never>(
state: SessionResolutionState<T, Scope, P>,
health: ServerHealth | undefined,
): SessionRouteView<T> {
if (state.status === "idle") return { type: "idle" }
): SessionRouteView<T, P> {
if (state.status === "idle") return IDLE_VIEW
const sessionID = state.target.sessionID
// A server this app cannot talk to wins over everything, including a session that is still being created.
if (health?.type === "incompatible") return { type: "incompatible", sessionID }
if (state.status === "preparing") return { type: "preparing", sessionID, pending: state.pending }
if (state.status === "ready") return { type: "ready", sessionID, session: state.session }
if (state.status === "not-found") return { type: "not-found", sessionID }
if (state.status === "error") return { type: "error", sessionID, error: state.error }
// Nothing is cached and an unreachable server never resolves the session, so explain instead of waiting blank.
// Only a failed health check counts: a version mismatch has its own panel, and a rejected credential is not an outage.
if (health?.type === "unreachable") return { type: "unreachable", sessionID }
// Nothing is cached and a server waiting for sign-in cannot resolve the session until the user signs in.
if (health?.type === "auth" || health?.type === "unauthorized") return { type: "signed-out", sessionID }
// Nothing is cached and an unreachable, stopped or silent server never resolves the session, so explain instead of
// waiting blank.
if (state.status === "unreachable" || health?.type === "unreachable" || health?.type === "stopped") {
return { type: "unreachable", sessionID }
}
return { type: "resolving", sessionID }
}
function targetChanged<T, Scope>(
state: SessionResolutionState<T, Scope>,
event: Extract<SessionResolutionEvent<T, Scope>, { readonly type: "target.changed" }>,
): SessionResolutionTransition<T, Scope> {
/** The directory whose models the route offers: the draft's while a new session is prepared, then the session's. */
export function sessionModelDirectory<
T extends { readonly location: { readonly directory: string } },
Scope,
P extends { readonly draft: { readonly directory: string } },
>(state: SessionResolutionState<T, Scope, P>) {
if (state.status === "preparing") return state.pending.draft.directory
if (state.status === "ready") return state.session.location.directory
return undefined
}
/** The session the user is looking at, which only a shown session is. */
export function viewedSessionID<T, P>(view: SessionRouteView<T, P>) {
return view.type === "ready" ? view.sessionID : undefined
}
export function sessionDocumentTitle<T extends { readonly title?: string }, P>(view: SessionRouteView<T, P>) {
if (view.type !== "ready") return undefined
return isFallbackTitle(view.session.title) ? undefined : view.session.title
}
function targetChanged<T, Scope, P>(
state: SessionResolutionState<T, Scope, P>,
event: Extract<SessionResolutionEvent<T, Scope, P>, { readonly type: "target.changed" }>,
): SessionResolutionTransition<T, Scope, P> {
if (!event.target) return released(state)
if (state.status !== "idle" && sameTarget(state.target, event.target)) return unchanged(state)
const attempt = state.attempt + 1
// Start independent reads before constructing the selected view, including when its metadata is
// cached but its transcript has never been loaded.
const effects = event.connected ? syncs(event.target, attempt, event.cached === undefined || event.refresh) : []
if (event.pending !== undefined) {
return changed(state, { status: "preparing", target: event.target, pending: event.pending, attempt })
}
if (event.cached === undefined) return changed({ status: "resolving", target: event.target, attempt }, effects)
return changed({ status: "ready", target: event.target, session: event.cached, attempt }, effects)
return opened(state, event.target, attempt, event)
}
function cacheChanged<T, Scope>(
state: Targeted<T, Scope>,
function pendingChanged<T, Scope, P>(
state: Targeted<T, Scope, P>,
event: Extract<SessionResolutionEvent<T, Scope, P>, { readonly type: "pending.changed" }>,
): SessionResolutionTransition<T, Scope, P> {
if (event.pending !== undefined) {
if (state.status === "preparing" && state.pending === event.pending) return unchanged(state)
return changed(state, {
status: "preparing",
target: state.target,
pending: event.pending,
attempt: state.attempt + 1,
})
}
if (state.status !== "preparing") return unchanged(state)
// The promotion settled: the created session is usually cached by now, so it shows without a resolving frame.
return opened(state, state.target, state.attempt + 1, event)
}
// Start independent reads before constructing the selected view, including when its metadata is
// cached but its transcript has never been loaded.
function opened<T, Scope, P>(
state: SessionResolutionState<T, Scope, P>,
target: SessionTarget<Scope>,
attempt: number,
input: { readonly cached: T | undefined; readonly connected: boolean; readonly refresh: boolean },
): SessionResolutionTransition<T, Scope, P> {
const effects = input.connected ? syncs(target, attempt, input.cached === undefined || input.refresh) : NO_EFFECTS
if (input.cached === undefined) return changed(state, { status: "resolving", target, attempt }, effects)
return changed(state, { status: "ready", target, session: input.cached, attempt }, effects)
}
function cacheChanged<T, Scope, P>(
state: Exclude<Targeted<T, Scope, P>, { readonly status: "preparing" }>,
session: T | undefined,
): SessionResolutionTransition<T, Scope> {
): SessionResolutionTransition<T, Scope, P> {
// The viewed session stays cached, so losing it after it resolved means it was deleted, possibly by another client.
if (session === undefined) {
if (state.status !== "ready") return unchanged(state)
return changed({ status: "not-found", target: state.target, attempt: state.attempt })
return changed(state, { status: "not-found", target: state.target, attempt: state.attempt })
}
if (state.status === "ready" && state.session === session) return unchanged(state)
return changed({ status: "ready", target: state.target, session, attempt: state.attempt })
return changed(state, { status: "ready", target: state.target, session, attempt: state.attempt })
}
// Queued inputs ride along with the transcript so a reconnect refreshes them instead of leaving the
// pre-disconnect queue on screen. A resolved session keeps its content visible while it refreshes;
// any other target retries from scratch.
function reconnected<T, Scope>(state: Targeted<T, Scope>, refresh: boolean): SessionResolutionTransition<T, Scope> {
if (state.status === "ready") return changed(state, syncs(state.target, state.attempt, refresh))
function reconnected<T, Scope, P>(
state: Exclude<Targeted<T, Scope, P>, { readonly status: "preparing" }>,
refresh: boolean,
): SessionResolutionTransition<T, Scope, P> {
if (state.status === "ready") return { state, effects: syncs(state.target, state.attempt, refresh) }
const attempt = state.attempt + 1
return changed({ status: "resolving", target: state.target, attempt }, syncs(state.target, attempt, true))
return changed(state, { status: "resolving", target: state.target, attempt }, syncs(state.target, attempt, true))
}
function released<T, Scope>(state: SessionResolutionState<T, Scope>): SessionResolutionTransition<T, Scope> {
function released<T, Scope, P>(state: SessionResolutionState<T, Scope, P>): SessionResolutionTransition<T, Scope, P> {
if (state.status === "idle") return unchanged(state)
return changed({ status: "idle", attempt: state.attempt + 1 })
return changed(state, { status: "idle", attempt: state.attempt + 1 })
}
// The timeline owns transcript errors, so only metadata reports back to the machine.
@@ -192,13 +307,24 @@ function sameTarget<Scope>(left: SessionTarget<Scope>, right: SessionTarget<Scop
return left.scope === right.scope && left.sessionID === right.sessionID
}
function changed<T, Scope>(
state: SessionResolutionState<T, Scope>,
effects: readonly SessionResolutionEffect<Scope>[] = [],
): SessionResolutionTransition<T, Scope> {
return { state, effects }
// Owns the resolution timeout: every entry into `resolving` starts it for the new attempt, and every exit clears it.
function changed<T, Scope, P>(
previous: SessionResolutionState<T, Scope, P>,
next: SessionResolutionState<T, Scope, P>,
effects: readonly SessionResolutionEffect<Scope>[] = NO_EFFECTS,
): SessionResolutionTransition<T, Scope, P> {
if (next.status === "resolving") {
return {
state: next,
effects: [...effects, { type: "timer.start", attempt: next.attempt, delayMs: SESSION_RESOLUTION_TIMEOUT_MS }],
}
}
if (previous.status === "resolving") return { state: next, effects: [...effects, { type: "timer.clear" }] }
return { state: next, effects }
}
function unchanged<T, Scope>(state: SessionResolutionState<T, Scope>): SessionResolutionTransition<T, Scope> {
return { state, effects: [] }
function unchanged<T, Scope, P>(state: SessionResolutionState<T, Scope, P>): SessionResolutionTransition<T, Scope, P> {
return { state, effects: NO_EFFECTS }
}
+92 -89
View File
@@ -6,7 +6,6 @@ import { makeEventListener } from "@solid-primitives/event-listener"
import { DataProvider } from "@opencode/session-ui/context"
import { SessionUserMessage } from "@opencode/session-ui/message"
import { TextShimmer } from "@opencode/ui/text-shimmer"
import { isFallbackTitle } from "@opencode/util/session-title-fallback"
import { CommentsProvider } from "@/composer/comments"
import { readPromptPresentation } from "@/composer/comment-note"
import { FileProvider } from "@/workspaces/files/model"
@@ -27,9 +26,9 @@ import { ErrorPage } from "@/shell/errors/error"
import { useSessionModel } from "./model"
import { SessionPanelFrame } from "./session-frame"
import { SessionIdentityHeader } from "./session-identity-header"
import { ServerUnavailablePanel } from "./server-unavailable-panel"
import { ServerSignedOutPanel, ServerUnavailablePanel } from "./server-unavailable-panel"
import { SessionErrorFallback, SessionNotFoundPanel } from "./route-error"
import { sessionRouteView } from "./resolution-machine"
import { sessionDocumentTitle, sessionModelDirectory, sessionRouteView, viewedSessionID } from "./resolution-machine"
import { createSessionResolution } from "./session-resolution"
import { SessionScreenView } from "./screen"
import { PreparingComposer } from "./preparing-composer"
@@ -40,19 +39,100 @@ export function TargetSessionRouteContent() {
const data = useData()
const server = useServer()
const tabs = useTabs()
const directory = createMemo(() => data.session.get(params.id)?.location.directory)
const resolution = createSessionResolution(
() => params.id,
() => data.session,
{
children: true,
connected: () => server.ctx.sdk.connection.status() === "connected",
pending: (sessionID) => tabs.pendingSession(server.key, sessionID),
},
)
const view = createMemo(() => sessionRouteView(resolution(), server.health))
const viewed = createMemo(() => viewedSessionID(view()))
const title = createMemo(() => sessionDocumentTitle(view()))
const modelDirectory = createMemo(() => sessionModelDirectory(resolution()))
// Kept once the session leaves `ready`: the session providers can still read it while the route
// swaps them out, where a narrowed <Match> value would throw a stale read.
const directory = createMemo((previous: string) => {
const current = view()
return current.type === "ready" ? current.session.location.directory : previous
}, "")
// Health updates rebuild the view; the preparing screen and its composer stay mounted through them.
const preparing = createMemo(
() => {
const current = view()
return current.type === "preparing" ? current : undefined
},
undefined,
{ equals: (a, b) => a?.sessionID === b?.sessionID && a?.pending === b?.pending },
)
const failure = createMemo(() => {
const current = view()
return current.type === "error" ? current : undefined
})
const closeTab = () => tabs.removeSessionTab({ server: server.key, sessionId: params.id })
return (
<>
<MarkSessionViewed sessionID={() => params.id} />
<SessionDocumentTitle sessionID={() => params.id} />
<ModelsProvider directory={directory()}>
<MarkSessionViewed sessionID={viewed} />
<SessionDocumentTitle title={title} />
<ModelsProvider directory={modelDirectory()}>
<TargetSessionSettingsCommand />
<SessionRouteErrorBoundary sessionID={params.id} serverKey={requireServerKey(params.serverKey)}>
<ComposerFocusProvider sessionID={params.id}>
<Show when={tabs.pendingSession(server.key, params.id)} fallback={<ResolvedTargetSessionRoute />}>
{(pending) => <PreparingSession sessionID={params.id} pending={pending()} />}
</Show>
<Switch>
<Match when={view().type === "incompatible"}>
<SessionStatePanel>
<ServerUnavailablePanel reason="incompatible" onClose={closeTab} />
</SessionStatePanel>
</Match>
<Match when={preparing()} keyed>
{(value) => <PreparingSession sessionID={value.sessionID} pending={value.pending} />}
</Match>
{/* Not keyed: the session providers stay mounted while tabs switch between resolved sessions. */}
<Match when={view().type === "ready"}>
<LocationProvider directory={directory()}>
<SessionUIProvider directory={directory()} server={server.key}>
<TargetSessionPage />
</SessionUIProvider>
</LocationProvider>
</Match>
<Match when={view().type === "not-found"}>
<SessionStatePanel>
<SessionNotFoundPanel sessionID={params.id} serverKey={server.key} />
</SessionStatePanel>
</Match>
<Match when={failure()} keyed>
{(value) => (
<SessionStatePanel>
<ErrorPage error={value.error} />
</SessionStatePanel>
)}
</Match>
<Match when={view().type === "signed-out"}>
<SessionStatePanel>
<ServerSignedOutPanel conn={server.conn} />
</SessionStatePanel>
</Match>
<Match when={view().type === "unreachable"}>
<SessionStatePanel>
<ServerUnavailablePanel reason="unreachable" onClose={closeTab} />
</SessionStatePanel>
</Match>
<Match when={view().type === "resolving"}>
<PendingSessionState sessionID={params.id} />
</Match>
</Switch>
</ComposerFocusProvider>
</SessionRouteErrorBoundary>
</ModelsProvider>
@@ -131,75 +211,6 @@ function SessionRouteErrorBoundary(props: ParentProps<{ sessionID?: string; serv
)
}
function ResolvedTargetSessionRoute() {
const params = useParams<{ id: string }>()
const server = useServer()
const tabs = useTabs()
const data = useData()
const resolution = createSessionResolution(
() => params.id,
() => data.session,
{ children: true, connected: () => server.ctx.sdk.connection.status() === "connected" },
)
const view = createMemo(() => sessionRouteView(resolution(), server.health))
// Kept once the session leaves `ready`: the session providers can still read it while the route
// swaps them out, where a narrowed <Match> value would throw a stale read.
const directory = createMemo((previous: string) => {
const current = view()
return current.type === "ready" ? current.session.location.directory : previous
}, "")
const failure = createMemo(() => {
const current = view()
return current.type === "error" ? current : undefined
})
const closeTab = () => tabs.removeSessionTab({ server: server.key, sessionId: params.id })
return (
<Switch>
<Match when={view().type === "incompatible"}>
<SessionStatePanel>
<ServerUnavailablePanel reason="incompatible" onClose={closeTab} />
</SessionStatePanel>
</Match>
{/* Not keyed: the session providers stay mounted while tabs switch between resolved sessions. */}
<Match when={view().type === "ready"}>
<LocationProvider directory={directory()}>
<SessionUIProvider directory={directory()} server={server.key}>
<TargetSessionPage />
</SessionUIProvider>
</LocationProvider>
</Match>
<Match when={view().type === "not-found"}>
<SessionStatePanel>
<SessionNotFoundPanel sessionID={params.id} serverKey={server.key} />
</SessionStatePanel>
</Match>
<Match when={failure()} keyed>
{(value) => (
<SessionStatePanel>
<ErrorPage error={value.error} />
</SessionStatePanel>
)}
</Match>
<Match when={view().type === "unreachable"}>
<SessionStatePanel>
<ServerUnavailablePanel reason="unreachable" onClose={closeTab} />
</SessionStatePanel>
</Match>
<Match when={view().type === "resolving"}>
<PendingSessionState sessionID={params.id} />
</Match>
</Switch>
)
}
function PendingSessionState(props: { sessionID: string }) {
return (
<SessionStatePanel>
@@ -257,18 +268,10 @@ function MarkSessionViewed(props: { sessionID: () => string | undefined }) {
}
// Browser tabs and desktop windows are otherwise indistinguishable, so name them after the open session.
function SessionDocumentTitle(props: { sessionID: () => string }) {
const data = useData()
const title = createMemo(() => {
const value = data.session.get(props.sessionID())?.title
return isFallbackTitle(value) ? undefined : value
})
function SessionDocumentTitle(props: { title: () => string | undefined }) {
// Keyed: <Title> reads its text inside a meta effect, which would hit a stale Show accessor once the session is deleted.
return (
<Show when={title()} keyed>
<Show when={props.title()} keyed>
{(value) => <Title>{`${value} · OpenCode`}</Title>}
</Show>
)
+58 -9
View File
@@ -23,17 +23,36 @@ type SessionStore<T> = {
// Resolution is imperative rather than a resource on purpose: a resource created here would be
// created inside the router's navigation transition, and suspending that transition deadlocks the
// URL commit and double-mounts the session header portals from the transition's shadow render.
export function createSessionResolution<T>(
// `pending` names a new session whose creation another owner (the tab promotion) still runs.
export function createSessionResolution<T, P = never>(
sessionID: () => string | undefined,
sessions: () => SessionStore<T>,
options?: { children?: boolean; connected?: () => boolean },
options?: { children?: boolean; connected?: () => boolean; pending?: (sessionID: string) => P | undefined },
) {
const [state, setState] = createSignal(createSessionResolutionState<T, SessionStore<T>>())
const [state, setState] = createSignal(createSessionResolutionState<T, SessionStore<T>, P>())
const connected = createMemo(() => options?.connected?.() ?? true)
// Without a live connection or child sessions to load, cached metadata is already complete.
const refresh = !!options?.children || !!options?.connected
let timer: ReturnType<typeof setTimeout> | undefined
const run = (effect: SessionResolutionEffect<SessionStore<T>>) => {
if (effect.type === "timer.clear") {
clearTimeout(timer)
timer = undefined
return
}
if (effect.type === "timer.start") {
clearTimeout(timer)
timer = setTimeout(() => {
timer = undefined
dispatch({ type: "resolve.timed-out", attempt: effect.attempt })
}, effect.delayMs)
return
}
const store = effect.target.scope
const id = effect.target.sessionID
@@ -47,14 +66,21 @@ export function createSessionResolution<T>(
store
.sync(id, options?.children ? { children: true } : undefined)
.then(() =>
dispatch({ type: "sync.settled", target: effect.target, attempt: effect.attempt, session: store.get(id) }),
dispatch({
type: "sync.settled",
target: effect.target,
attempt: effect.attempt,
session: untrack(() => store.get(id)),
}),
)
.catch((error) => dispatch({ type: "sync.failed", target: effect.target, attempt: effect.attempt, error }))
}
const dispatch = (event: SessionResolutionEvent<T, SessionStore<T>>) => {
const result = transitionSessionResolution(untrack(state), event)
setState(() => result.state)
const dispatch = (event: SessionResolutionEvent<T, SessionStore<T>, P>) => {
const previous = untrack(state)
const result = transitionSessionResolution(previous, event)
if (result.state !== previous) setState(() => result.state)
result.effects.forEach(run)
}
@@ -71,10 +97,33 @@ export function createSessionResolution<T>(
}
const target = { scope: store, sessionID: id }
const pending = createMemo(() => options?.pending?.(id))
const cached = createMemo(() => store.get(id))
dispatch({ type: "target.changed", target, cached: cached(), connected: connected(), refresh })
dispatch({
type: "target.changed",
target,
pending: pending(),
cached: cached(),
connected: connected(),
refresh,
})
// Owned by this target's run, so both are disposed before the next target is dispatched.
// Owned by this target's run, so all are disposed before the next target is dispatched.
createComputed(
on(
pending,
(value) =>
dispatch({
type: "pending.changed",
target,
pending: value,
cached: untrack(cached),
connected: untrack(connected),
refresh,
}),
{ defer: true },
),
)
createComputed(on(cached, (session) => dispatch({ type: "cache.changed", target, session }), { defer: true }))
createComputed(
on(
@@ -1,14 +1,14 @@
import { expect, test } from "bun:test"
import { expect, jest, test } from "bun:test"
import { createRoot, createSignal } from "solid-js"
import { createStore } from "solid-js/store"
import type { SessionResolutionState } from "@/session/resolution-machine"
import { SESSION_RESOLUTION_TIMEOUT_MS, type SessionResolutionState } from "@/session/resolution-machine"
import { createSessionResolution } from "@/session/session-resolution"
type Session = { id: string; directory: string }
const sessionOf = (id: string): Session => ({ id, directory: `/dir/${id}` })
function resolved<Scope>(state: SessionResolutionState<Session, Scope>) {
function resolved<Scope, P>(state: SessionResolutionState<Session, Scope, P>) {
return state.status === "ready" ? state.session : undefined
}
@@ -318,3 +318,68 @@ test("reports a deleted session as not found until the route targets another ses
dispose()
})
})
// The tab promotion creates a new session and caches it before it settles; only the settled promotion loads it.
test("a prepared session loads once its promotion settles, not when its cache entry appears", async () => {
await createRoot(async (dispose) => {
const fixture = createFixture()
const [pending, setPending] = createSignal<{ draft: string } | undefined>({ draft: "/draft" })
const current = createSessionResolution(
() => "ses_a",
() => fixture.sessions,
{ children: true, pending: () => pending() },
)
expect(current().status).toBe("preparing")
fixture.settle("ses_a")
await flush()
expect(current().status).toBe("preparing")
expect(fixture.resolves).toEqual([])
expect(fixture.messages.syncs).toEqual([])
setPending(undefined)
expect(resolved(current())?.id).toBe("ses_a")
expect(fixture.resolves).toEqual(["ses_a"])
expect(fixture.messages.syncs).toEqual(["ses_a"])
dispose()
})
})
test("an uncached session that never resolves shows as unreachable, and unmounting stops the timeout", () => {
jest.useFakeTimers()
createRoot((dispose) => {
const fixture = createFixture()
const [connection, setConnection] = createStore({ connected: false })
const current = createSessionResolution(
() => "ses_a",
() => fixture.sessions,
{ connected: () => connection.connected },
)
jest.advanceTimersByTime(SESSION_RESOLUTION_TIMEOUT_MS - 1)
expect(current().status).toBe("resolving")
jest.advanceTimersByTime(1)
expect(current().status).toBe("unreachable")
// A reconnect retries with a fresh timeout.
setConnection("connected", true)
expect(current().status).toBe("resolving")
expect(fixture.resolves).toEqual(["ses_a"])
jest.advanceTimersByTime(SESSION_RESOLUTION_TIMEOUT_MS - 1)
expect(current().status).toBe("resolving")
jest.advanceTimersByTime(1)
expect(current().status).toBe("unreachable")
setConnection("connected", false)
setConnection("connected", true)
dispose()
jest.advanceTimersByTime(SESSION_RESOLUTION_TIMEOUT_MS)
expect(current().status).toBe("idle")
})
jest.useRealTimers()
})