Something went wrong. Try again.
opencode v2 mirror
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736import { expect, test } from "bun:test"import { getEventListeners } from "node:events"import { createRoot } from "solid-js"import { createData, type CreateDataInput } from "../src/solid"import { OpenCode, type OpenCodeEvent, type Project, type SessionInfo } from "../src/promise"
const session = (viewed: number): SessionInfo => ({ id: "ses_refresh", projectID: "project", cost: 0, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, outcome: "succeeded", time: { created: 0, updated: 0, idle: 2, viewed }, location: { directory: "/project" },})
test("revalidates after an event overtakes an active session read", async () => { let release!: () => void const gate = new Promise<void>((resolve) => (release = resolve)) const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>() let requests = 0 const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async (input, init) => { const request = input instanceof Request ? input : new Request(input, init) if (!request.url.endsWith("/api/session/ses_refresh")) throw new Error(`Unexpected request: ${request.url}`) requests++ if (requests === 1) { await gate return Response.json({ data: session(1) }) } return Response.json({ data: session(2) }) }, }) const event: CreateDataInput["event"] = { on: <Type extends OpenCodeEvent["type"]>( _type: Type, _handler: (event: Extract<OpenCodeEvent, { type: Type }>) => void, ) => () => {}, listen(handler) { listeners.add(handler) return () => listeners.delete(handler) }, } const setup = createRoot((dispose) => ({ data: createData({ api: () => api, directory: "/project", event, connection: { status: () => "connected" } }), dispose, }))
try { setup.data.session.remember(session(1)) setup.data.session.invalidate("ses_refresh") const initial = setup.data.session.sync("ses_refresh") await wait(() => requests === 1)
const viewed: OpenCodeEvent = { id: "evt_viewed", created: 2, type: "session.viewed", durable: { aggregateID: "ses_refresh", seq: 1, version: 1 }, data: { sessionID: "ses_refresh", idle: 2 }, } listeners.forEach((listener) => listener({ name: viewed.type, details: viewed })) await Bun.sleep(20) release() await initial
await wait(() => requests === 2 && setup.data.session.get("ses_refresh")?.time.viewed === 2) } finally { setup.dispose() }})
test("updates authoritative cached project metadata from live events", async () => { const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>() const original: Project = { id: "project_renamed", canonical: "/projects/original", name: "Original custom name", time: { created: 1, updated: 1 }, sandboxes: [], } const unrelated: Project = { id: "project_unrelated", canonical: "/projects/unrelated", name: "Unrelated project", time: { created: 1, updated: 1 }, sandboxes: [], } let requests = 0 const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async (input, init) => { const request = input instanceof Request ? input : new Request(input, init) if (!request.url.endsWith("/api/project")) throw new Error(`Unexpected request: ${request.url}`) requests++ return Response.json([original, unrelated]) }, }) const event: CreateDataInput["event"] = { on: () => () => {}, listen(handler) { listeners.add(handler) return () => listeners.delete(handler) }, } const setup = createRoot((dispose) => ({ data: createData({ api: () => api, directory: "/projects/original", event }), dispose, }))
try { await setup.data.project.sync() expect(setup.data.project.get(original.id)).toEqual(original)
const updated: OpenCodeEvent = { id: "evt_project_renamed", created: 2, type: "project.updated", data: { ...original, canonical: "/projects/renamed", name: "Updated custom name", time: { ...original.time, updated: 2 }, }, } listeners.forEach((listener) => listener({ name: updated.type, details: updated }))
expect(setup.data.project.get(original.id)?.canonical).toBe("/projects/renamed") expect(setup.data.project.get(original.id)?.name).toBe("Updated custom name") expect(setup.data.project.get(unrelated.id)).toEqual(unrelated) expect(requests).toBe(1)
const reset: OpenCodeEvent = { id: "evt_project_name_reset", created: 3, type: "project.updated", data: { id: original.id, canonical: "/projects/renamed-again", time: { ...original.time, updated: 3 }, sandboxes: [], }, } listeners.forEach((listener) => listener({ name: reset.type, details: reset }))
expect(setup.data.project.get(original.id)?.canonical).toBe("/projects/renamed-again") expect(setup.data.project.get(original.id)?.name).toBeUndefined() expect(setup.data.project.get(unrelated.id)).toEqual(unrelated) expect(requests).toBe(1) } finally { setup.dispose() }})
test("adopts cached directory-project sessions when their repository is resolved", async () => { const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>() const refreshed: SessionInfo = { ...session(0), id: "ses_uncached", projectID: "repository", location: { directory: "/unknown-alias" }, subpath: "app", } const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async (input, init) => { const request = input instanceof Request ? input : new Request(input, init) if (!request.url.endsWith("/api/session/ses_uncached")) throw new Error(`Unexpected request: ${request.url}`) return Response.json({ data: refreshed }) }, }) const setup = createRoot((dispose) => ({ data: createData({ api: () => api, directory: "/repo", event: { on: () => () => {}, listen(handler) { listeners.add(handler) return () => listeners.delete(handler) }, }, }), dispose, }))
try { const sessions: SessionInfo[] = [ { ...session(0), id: "ses_root", projectID: "directory-root", location: { directory: "/repo" } }, { ...session(0), id: "ses_nested", projectID: "directory-nested", location: { directory: "/repo/app" } }, { ...session(0), id: "ses_alias", projectID: "directory-nested", location: { directory: "/repo/alias/../app" }, }, { ...session(0), id: "ses_symlink", projectID: "directory-nested", location: { directory: "/shortcut" } }, { ...refreshed, projectID: "directory-uncached" }, { ...session(0), id: "ses_global", projectID: "global", location: { directory: "/repo/legacy" } }, { ...session(0), id: "ses_escaped", projectID: "global", location: { directory: "/repo/../other" } }, { ...session(0), id: "ses_other", projectID: "other-repository", location: { directory: "/repo/vendor" } }, { ...session(0), id: "ses_sibling", projectID: "global", location: { directory: "/repo-other" } }, { ...session(0), id: "ses_remote", projectID: "directory-root", location: { directory: "/repo", workspaceID: "workspace-remote" }, }, ] sessions.forEach((item) => setup.data.session.remember(item)) for (const project of [ { id: "directory-root", canonical: "/repo" }, { id: "directory-nested", canonical: "/repo/app" }, ]) { const updated: OpenCodeEvent = { id: `evt_${project.id}`, created: 0, type: "project.updated", data: { ...project, time: { created: 0, updated: 0 }, sandboxes: [] }, } listeners.forEach((listener) => listener({ name: updated.type, details: updated })) }
const resolved: OpenCodeEvent = { id: "evt_repository_resolved", created: 1, type: "worktree.resolved", durable: { aggregateID: "repository", seq: 0, version: 1 }, data: { projectID: "repository", directory: "/repo", previous: "global", adopted: ["directory-root", "directory-nested", "directory-uncached"], }, } listeners.forEach((listener) => listener({ name: resolved.type, details: resolved }))
expect(setup.data.session.get("ses_root")?.projectID).toBe("repository") expect(setup.data.session.get("ses_root")?.subpath).toBeUndefined() expect(setup.data.session.get("ses_nested")).toMatchObject({ projectID: "repository", subpath: "app" }) expect(setup.data.session.get("ses_alias")).toMatchObject({ projectID: "repository", subpath: "app" }) expect(setup.data.session.get("ses_symlink")).toMatchObject({ projectID: "repository", subpath: "app" }) expect(setup.data.session.get("ses_global")).toMatchObject({ projectID: "repository", subpath: "legacy" }) expect(setup.data.session.get("ses_escaped")?.projectID).toBe("global") expect(setup.data.session.get("ses_other")?.projectID).toBe("other-repository") expect(setup.data.session.get("ses_sibling")?.projectID).toBe("global") expect(setup.data.session.get("ses_remote")?.projectID).toBe("directory-root") await wait(() => setup.data.session.get("ses_uncached")?.projectID === "repository") expect(setup.data.session.get("ses_uncached")?.subpath).toBe("app") } finally { setup.dispose() }})
test("refreshes global credential events across every loaded location and workspace", async () => { const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>() const requests: URL[] = [] const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async (input, init) => { const request = input instanceof Request ? input : new Request(input, init) const url = new URL(request.url) requests.push(url) const directory = url.searchParams.get("location[directory]") ?? "/project" return Response.json({ location: { directory, workspaceID: url.searchParams.get("location[workspace]") ?? undefined, project: { id: "project", directory, canonical: directory }, }, data: [], }) }, }) const setup = createRoot((dispose) => ({ data: createData({ api: () => api, directory: "/project", event: { on: () => () => {}, listen(handler) { listeners.add(handler) return () => listeners.delete(handler) }, }, connection: { status: () => "connected" }, }), dispose, })) const locations = [{ directory: "/project" }, { directory: "/other", workspaceID: "workspace-other" }]
try { await Promise.all( locations.flatMap((location) => [ setup.data.location.integration.sync(location), setup.data.location.model.sync(location), setup.data.location.provider.sync(location), ]), ) requests.length = 0
const updated: OpenCodeEvent = { id: "evt_credential.updated", created: 1, type: "credential.updated", data: {}, } listeners.forEach((listener) => listener({ name: updated.type, details: updated })) await wait(() => requests.length === 2) expect( requests.map((url) => [ url.pathname, url.searchParams.get("location[directory]"), url.searchParams.get("location[workspace]"), ]), ).toEqual([ ["/api/integration", "/project", null], ["/api/integration", "/other", "workspace-other"], ]) requests.length = 0
for (const credentialID of ["credential", null]) { const switched: OpenCodeEvent = { id: `evt_credential.switched.${credentialID}`, created: 2, type: "credential.switched", data: { credentialID, integrationID: "integration" }, } listeners.forEach((listener) => listener({ name: switched.type, details: switched })) await wait(() => requests.length === 4) expect( requests.map((url) => [ url.pathname, url.searchParams.get("location[directory]"), url.searchParams.get("location[workspace]"), ]), ).toEqual( expect.arrayContaining([ ["/api/model", "/project", null], ["/api/provider", "/project", null], ["/api/model", "/other", "workspace-other"], ["/api/provider", "/other", "workspace-other"], ]), ) requests.length = 0 } } finally { setup.dispose() }})
test("reports optimistic sessions as creating until the request settles", async () => { const release = Promise.withResolvers<void>() const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async (input, init) => { const request = input instanceof Request ? input : new Request(input, init) if (!request.url.endsWith("/api/session")) throw new Error(`Unexpected request: ${request.url}`) await release.promise return Response.json({ data: session(0) }) }, }) const event: CreateDataInput["event"] = { on: () => () => {}, listen: () => () => {}, } const setup = createRoot((dispose) => ({ data: createData({ api: () => api, directory: "/project", event, connection: { status: () => "connected" } }), dispose, }))
try { const created = setup.data.session.create({ id: "ses_refresh", location: { directory: "/project" } }) expect(setup.data.session.creating(created.id)).toBe(true) release.resolve() await created.request expect(setup.data.session.creating(created.id)).toBe(false) } finally { setup.dispose() }})
test("loads bounded message pages", async () => { const requests: URL[] = [] const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async (input, init) => { const request = input instanceof Request ? input : new Request(input, init) const url = new URL(request.url) requests.push(url) return Response.json({ data: [], cursor: requests.length === 1 ? { next: "next" } : {} }) }, }) const setup = createRoot((dispose) => ({ data: createData({ api: () => api, directory: "/project", event: { on: () => () => {}, listen: () => () => {} }, }), dispose, }))
try { await setup.data.session.message.sync("ses_refresh") await setup.data.session.message.loadMore("ses_refresh")
expect(requests).toHaveLength(2) expect(Object.fromEntries(requests[0].searchParams)).toEqual({ limit: "20", order: "desc" }) expect(Object.fromEntries(requests[1].searchParams)).toEqual({ cursor: "next", limit: "20" }) } finally { setup.dispose() }})
test.each(["success", "failure", "cancel", "cancel-retry", "cancel-page", "join-cancel", "join-failure"])( "bulk history (%s)", async (mode) => { const messages = [1, 2, 3].map((index) => ({ id: `msg_${index}`, type: "user", text: `Message ${index}`, time: { created: index }, })) const release = Promise.withResolvers<void>() const controller = new AbortController() const requests: URL[] = [] const publications: string[][] = [] const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async (input, init) => { const url = new URL(input instanceof Request ? input.url : String(input)) requests.push(url) const cursor = url.searchParams.get("cursor") if (!cursor) return Response.json({ data: [messages[2]], cursor: { next: "recent" } }) if (cursor === "recent") { if (mode.startsWith("join")) await release.promise if (mode === "join-failure") return Response.json({ message: "offline" }, { status: 503 }) return Response.json({ data: [messages[2], messages[1]], cursor: { next: "oldest" } }) } if (cursor === "oldest") return Response.json({ data: [messages[0]], cursor: { next: "empty" } }) expect(init?.signal).toBe(requests.length === 4 ? controller.signal : undefined) await release.promise if (mode === "failure") return Response.json({ message: "offline" }, { status: 503 }) return Response.json({ data: [], cursor: {} }) }, }) const setup = createRoot((dispose) => { const data = createData({ api: () => api, directory: "/project", event: { on: () => () => {}, listen: () => () => {} }, }) return { data, dispose } })
try { await setup.data.session.message.sync("ses_refresh") const newest = setup.data.session.message.get("ses_refresh", "msg_3") const load = setup.data.session.message.loadMore( "ses_refresh", mode.startsWith("join") ? undefined : { all: true, signal: controller.signal, beforePublish: () => { publications.push(setup.data.session.message.list("ses_refresh").map((message) => message.id)) expect(setup.data.session.message.get("ses_refresh", "msg_3")).toBe(newest) }, }, ) const joined = setup.data.session.message.loadMore("ses_refresh", { all: true, signal: controller.signal }) const settled = Promise.allSettled([load, joined]) if (mode.startsWith("join")) { await wait(() => requests.length === 2) expect(getEventListeners(controller.signal, "abort")).toHaveLength(1) controller.abort() let cancelled = false void joined.then(() => { cancelled = true }) await wait(() => cancelled) expect(setup.data.session.message.loading("ses_refresh")).toBe(true) expect(getEventListeners(controller.signal, "abort")).toHaveLength(0) release.resolve() expect((await settled).map((result) => result.status)).toEqual( mode === "join-failure" ? ["rejected", "fulfilled"] : ["fulfilled", "fulfilled"], ) expect(requests.at(-1)?.searchParams.get("limit")).toBe("20") expect(requests).toHaveLength(2) expect(setup.data.session.message.more("ses_refresh")).toBe(true) expect(setup.data.session.message.list("ses_refresh").map((message) => message.id)).toEqual( mode === "join-failure" ? ["msg_3"] : ["msg_2", "msg_3"], ) return } await wait(() => requests.length === 4) expect(setup.data.session.message.loading("ses_refresh")).toBe(true) expect(setup.data.session.message.list("ses_refresh").map((message) => message.id)).toEqual(["msg_3"]) expect(requests.slice(1).map((url) => url.searchParams.get("limit"))).toEqual(["200", "200", "200"]) if (mode.startsWith("cancel")) controller.abort() const retry = mode === "cancel-retry" || mode === "cancel-page" ? setup.data.session.message.loadMore("ses_refresh", mode === "cancel-retry" ? { all: true } : undefined) : undefined release.resolve() expect((await settled).map((result) => result.status)).toEqual( mode === "failure" ? ["rejected", "rejected"] : ["fulfilled", "fulfilled"], ) await retry const success = mode === "success" || mode === "cancel-retry" expect(setup.data.session.message.loading("ses_refresh")).toBe(false) expect(setup.data.session.message.more("ses_refresh")).toBe(!success) expect(setup.data.session.message.list("ses_refresh").map((message) => message.id)).toEqual( success ? ["msg_1", "msg_2", "msg_3"] : mode === "cancel-page" ? ["msg_2", "msg_3"] : ["msg_3"], ) expect(setup.data.session.message.get("ses_refresh", "msg_3")).toBe(newest) expect(requests).toHaveLength(mode === "cancel-retry" ? 7 : mode === "cancel-page" ? 5 : 4) if (mode === "cancel-page") expect(requests.at(-1)?.searchParams.get("limit")).toBe("20") expect(publications).toEqual(mode === "success" ? [["msg_3"]] : []) expect(getEventListeners(controller.signal, "abort")).toHaveLength(0) } finally { release.resolve() setup.dispose() } },)
test("preserves assistant content replacement events across an active message read", async () => { const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>() const release = Promise.withResolvers<void>() let requests = 0 const content = [ { type: "text" as const, text: "replacement" }, { type: "reasoning" as const, text: "reasoning", time: { created: 3 } }, ] const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async () => { const current = ++requests if (current === 2) await release.promise return Response.json({ data: [ { id: "msg_assistant", type: "assistant", agent: "build", model: { id: "model", providerID: "provider" }, content: current === 3 ? content : [{ type: "text", text: "original" }], time: { created: 1, completed: 2 }, }, ], cursor: {}, }) }, }) const setup = createRoot((dispose) => ({ data: createData({ api: () => api, directory: "/project", event: { on: () => () => {}, listen(handler) { listeners.add(handler) return () => listeners.delete(handler) }, }, }), dispose, }))
try { await setup.data.session.message.sync("ses_refresh") setup.data.session.message.invalidate("ses_refresh") const stale = setup.data.session.message.sync("ses_refresh") await wait(() => requests === 2) const updated: OpenCodeEvent = { id: "evt_message_updated", created: 3, type: "session.message.content.updated", durable: { aggregateID: "ses_refresh", seq: 3, version: 1 }, data: { sessionID: "ses_refresh", messageID: "msg_assistant", content, }, } listeners.forEach((listener) => listener({ name: updated.type, details: updated }))
expect(setup.data.session.message.list("ses_refresh")[0]).toMatchObject({ content }) release.resolve() await stale await wait(() => requests === 3) expect(setup.data.session.message.list("ses_refresh")[0]).toMatchObject({ content }) } finally { setup.dispose() }})
test.each([ "session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.execution.started", "session.deleted",] as const)("preserves %s activity when an older snapshot arrives", async (type) => { const release = Promise.withResolvers<void>() const requested = Promise.withResolvers<void>() const setup = activityFixture(async () => { requested.resolve() await release.promise return Response.json({ data: { ...(type === "session.execution.started" ? {} : { ses_refresh: { type: "running" } }), ses_hydrated: { type: "running" }, }, }) })
try { if (type !== "session.execution.started") setup.data.session.setStatus("ses_refresh", "running") setup.emit({ type: "server.connected", data: {} }) await requested.promise setup.emit({ id: "evt_activity", created: 2, type, durable: { aggregateID: "ses_refresh", seq: 2, version: 1 }, data: { sessionID: "ses_refresh", reason: "user" }, }) expect(setup.data.session.status("ses_refresh")).toBe(type === "session.execution.started" ? "running" : "idle") release.resolve() await wait(() => setup.data.session.status("ses_hydrated") === "running") expect(setup.data.session.status("ses_refresh")).toBe(type === "session.execution.started" ? "running" : "idle") } finally { release.resolve() setup.dispose() }})
test("ignores activity snapshots from an older connection", async () => { const reads: ReturnType<typeof Promise.withResolvers<Response>>[] = [] const setup = activityFixture(() => { const read = Promise.withResolvers<Response>() reads.push(read) return read.promise })
try { setup.emit({ type: "server.connected", data: {} }) await wait(() => reads.length === 1) setup.emit({ type: "server.connected", data: {} }) await wait(() => reads.length === 2) reads[1]?.resolve(Response.json({ data: { ses_new: { type: "running" } } })) await wait(() => setup.data.session.status("ses_new") === "running") reads[0]?.resolve(Response.json({ data: { ses_old: { type: "running" } } })) await Bun.sleep(20) expect(setup.data.session.status("ses_new")).toBe("running") expect(setup.data.session.status("ses_old")).toBe("idle") } finally { reads.forEach((read) => read.resolve(Response.json({ data: {} }))) setup.dispose() }})
test("projects background user shell metadata from durable shell data", () => { const setup = activityFixture(() => Response.json({ data: {} })) try { setup.emit({ id: "evt_user_shell", created: 1, type: "session.shell.started", durable: { aggregateID: "ses_refresh", seq: 1, version: 1 }, data: { sessionID: "ses_refresh", shell: { id: "sh_user", status: "running", command: "pwd", cwd: "/project", shell: "/bin/sh", file: "/project/shell.out", metadata: { sessionID: "ses_refresh", background: true }, time: { started: 1 }, }, }, }) expect(setup.data.session.message.list("ses_refresh")).toMatchObject([ { type: "shell", shellID: "sh_user", status: "running", metadata: { background: true } }, ]) } finally { setup.dispose() }})
function activityFixture(read: () => Response | Promise<Response>) { const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>() const api = OpenCode.make({ baseUrl: "http://opencode.local", fetch: async (input, init) => { const request = input instanceof Request ? input : new Request(input, init) const path = new URL(request.url).pathname if (path === "/api/session/active") return read() if (path === "/api/project") return Response.json([]) if (path === "/api/location") return Response.json({ directory: "/project" }) return Response.json({ location: { directory: "/project" }, data: { branch: "main" } }) }, }) return createRoot((dispose) => ({ data: createData({ api: () => api, directory: "/project", event: { on: () => () => {}, listen(handler) { listeners.add(handler) return () => listeners.delete(handler) }, }, }), emit: (details: OpenCodeEvent) => listeners.forEach((listener) => listener({ name: details.type, details })), dispose, }))}
async function wait(check: () => boolean) { const started = Date.now() while (!check()) { if (Date.now() - started > 2_000) throw new Error("Timed out waiting for condition") await Bun.sleep(10) }}