Bohdan Triapitsyn
85400459e9
Improve OpenChamber responsiveness under large session workloads while fixing cache, synchronization, and persistence correctness across runtimes, projects, directories, and worktrees. - prioritize selected and visible sessions during bootstrap and defer non-critical enrichment work - reduce redundant message loading, event processing, store publication, and hidden sidebar work - prevent stale session and message requests from overwriting newer authoritative state - preserve existing data when authoritative fetches fail instead of treating failures as successful empty responses - scope session materialization, messages, drafts, queues, todos, pins, permissions, folders, tabs, Git state, and pull request data by runtime and directory identity - harden runtime switching, reconnect, cleanup, mutation reconciliation, and persisted-state ordering - preserve live subagent Task linkage when metadata arrives after an older message request or while streaming parts are suspended - coalesce overlapping tail refreshes without losing newer refresh demand - improve cold-session loading by moving deferrable work out of the critical bootstrap path - isolate URL authentication, mobile credentials, native secrets, and other runtime-owned state across endpoint changes - bound long-lived caches and remove avoidable allocations from event and rendering hot paths - limit virtualization to archive collections where it improves rendering without disrupting active sidebar layout - stabilize session folders, pin ordering, expanded state, and persisted sidebar behavior - open skill files through the same secure editor and outside-workspace grant flow used by file navigation, including worktree sessions - expand regression coverage for stale completions, runtime collisions, reconnect behavior, persistence races, authoritative empty results, and subagent refresh ordering - document the updated synchronization, cache ownership, performance, and runtime-isolation invariants
112 lines
3.5 KiB
TypeScript
112 lines
3.5 KiB
TypeScript
import { describe, expect, test } from "bun:test"
|
|
import type { OpencodeClient, Project } from "@opencode-ai/sdk/v2/client"
|
|
import { bootstrapDirectory } from "./bootstrap"
|
|
import { INITIAL_STATE, type State } from "./types"
|
|
|
|
const createSdk = (options?: { commandList?: () => Promise<{ data: unknown[] }> }) => ({
|
|
project: { current: async () => ({ data: { id: "project-a" } }) },
|
|
config: { get: async () => ({ data: {} }) },
|
|
path: { get: async () => ({ data: { state: "", config: "", worktree: "/repo", directory: "/repo", home: "/home" } }) },
|
|
session: { status: async () => ({ data: {} }) },
|
|
command: { list: options?.commandList ?? (async () => ({ data: [] })) },
|
|
mcp: { status: async () => ({ data: {} }) },
|
|
lsp: { status: async () => ({ data: [] }) },
|
|
vcs: { get: async () => ({ data: { branch: "main" } }) },
|
|
question: { list: async () => ({ data: [] }) },
|
|
permission: { list: async () => ({ data: [] }) },
|
|
}) as unknown as OpencodeClient
|
|
|
|
const createState = (): State => ({
|
|
...INITIAL_STATE,
|
|
message: {},
|
|
part: {},
|
|
})
|
|
|
|
const project = { id: "project-a", worktree: "/repo" } as Project
|
|
|
|
describe("bootstrapDirectory", () => {
|
|
test("prioritizes session loading without waiting for deferred fields", async () => {
|
|
let state = createState()
|
|
let deferredStarted = false
|
|
let resolveDeferred!: () => void
|
|
const deferred = new Promise<{ data: unknown[] }>((resolve) => {
|
|
resolveDeferred = () => resolve({ data: [] })
|
|
})
|
|
let resolveSessions!: () => void
|
|
const sessions = new Promise<void>((resolve) => {
|
|
resolveSessions = resolve
|
|
})
|
|
let settled = false
|
|
const sdk = createSdk({
|
|
commandList: async () => {
|
|
deferredStarted = true
|
|
return deferred
|
|
},
|
|
})
|
|
const bootstrapping = bootstrapDirectory({
|
|
directory: "/repo",
|
|
sdk,
|
|
getState: () => state,
|
|
set: (patch) => {
|
|
state = { ...state, ...patch }
|
|
},
|
|
global: { config: {}, projects: [project] },
|
|
loadSessions: () => sessions,
|
|
}).then((result) => {
|
|
settled = true
|
|
return result
|
|
})
|
|
|
|
await Promise.resolve()
|
|
await Promise.resolve()
|
|
expect(settled).toBe(false)
|
|
expect(deferredStarted).toBe(false)
|
|
resolveSessions()
|
|
|
|
expect(await bootstrapping).toBe("complete")
|
|
expect(state.status).toBe("complete")
|
|
expect(deferredStarted).toBe(false)
|
|
await new Promise((resolve) => setTimeout(resolve, 0))
|
|
expect(deferredStarted).toBe(true)
|
|
resolveDeferred()
|
|
})
|
|
|
|
test("reports session-list failure without clearing existing state", async () => {
|
|
let state = { ...createState(), session: [{ id: "cached" }] as State["session"] }
|
|
const result = await bootstrapDirectory({
|
|
directory: "/repo",
|
|
sdk: createSdk(),
|
|
getState: () => state,
|
|
set: (patch) => {
|
|
state = { ...state, ...patch }
|
|
},
|
|
global: { config: {}, projects: [project] },
|
|
loadSessions: async () => {
|
|
throw new Error("unavailable")
|
|
},
|
|
})
|
|
|
|
expect(result).toBe("failed")
|
|
expect(state.session.map((session) => session.id)).toEqual(["cached"])
|
|
})
|
|
|
|
test("rejects stale work before committing", async () => {
|
|
const state = createState()
|
|
let commits = 0
|
|
const result = await bootstrapDirectory({
|
|
directory: "/repo",
|
|
sdk: createSdk(),
|
|
getState: () => state,
|
|
set: () => {
|
|
commits += 1
|
|
},
|
|
isStale: () => true,
|
|
global: { config: {}, projects: [project] },
|
|
loadSessions: async () => undefined,
|
|
})
|
|
|
|
expect(result).toBe("stale")
|
|
expect(commits).toBe(0)
|
|
})
|
|
})
|