fix(app): retry failed mark-viewed reports for every caller (#61809)

This commit is contained in:
Luke Parker
2026-11-04 17:34:16 -06:00
committed by GitHub
Unverified
parent 6838d95795
commit 452cfb579c
4 changed files with 765 additions and 111 deletions
@@ -0,0 +1,297 @@
import { describe, expect, test } from "bun:test"
import {
INITIAL_LEGACY_MIGRATION_STATE,
INITIAL_VIEW_REPORT_STATE,
selectLegacyHiddenReports,
selectSessionUnread,
transitionLegacyMigration,
transitionViewReport,
type LegacyMigrationEvent,
type LegacyMigrationState,
type LegacyMigrationTransition,
type ViewReportEvent,
type ViewReportState,
type ViewReportTransition,
} from "./machine"
function replayView(events: ViewReportEvent[], from = INITIAL_VIEW_REPORT_STATE) {
return events.reduce<ViewReportTransition[]>((steps, event) => {
steps.push(transitionViewReport(steps.at(-1)?.state ?? from, event))
return steps
}, [])
}
function replayLegacy(events: LegacyMigrationEvent[], from = INITIAL_LEGACY_MIGRATION_STATE) {
return events.reduce<LegacyMigrationTransition[]>((steps, event) => {
steps.push(transitionLegacyMigration(steps.at(-1)?.state ?? from, event))
return steps
}, [])
}
const failed = (attempt: number): ViewReportEvent => ({ type: "report.failed", attempt, notFound: false })
const reporting = (idle: number, attempt: number, failures = 0): ViewReportState => ({
status: "reporting",
idle,
attempt,
failures,
})
describe("transitionViewReport", () => {
test("a one-shot view retries on its own until the report lands", () => {
// Menu and Inbox actions call markViewed once from an event handler; nothing re-runs them after a failure.
const steps = replayView([{ type: "view", idle: 2 }, failed(1), { type: "report.succeeded", attempt: 1 }])
expect(steps.map((step) => step.state)).toEqual([
reporting(2, 1),
reporting(2, 1, 1),
{ status: "reported", idle: 2, attempt: 1 },
])
expect(steps.map((step) => step.effects)).toEqual([
[{ type: "send", idle: 2, attempt: 1, delayMs: 0 }],
[{ type: "send", idle: 2, attempt: 1, delayMs: 250 }],
[],
])
})
test("backs off per root, gives up after the limit, and starts over on reconnect or a new view", () => {
const steps = replayView([{ type: "view", idle: 2 }, ...Array.from({ length: 7 }, () => failed(1))])
expect(steps.slice(1, 7).map((step) => step.effects[0])).toEqual(
[250, 500, 1000, 2000, 4000, 5000].map((delayMs) => ({ type: "send", idle: 2, attempt: 1, delayMs })),
)
const gaveUp = steps.at(-1)!
expect(gaveUp).toEqual({ state: { status: "failed", idle: 2, attempt: 1 }, effects: [] })
expect(transitionViewReport(gaveUp.state, { type: "connected" })).toEqual({
state: reporting(2, 2),
effects: [{ type: "send", idle: 2, attempt: 2, delayMs: 0 }],
})
// A view of an older copy still reports the newest watermark the failed report held.
expect(transitionViewReport(gaveUp.state, { type: "view", idle: 1 })).toEqual({
state: reporting(2, 2),
effects: [{ type: "send", idle: 2, attempt: 2, delayMs: 0 }],
})
// The next failure after starting over waits the first delay again, not the cap.
expect(transitionViewReport(reporting(2, 2), failed(2)).effects).toEqual([
{ type: "send", idle: 2, attempt: 2, delayMs: 250 },
])
})
test("a newer watermark replaces the report in flight and its late result is ignored", () => {
const steps = replayView([{ type: "view", idle: 2 }, failed(1), { type: "view", idle: 6 }])
expect(steps.at(-1)).toEqual({
state: reporting(6, 2),
effects: [{ type: "send.cancel" }, { type: "send", idle: 6, attempt: 2, delayMs: 0 }],
})
const current = steps.at(-1)!.state
expect(transitionViewReport(current, { type: "report.succeeded", attempt: 1 }).state).toBe(current)
expect(transitionViewReport(current, failed(1)).state).toBe(current)
})
test("re-running a view for a watermark already reported or in flight posts nothing", () => {
const inFlight = reporting(2, 1)
const reported: ViewReportState = { status: "reported", idle: 2, attempt: 1 }
expect(transitionViewReport(inFlight, { type: "view", idle: 2 }).state).toBe(inFlight)
expect(transitionViewReport(reported, { type: "view", idle: 2 }).state).toBe(reported)
expect(transitionViewReport(reported, { type: "view", idle: 3 })).toEqual({
state: reporting(3, 2),
effects: [{ type: "send", idle: 3, attempt: 2, delayMs: 0 }],
})
expect(transitionViewReport(reported, { type: "connected" }).state).toBe(reported)
})
test("a deleted session is forgotten without a retry", () => {
expect(transitionViewReport(reporting(2, 3, 2), { type: "report.failed", attempt: 3, notFound: true })).toEqual({
state: { status: "unreported", attempt: 3 },
effects: [{ type: "forget" }],
})
})
const afterDispose: ViewReportEvent[] = [
{ type: "view", idle: 9 },
failed(1),
{ type: "report.succeeded", attempt: 1 },
{ type: "connected" },
]
test.each([
[INITIAL_VIEW_REPORT_STATE, []],
[reporting(2, 1, 1), [{ type: "send.cancel" }]],
[{ status: "reported", idle: 2, attempt: 1 }, []],
[{ status: "failed", idle: 2, attempt: 1 }, []],
] as const)("disposing from %o cancels pending work and ignores later results", (from, effects) => {
const disposed = transitionViewReport(from, { type: "disposed" })
expect(disposed).toEqual({ state: { status: "disposed" }, effects })
afterDispose.forEach((event) => expect(transitionViewReport(disposed.state, event).state).toBe(disposed.state))
})
})
const list = [
{ session: "read-here", viewed: true },
{ session: "unread-here", viewed: false },
]
const hydrated = (connected: boolean, started?: number): LegacyMigrationEvent => ({
type: "hydrated",
list,
started,
now: 10,
connected,
})
describe("transitionLegacyMigration", () => {
test("a transient failure while connected retries with backoff, then ends in done", () => {
const steps = replayLegacy([
hydrated(true),
{ type: "sessions.reported", reports: [{ sessionID: "s1", idle: 5 }] },
{ type: "run.failed", attempt: 1 },
{ type: "run.succeeded", attempt: 2 },
])
expect(steps[0]!.effects).toEqual([
{ type: "persist.started", started: 10 },
{ type: "run", attempt: 1, delayMs: 5000 },
])
expect(steps[2]!.state).toMatchObject({ status: "migrating", attempt: 2, failures: 1 })
expect(steps[2]!.effects).toEqual([{ type: "run", attempt: 2, delayMs: 5000 }])
expect(steps[3]).toEqual({
state: { status: "done", reported: new Map([["s1", 5]]) },
effects: [{ type: "persist.remove" }],
})
})
test("a disconnect cancels the run, ignores its late result, and the reconnect runs a new attempt", () => {
const steps = replayLegacy([hydrated(true), { type: "connection.changed", connected: false }])
const idle = steps.at(-1)!
expect(idle.state).toMatchObject({ status: "idle", attempt: 1 })
expect(idle.effects).toEqual([{ type: "run.cancel" }])
expect(transitionLegacyMigration(idle.state, { type: "run.succeeded", attempt: 1 }).state).toBe(idle.state)
expect(transitionLegacyMigration(idle.state, { type: "run.failed", attempt: 1 }).state).toBe(idle.state)
expect(transitionLegacyMigration(idle.state, { type: "connection.changed", connected: true })).toMatchObject({
state: { status: "migrating", attempt: 2, failures: 0 },
effects: [{ type: "run", attempt: 2, delayMs: 5000 }],
})
})
test("after the last retry it keeps the list and waits for the next connection", () => {
const steps = replayLegacy([
hydrated(true),
...[1, 2, 3, 4].map((attempt): LegacyMigrationEvent => ({ type: "run.failed", attempt })),
])
expect(steps.slice(1, 4).map((step) => step.effects)).toEqual(
[5000, 10000, 20000].map((delayMs, index) => [{ type: "run", attempt: index + 2, delayMs }]),
)
expect(steps.at(-1)).toMatchObject({ state: { status: "idle", attempt: 4 }, effects: [] })
})
test.each([
["no list", { ...hydrated(true), list: undefined }, { status: "done" }, []],
["offline", hydrated(false), { status: "idle", attempt: 0 }, [{ type: "persist.started", started: 10 }]],
["a cutoff from an earlier start", hydrated(false, 3), { status: "idle", carry: { started: 3 } }, []],
] as const)("hydrating with %s", (_name, event, state, effects) => {
const result = transitionLegacyMigration(INITIAL_LEGACY_MIGRATION_STATE, event)
expect(result.state).toMatchObject(state)
expect(result.effects).toEqual(effects)
})
test("events that don't apply keep the same state", () => {
const idle = transitionLegacyMigration(INITIAL_LEGACY_MIGRATION_STATE, hydrated(false)).state
const reported = transitionLegacyMigration(idle, {
type: "sessions.reported",
reports: [{ sessionID: "s1", idle: 5 }],
}).state
expect(transitionLegacyMigration(INITIAL_LEGACY_MIGRATION_STATE, { type: "run.failed", attempt: 0 }).state).toBe(
INITIAL_LEGACY_MIGRATION_STATE,
)
expect(transitionLegacyMigration(idle, hydrated(true)).state).toBe(idle)
expect(transitionLegacyMigration(idle, { type: "connection.changed", connected: false }).state).toBe(idle)
expect(transitionLegacyMigration(idle, { type: "sessions.reported", reports: [] }).state).toBe(idle)
expect(
transitionLegacyMigration(reported, { type: "sessions.reported", reports: [{ sessionID: "s1", idle: 4 }] }).state,
).toBe(reported)
})
test("a page of reports is recorded in one state change", () => {
const idle = transitionLegacyMigration(INITIAL_LEGACY_MIGRATION_STATE, hydrated(false)).state
const reported = transitionLegacyMigration(idle, {
type: "sessions.reported",
reports: [
{ sessionID: "s1", idle: 5 },
{ sessionID: "s2", idle: 7 },
],
}).state
expect(reported).toMatchObject({
reported: new Map([
["s1", 5],
["s2", 7],
]),
})
expect(
transitionLegacyMigration(reported, {
type: "sessions.reported",
reports: [
{ sessionID: "s1", idle: 4 },
{ sessionID: "s2", idle: 9 },
],
}).state,
).toMatchObject({
reported: new Map([
["s1", 5],
["s2", 9],
]),
})
})
test("disposing cancels a pending run and ignores later results", () => {
const migrating = transitionLegacyMigration(INITIAL_LEGACY_MIGRATION_STATE, hydrated(true)).state
const disposed = transitionLegacyMigration(migrating, { type: "disposed" })
expect(disposed).toEqual({ state: { status: "disposed" }, effects: [{ type: "run.cancel" }] })
expect(transitionLegacyMigration(disposed.state, { type: "run.succeeded", attempt: 1 }).state).toBe(disposed.state)
expect(transitionLegacyMigration(INITIAL_LEGACY_MIGRATION_STATE, { type: "disposed" }).effects).toEqual([])
})
})
describe("selectSessionUnread", () => {
const sessions = [
{ id: "read-here", time: { idle: 5 } },
{ id: "unread-here", time: { idle: 6 } },
{ id: "viewed", time: { idle: 4, viewed: 4 } },
{ id: "untracked", time: { idle: 7, viewed: 3 } },
{ id: "new", time: { idle: 20 } },
{ id: "never-ran", time: {} },
]
const carrying = transitionLegacyMigration(INITIAL_LEGACY_MIGRATION_STATE, hydrated(false)).state
const done: LegacyMigrationState = { status: "done", reported: new Map([["read-here", 5]]) }
test.each([
["loading", INITIAL_LEGACY_MIGRATION_STATE, []],
["carrying the old list", carrying, ["unread-here", "new"]],
["done", done, ["unread-here", "untracked", "new"]],
] as const)("while %s", (_name, state, unread) => {
expect(sessions.flatMap((session) => (selectSessionUnread(state, session) ? [session.id] : []))).toEqual([
...unread,
])
})
test("the carry-over reports the sessions the server has unread but this client shows read", () => {
expect(selectLegacyHiddenReports(carrying, sessions)).toEqual([
{ sessionID: "read-here", idle: 5 },
{ sessionID: "untracked", idle: 7 },
])
})
})
@@ -0,0 +1,313 @@
import type { SessionInfo } from "@opencode/client/promise"
export const VIEW_RETRY_DELAY = 250
export const VIEW_RETRY_MAX_DELAY = 5_000
export const VIEW_RETRY_LIMIT = 6
// One root session's `session.view` report. `attempt` names one request, so a result for a watermark that a newer
// one replaced can never settle it. `reporting` covers both the request in flight and the backoff before a retry.
export type ViewReportState =
| { readonly status: "unreported"; readonly attempt: number }
| { readonly status: "reporting"; readonly idle: number; readonly attempt: number; readonly failures: number }
| { readonly status: "reported"; readonly idle: number; readonly attempt: number }
| { readonly status: "failed"; readonly idle: number; readonly attempt: number }
| { readonly status: "disposed" }
export type ViewReportEvent =
| { readonly type: "view"; readonly idle: number }
| { readonly type: "report.succeeded"; readonly attempt: number }
| { readonly type: "report.failed"; readonly attempt: number; readonly notFound: boolean }
| { readonly type: "connected" }
| { readonly type: "disposed" }
export type ViewReportEffect =
| { readonly type: "send"; readonly idle: number; readonly attempt: number; readonly delayMs: number }
| { readonly type: "send.cancel" }
| { readonly type: "forget" }
export type ViewReportTransition = {
readonly state: ViewReportState
readonly effects: readonly ViewReportEffect[]
}
export const INITIAL_VIEW_REPORT_STATE: ViewReportState = Object.freeze({ status: "unreported", attempt: 0 })
export function viewRetryDelay(failures: number) {
return Math.min(VIEW_RETRY_DELAY * 2 ** (failures - 1), VIEW_RETRY_MAX_DELAY)
}
export function transitionViewReport(state: ViewReportState, event: ViewReportEvent): ViewReportTransition {
if (state.status === "disposed") return { state, effects: [] }
if (event.type === "disposed") {
return { state: { status: "disposed" }, effects: state.status === "reporting" ? [{ type: "send.cancel" }] : [] }
}
// Reactive callers view again whenever what they read changes; only a newer watermark starts a new report. A
// report that gave up starts over on any view, so clicking the session again retries it.
if (event.type === "view") {
if ((state.status === "reporting" || state.status === "reported") && event.idle <= state.idle) {
return { state, effects: [] }
}
const idle = state.status === "failed" ? Math.max(state.idle, event.idle) : event.idle
return report(state, idle)
}
// A report that gave up while offline is retried once the connection is back.
if (event.type === "connected") {
if (state.status !== "failed") return { state, effects: [] }
return report(state, state.idle)
}
if (state.status !== "reporting" || state.attempt !== event.attempt) return { state, effects: [] }
if (event.type === "report.succeeded") {
return { state: { status: "reported", idle: state.idle, attempt: state.attempt }, effects: [] }
}
if (event.notFound) return { state: { status: "unreported", attempt: state.attempt }, effects: [{ type: "forget" }] }
if (state.failures >= VIEW_RETRY_LIMIT) {
return { state: { status: "failed", idle: state.idle, attempt: state.attempt }, effects: [] }
}
const failures = state.failures + 1
return {
state: { ...state, failures },
effects: [{ type: "send", idle: state.idle, attempt: state.attempt, delayMs: viewRetryDelay(failures) }],
}
}
function report(state: Exclude<ViewReportState, { status: "disposed" }>, idle: number): ViewReportTransition {
const attempt = state.attempt + 1
const send: ViewReportEffect = { type: "send", idle, attempt, delayMs: 0 }
return {
state: { status: "reporting", idle, attempt, failures: 0 },
effects: state.status === "reporting" ? [{ type: "send.cancel" }, send] : [send],
}
}
// The carry-over waits this long after connecting so it doesn't compete with startup requests.
export const LEGACY_MIGRATION_DELAY = 5_000
export const LEGACY_MIGRATION_RETRY_MAX_DELAY = 30_000
export const LEGACY_MIGRATION_RETRY_LIMIT = 3
export type LegacyListItem = {
readonly session?: string
readonly viewed: boolean
}
export type LegacyCarry = {
// Sessions the old list still had unread.
readonly unseen: ReadonlySet<string>
// When this client first found the list. Sessions that went idle later are new, whatever the list says.
readonly started: number
}
export type LegacyViewReport = {
readonly sessionID: string
readonly idle: number
}
// The background carry-over of the list Desktop kept before unread state moved to the server. `reported` keeps the
// watermarks it posted, so rows drawn from an older fetched copy of a session stay read after the list is deleted.
// `migrating` covers the delay before a run and the run itself.
export type LegacyMigrationState =
| { readonly status: "loading" }
| {
readonly status: "idle"
readonly carry: LegacyCarry
readonly reported: ReadonlyMap<string, number>
readonly attempt: number
}
| {
readonly status: "migrating"
readonly carry: LegacyCarry
readonly reported: ReadonlyMap<string, number>
readonly attempt: number
readonly failures: number
}
| { readonly status: "done"; readonly reported: ReadonlyMap<string, number> }
| { readonly status: "disposed" }
export type LegacyMigrationEvent =
| {
readonly type: "hydrated"
readonly list: readonly LegacyListItem[] | undefined
readonly started: number | undefined
readonly now: number
readonly connected: boolean
}
| { readonly type: "connection.changed"; readonly connected: boolean }
| { readonly type: "sessions.reported"; readonly reports: readonly LegacyViewReport[] }
| { readonly type: "run.succeeded"; readonly attempt: number }
| { readonly type: "run.failed"; readonly attempt: number }
| { readonly type: "disposed" }
export type LegacyMigrationEffect =
| { readonly type: "persist.started"; readonly started: number }
| { readonly type: "persist.remove" }
| { readonly type: "run"; readonly attempt: number; readonly delayMs: number }
| { readonly type: "run.cancel" }
export type LegacyMigrationTransition = {
readonly state: LegacyMigrationState
readonly effects: readonly LegacyMigrationEffect[]
}
export const INITIAL_LEGACY_MIGRATION_STATE: LegacyMigrationState = Object.freeze({ status: "loading" })
const EMPTY_REPORTED: ReadonlyMap<string, number> = new Map()
export function legacyRetryDelay(failures: number) {
return Math.min(LEGACY_MIGRATION_DELAY * 2 ** (failures - 1), LEGACY_MIGRATION_RETRY_MAX_DELAY)
}
export function transitionLegacyMigration(
state: LegacyMigrationState,
event: LegacyMigrationEvent,
): LegacyMigrationTransition {
if (state.status === "disposed") return { state, effects: [] }
if (event.type === "disposed") {
return { state: { status: "disposed" }, effects: state.status === "migrating" ? [{ type: "run.cancel" }] : [] }
}
if (state.status === "loading") {
if (event.type !== "hydrated") return { state, effects: [] }
return hydrate(event)
}
if (event.type === "hydrated") return { state, effects: [] }
// A report the server saved stays recorded even when the run that made it was cancelled or failed. A run records
// each page's reports in one event, so unread readers re-run once per page rather than once per session.
if (event.type === "sessions.reported") {
const updates = event.reports.filter((report) => report.idle > (state.reported.get(report.sessionID) ?? -Infinity))
if (updates.length === 0) return { state, effects: [] }
const reported = new Map(state.reported)
updates.forEach((report) =>
reported.set(report.sessionID, Math.max(report.idle, reported.get(report.sessionID) ?? -Infinity)),
)
return { state: { ...state, reported }, effects: [] }
}
if (state.status === "done") return { state, effects: [] }
if (event.type === "connection.changed") {
if (event.connected && state.status === "idle") return migrate(state, state.attempt + 1, 0, LEGACY_MIGRATION_DELAY)
if (!event.connected && state.status === "migrating") {
return {
state: { status: "idle", carry: state.carry, reported: state.reported, attempt: state.attempt },
effects: [{ type: "run.cancel" }],
}
}
return { state, effects: [] }
}
if (state.status !== "migrating" || state.attempt !== event.attempt) return { state, effects: [] }
if (event.type === "run.succeeded") {
return { state: { status: "done", reported: state.reported }, effects: [{ type: "persist.remove" }] }
}
// After the last retry the list is kept, and the next connection tries again.
if (state.failures >= LEGACY_MIGRATION_RETRY_LIMIT) {
return {
state: { status: "idle", carry: state.carry, reported: state.reported, attempt: state.attempt },
effects: [],
}
}
const failures = state.failures + 1
return migrate(state, state.attempt + 1, failures, legacyRetryDelay(failures))
}
function hydrate(event: Extract<LegacyMigrationEvent, { type: "hydrated" }>): LegacyMigrationTransition {
if (!event.list) return { state: { status: "done", reported: EMPTY_REPORTED }, effects: [] }
const started = event.started ?? event.now
const state: LegacyMigrationState = {
status: "idle",
carry: {
unseen: new Set(event.list.flatMap((item) => (!item.viewed && item.session ? [item.session] : []))),
started,
},
reported: EMPTY_REPORTED,
attempt: 0,
}
const persist: LegacyMigrationEffect[] = event.started === undefined ? [{ type: "persist.started", started }] : []
if (!event.connected) return { state, effects: persist }
const next = migrate(state, 1, 0, LEGACY_MIGRATION_DELAY)
return { state: next.state, effects: [...persist, ...next.effects] }
}
function migrate(
state: Extract<LegacyMigrationState, { status: "idle" | "migrating" }>,
attempt: number,
failures: number,
delayMs: number,
): LegacyMigrationTransition {
return {
state: { status: "migrating", carry: state.carry, reported: state.reported, attempt, failures },
effects: [{ type: "run", attempt, delayMs }],
}
}
type SessionTime = Pick<SessionInfo["time"], "idle" | "viewed">
type UnreadSession = { readonly id: string; readonly time: SessionTime }
/** A session is unread on the server when its latest terminal execution is newer than the last one any client viewed. */
export function isSessionUnread(session?: { readonly time: SessionTime }) {
const time = session?.time
return time?.idle !== undefined && (time.viewed === undefined || time.idle > time.viewed)
}
/** Whether the session shows unread here, honouring the old local list until its viewed state reaches the server. */
export function selectSessionUnread(state: LegacyMigrationState, session?: UnreadSession) {
// Until the old list is read, a session it had read could flash unread.
if (state.status === "loading" || state.status === "disposed") return false
const idle = session?.time.idle
if (!session || idle === undefined || !isSessionUnread(session)) return false
if (idle <= (state.reported.get(session.id) ?? -Infinity)) return false
if (state.status === "done") return true
return state.carry.unseen.has(session.id) || idle > state.carry.started
}
/** Sessions on a fetched page that the server has unread but this client shows read: the carry-over reports these. */
export function selectLegacyHiddenReports(state: LegacyMigrationState, sessions: readonly UnreadSession[]) {
return sessions.flatMap((session) =>
session.time.idle !== undefined && isSessionUnread(session) && !selectSessionUnread(state, session)
? [{ sessionID: session.id, idle: session.time.idle }]
: [],
)
}
@@ -1,5 +1,4 @@
import { createEffect, createMemo, onCleanup, untrack } from "solid-js"
import { createStore } from "solid-js/store"
import { createEffect, createMemo, createSignal, onCleanup, untrack } from "solid-js"
import { Schema } from "effect"
import { isSessionNotFoundError, type SessionInfo } from "@opencode/client/promise"
import type { ServerSDK } from "@/runtime/server/client"
@@ -14,6 +13,19 @@ import type { createNotificationCoordinator } from "@/shell/notifications/coordi
import { ServerConnection } from "@/runtime/server/registry"
import { sessionIDHasOpenTab, useTabs } from "@/shell/tabs/tabs"
import { useServer } from "@/runtime/server/current"
import {
INITIAL_LEGACY_MIGRATION_STATE,
INITIAL_VIEW_REPORT_STATE,
isSessionUnread,
selectLegacyHiddenReports,
selectSessionUnread,
transitionLegacyMigration,
transitionViewReport,
type LegacyMigrationEvent,
type LegacyViewReport,
type ViewReportEvent,
type ViewReportState,
} from "@/shell/notifications/machine"
type NotificationTabs = Pick<ReturnType<typeof useTabs>, "addSessionTab" | "rememberSessionRoute" | "select">
@@ -45,13 +57,6 @@ function hasRunningChild(data: Data, sessionID: string) {
)
}
/** A session is unread when its latest terminal execution is newer than the last one any client viewed. */
function isSessionUnread(session?: Pick<SessionInfo, "time">) {
const time = session?.time
return time?.idle !== undefined && (time.viewed === undefined || time.idle > time.viewed)
}
// The list Desktop kept before unread state moved to the server. Until its viewed state reaches the server, unread
// state still honours it, so sessions read here don't light up while the server catches up.
const LegacyNotificationStore = Persistence.struct({
@@ -62,17 +67,10 @@ const LegacyNotificationStore = Persistence.struct({
started: Schema.optional(Schema.Finite),
})
// The carry-over waits this long after connecting so it doesn't compete with startup requests.
const LEGACY_MIGRATION_DELAY = 5_000
const LEGACY_MIGRATION_PAGE = 200
const LEGACY_MIGRATION_CONCURRENCY = 4
const VIEW_RETRY_DELAY = 250
const VIEW_RETRY_MAX_DELAY = 5_000
export function createServerNotificationState(input: {
sdk: ServerSDK
data: Data
@@ -84,50 +82,100 @@ export function createServerNotificationState(input: {
const language = useLanguage()
const tabs = useTabs()
const disposed = { value: false }
// Idle watermarks already reported per root session, so reactive re-runs don't re-post them.
const acknowledged = new Map<string, number>()
// A failed view report re-runs the tracking caller with backoff, like the TUI.
const [state, setState] = createStore({ viewRetry: 0, legacyMigrated: false })
let viewRetryTimer: ReturnType<typeof setTimeout> | undefined
let viewRetryAttempt = 0
onCleanup(() => clearTimeout(viewRetryTimer))
const connected = createMemo(() => input.sdk.connection.status() === "connected")
// Per root session, so a failed report retries on its own whether or not a reactive caller is still viewing it.
const reports = new Map<string, ViewReportState>()
const reportTimers = new Map<string, ReturnType<typeof setTimeout>>()
const dispatchView = (root: string, event: ViewReportEvent) => {
const result = transitionViewReport(reports.get(root) ?? INITIAL_VIEW_REPORT_STATE, event)
reports.set(root, result.state)
result.effects.forEach((effect) => {
if (effect.type === "forget") {
input.data.session.forget(root)
return
}
clearTimeout(reportTimers.get(root))
reportTimers.delete(root)
if (effect.type === "send.cancel") return
if (effect.delayMs === 0) {
sendView(root, effect)
return
}
reportTimers.set(
root,
setTimeout(() => {
reportTimers.delete(root)
sendView(root, effect)
}, effect.delayMs),
)
})
}
const sendView = (root: string, effect: { idle: number; attempt: number }) =>
void input.sdk.api.session.view({ sessionID: root, idle: effect.idle }).then(
() => dispatchView(root, { type: "report.succeeded", attempt: effect.attempt }),
(error) =>
dispatchView(root, { type: "report.failed", attempt: effect.attempt, notFound: isSessionNotFoundError(error) }),
)
const legacyTarget = Persist.serverGlobal(input.sdk.scope, "notification")
const [legacy, setLegacy, , legacyReady] = persisted(legacyTarget, LegacyNotificationStore, {}, platform)
const started = Date.now()
const legacyStarted = () => legacy.started ?? started
const [legacyState, setLegacyState] = createSignal(INITIAL_LEGACY_MIGRATION_STATE)
const discovered = Date.now()
let legacyRun: AbortController | undefined
// Sessions the old list still had unread, while its viewed state hasn't reached the server yet.
const legacyUnseen = createMemo(() => {
const list = legacy.list
const dispatchLegacy = (event: LegacyMigrationEvent) => {
const previous = untrack(legacyState)
const result = transitionLegacyMigration(previous, event)
if (!list || state.legacyMigrated) return
if (result.state !== previous) setLegacyState(result.state)
result.effects.forEach((effect) => {
if (effect.type === "persist.started") {
setLegacy("started", effect.started)
return new Set(list.flatMap((item) => (!item.viewed && item.session ? [item.session] : [])))
})
return
}
// Idle watermarks the carry-over reported, so rows drawn from an older fetched copy of a session stay read.
const legacyReported = new Map<string, number>()
if (effect.type === "persist.remove") {
removePersisted(legacyTarget, platform)
const unread = (session?: Pick<SessionInfo, "id" | "time">) => {
const idle = session?.time.idle
return
}
// Until the old list is read, a session it had read could flash unread.
if (!legacyReady() || !session || idle === undefined || !isSessionUnread(session)) return false
legacyRun?.abort()
legacyRun = undefined
if (idle <= (legacyReported.get(session.id) ?? -Infinity)) return false
const unseen = legacyUnseen()
if (effect.type === "run.cancel") return
return !unseen || unseen.has(session.id) || idle > legacyStarted()
const controller = new AbortController()
const timer = setTimeout(
() =>
void migrateLegacy(controller.signal).then(
() => dispatchLegacy({ type: "run.succeeded", attempt: effect.attempt }),
() => dispatchLegacy({ type: "run.failed", attempt: effect.attempt }),
),
effect.delayMs,
)
controller.signal.addEventListener("abort", () => clearTimeout(timer))
legacyRun = controller
})
}
// Carry the old list's viewed state to the server in the background: page through every root session and report
// the ones the server has unread but this client shows read. Then delete the list. A failure keeps it, and the
// next connection retries; reports already made are skipped because the server then has them read.
let legacyMigration: "idle" | "scheduled" | "running" = "idle"
const migrateLegacy = async () => {
legacyMigration = "running"
// the ones the server has unread but this client shows read. Then delete the list. Reports already made are
// skipped on a retry because the server then has them read.
const migrateLegacy = async (signal: AbortSignal) => {
let cursor: string | undefined
for (;;) {
@@ -138,54 +186,63 @@ export function createServerNotificationState(input: {
cursor,
})
const hidden = page.data.flatMap((session) =>
session.time.idle !== undefined && isSessionUnread(session) && !unread(session)
? [{ sessionID: session.id, idle: session.time.idle }]
: [],
)
const hidden = selectLegacyHiddenReports(untrack(legacyState), page.data)
const settled: PromiseSettledResult<LegacyViewReport>[] = []
for (let index = 0; index < hidden.length; index += LEGACY_MIGRATION_CONCURRENCY) {
if (disposed.value) return
if (signal.aborted || settled.some((result) => result.status === "rejected")) break
await Promise.all(
hidden.slice(index, index + LEGACY_MIGRATION_CONCURRENCY).map(async (report) => {
await input.sdk.api.session.view(report)
legacyReported.set(report.sessionID, report.idle)
}),
settled.push(
...(await Promise.allSettled(
hidden
.slice(index, index + LEGACY_MIGRATION_CONCURRENCY)
.map((report) => input.sdk.api.session.view(report).then(() => report)),
)),
)
}
if (page.data.length === 0 || !page.cursor.next) break
dispatchLegacy({
type: "sessions.reported",
reports: settled.flatMap((result) => (result.status === "fulfilled" ? [result.value] : [])),
})
const failure = settled.find((result): result is PromiseRejectedResult => result.status === "rejected")
if (failure) throw failure.reason
if (signal.aborted || page.data.length === 0 || !page.cursor.next) return
cursor = page.cursor.next
}
removePersisted(legacyTarget, platform)
setState("legacyMigrated", true)
}
createEffect(() => {
if (!legacyReady() || !legacyUnseen()) return
if (untrack(() => legacy.started) === undefined) setLegacy("started", started)
if (input.sdk.connection.status() !== "connected" || legacyMigration !== "idle") return
legacyMigration = "scheduled"
const timer = setTimeout(
() =>
void migrateLegacy().catch(() => {
legacyMigration = "idle"
}),
LEGACY_MIGRATION_DELAY,
const hydrateLegacy = () =>
untrack(() =>
dispatchLegacy({
type: "hydrated",
list: legacy.list,
started: legacy.started,
now: discovered,
connected: connected(),
}),
)
onCleanup(() => {
clearTimeout(timer)
// localStorage reads the old list at once; hydrate now so unread state is right before the first effect runs.
if (untrack(legacyReady)) hydrateLegacy()
if (legacyMigration === "scheduled") legacyMigration = "idle"
})
createEffect(() => {
if (legacyReady()) hydrateLegacy()
})
createEffect(() => {
const online = connected()
dispatchLegacy({ type: "connection.changed", connected: online })
if (online) reports.forEach((_, root) => dispatchView(root, { type: "connected" }))
})
const unread = (session?: Pick<SessionInfo, "id" | "time">) => selectSessionUnread(legacyState(), session)
const roots = (directory: string) =>
input.data.session
.list()
@@ -195,40 +252,12 @@ export function createServerNotificationState(input: {
)
const view = (sessionID: string) => {
void state.viewRetry
const root = input.data.session.root(sessionID)
const session = input.data.session.get(root)
const idle = session?.time.idle
if (idle === undefined || !isSessionUnread(session) || acknowledged.get(root) === idle) return
acknowledged.set(root, idle)
void input.sdk.api.session.view({ sessionID: root, idle }).then(
() => {
clearTimeout(viewRetryTimer)
viewRetryTimer = undefined
viewRetryAttempt = 0
},
(error) => {
if (isSessionNotFoundError(error)) {
acknowledged.delete(root)
input.data.session.forget(root)
return
}
if (acknowledged.get(root) !== idle) return
acknowledged.delete(root)
if (viewRetryTimer) return
const delay = Math.min(VIEW_RETRY_DELAY * 2 ** viewRetryAttempt, VIEW_RETRY_MAX_DELAY)
viewRetryAttempt++
viewRetryTimer = setTimeout(() => {
viewRetryTimer = undefined
setState("viewRetry", (value) => value + 1)
}, delay)
},
)
if (idle === undefined || !isSessionUnread(session)) return
dispatchView(root, { type: "view", idle })
}
// Loading the session keeps a background completion visible in the server-derived unread state.
@@ -367,6 +396,8 @@ export function createServerNotificationState(input: {
onCleanup(() => {
disposed.value = true
unsub()
dispatchLegacy({ type: "disposed" })
reports.forEach((_, root) => dispatchView(root, { type: "disposed" }))
})
return {
@@ -166,6 +166,7 @@ test.each(
createState({
sdk: {
scope: ServerScope.local,
connection: { status: () => "connected" },
event: {
listen: (listener: (event: OpenCodeEvent) => void) => {
listeners.push(listener)
@@ -264,6 +265,7 @@ test.each([
createState({
sdk: {
scope: ServerScope.local,
connection: { status: () => "connected" },
event: {
listen: (listener: (event: OpenCodeEvent) => void) => {
listeners.push(listener)
@@ -315,6 +317,7 @@ test("unread state and viewing follow the server's idle and viewed watermarks",
const state = createState({
sdk: {
scope: ServerScope.local,
connection: { status: () => "connected" },
event: { listen: () => () => {} },
api: {
session: {
@@ -368,11 +371,21 @@ test("unread state and viewing follow the server's idle and viewed watermarks",
setStore("sessions", "root", "time", "idle", 6)
expect(state.session.unread("root")).toBe(true)
state.project.markViewed("/project")
expect(views.slice(2)).toEqual([{ sessionID: "root", idle: 6 }])
// Menu and Inbox actions mark sessions viewed from event handlers, with nothing to re-run them: a failed report
// still retries on its own, and a sibling's success does not cancel that retry.
setStore("viewing", undefined)
setStore("sessions", "root", "time", "idle", 8)
failures.remaining = 1
state.project.markViewed("/project")
state.project.markViewed("/other")
expect(views.slice(2)).toEqual([
{ sessionID: "root", idle: 6 },
expect(views.slice(3)).toEqual([
{ sessionID: "root", idle: 8 },
{ sessionID: "other", idle: 4 },
])
await new Promise((resolve) => setTimeout(resolve, 300))
expect(views.slice(5)).toEqual([{ sessionID: "root", idle: 8 }])
dispose.dispose()
})