mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-18 15:28:48 +03:00
fix(app): select the session route view from one resolution machine (#61963)
This commit is contained in:
committed by
GitHub
Unverified
parent
883249d729
commit
008619ae06
@@ -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",
|
||||
},
|
||||
|
||||
@@ -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 }
|
||||
}
|
||||
|
||||
@@ -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>
|
||||
)
|
||||
|
||||
@@ -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()
|
||||
})
|
||||
|
||||
Reference in New Issue
Block a user