Can you create for me a sequence diagram, showing how the session state is persisted now through the sql database.
Show me how that now the agent and model information is persisted correctly even in the case that the messages from the agent are dropped, as would happen before the database layer.
Are there any ways the state can slip, or is there a tight persistence layer now supporting the session messages?
/home/jm/data/code/opencode/packages/web/src/session-ref-backup.md
/home/jm/data/code/opencode/packages/web/src/components/sessions-list.module.css
/home/jm/data/code/opencode/packages/cloudsession/src/views/session-list.tsx
/home/jm/data/code/opencode/packages/cloudsession/src/views/session-detail.tsx
/home/jm/data/code/opencode/packages/ui/src/components/session-turn.tsx
/home/jm/data/code/opencode/packages/ui/src/components/session-turn.css
/home/jm/data/code/opencode/packages/ui/src/components/session-review.tsx
/home/jm/data/code/opencode/packages/ui/src/components/session-review.css
/home/jm/data/code/opencode/packages/app/src/pages/session.tsx
/home/jm/data/code/opencode/packages/app/src/pages/session/composer/session-question-dock.tsx
/home/jm/data/code/opencode/packages/app/e2e/session/session.spec.ts
/home/jm/data/code/opencode/packages/app/src/components/session/session-header.tsx
/home/jm/data/code/opencode/packages/app/src/components/session/session-context-tab.tsx
/home/jm/data/code/opencode/specs/session-composer-refactor-plan.md
/home/jm/data/code/opencode/packages/opencode/src/acp/session.ts
/home/jm/data/code/opencode/packages/opencode/src/cli/cmd/session.ts
/home/jm/data/code/opencode/packages/app/src/pages/session/use-session-commands.tsx
/home/jm/data/code/opencode/packages/app/src/pages/session/session-side-panel.tsx
/home/jm/data/code/opencode/packages/app/src/pages/session/session-mobile-tabs.tsx
/home/jm/data/code/opencode/packages/app/src/pages/session/composer/session-todo-dock.tsx
/home/jm/data/code/opencode/packages/app/src/pages/session/composer/session-permission-dock.tsx
/home/jm/data/code/opencode/packages/app/src/pages/session/composer/session-composer-state.ts
/home/jm/data/code/opencode/packages/app/src/pages/session/composer/session-composer-region.tsx
/home/jm/data/code/opencode/packages/app/src/context/global-sync/session-load.ts
/home/jm/data/code/opencode/packages/app/e2e/session/session-composer-dock.spec.ts
/home/jm/data/co...Found 617 matches (showing first 100)
/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts:
Line 8: import { Database, eq } from "@/storage/db"
Line 97: Database.use((db) =>
Line 98: db
Line 112: const row = Database.use((db) =>
Line 113: db.select().from(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).get(),
Line 181: Database.use((db) => db.delete(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).run())
/home/jm/data/code/opencode/packages/opencode/src/server/server.ts:
Line 34: import { NotFoundError } from "../storage/db"
Line 44: // @ts-ignore This global is needed to prevent ai-sdk from logging warnings to stdout https://github.com/vercel/ai/blob/2dc67e0ef538307f21368db32d5a12345d98831b/packages/ai/src/logger/log-warnings.ts#L85
/home/jm/data/code/opencode/packages/console/core/drizzle.config.ts:
Line 2: import { defineConfig } from "drizzle-kit"
Line 10: dbCredentials: {
Line 11: database: Resource.Database.database,
/home/jm/data/code/opencode/github/index.ts:
Line 19: databaseId: string
Line 48: databaseId: string
Line 853: databaseId
Line 882: const id = parseInt(c.databaseId)
Line 950: databaseId
Line 961: databaseId
Line 971: databaseId
Line 1004: const id = parseInt(c.databaseId)
/home/jm/data/code/opencode/script/version.ts:
Line 17: const release = await $`gh release view v${Script.version} --json tagName,databaseId`.json()
Line 18: output.push(`release=${release.databaseId}`)
/home/jm/data/code/opencode/packages/opencode/src/session/index.ts:
Line 13: import { Database, NotFoundError, eq, and, or, gte, isNull, desc, like } from "../storage/db"
Line 254: Database.use((db) => {
Line 255: const row = db
Line 289: Database.use((db) => {
Line 290: db.insert(SessionTable).values(toRow(result)).run()
Line 316: const row = Dat...Found 258 matches (showing first 100)
/home/jm/data/code/opencode/packages/opencode/src/session/index.ts:
Line 684: model: z.custom<Provider.Model>(),
Line 720: input.model.api.npm === "@ai-sdk/anthropic" ||
Line 721: input.model.api.npm === "@ai-sdk/amazon-bedrock" ||
Line 722: input.model.api.npm === "@ai-sdk/google-vertex/anthropic"
Line 741: input.model.cost?.experimentalOver200K && tokens.input + tokens.cache.read > 200_000
Line 742: ? input.model.cost.experimentalOver200K
Line 743: : input.model.cost
Line 751: // TODO: update models.dev to have better pricing model, for now:
Line 770: modelID: z.string(),
Line 778: model: input.providerID + "/" + input.modelID,
/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts:
Line 11: import { Agent } from "../agent/agent"
Line 94: model: z
Line 97: modelID: z.string(),
Line 100: agent: z.string().optional(),
Line 207: const agent = await Agent.get(name)
Line 208: if (agent) {
Line 210: type: "agent",
Line 211: name: agent.name,
Line 331: modelID: lastUser.model.modelID,
Line 332: providerID: lastUser.model.providerID,
Line 336: const model = await Provider.getModel(lastUser.model.providerID, lastUser.model.modelID).catch((e) => {
Line 342: message: `Model not found: ${e.data.providerID}/${e.data.modelID}.${hint}`,
Line 354: const taskModel = task.model ? await Provider.getModel(task.model.providerID, task.model.modelID) : model
Line 360: mode: task.agent,
Line 361: agent: task.agent,
Line 374: modelID: taskModel.id,
Line 392: subagent_type: task.agent,
Line 403: subagent_type: task.agent,
Line 416: const taskAgent = await Agent.get(task.agent)
Line 418: agent: task.agent,
Lin...<path>/home/jm/data/code/opencode/packages/opencode/src/session/session.sql.ts</path>
<type>file</type>
<content>1: import { sqliteTable, text, integer, index, primaryKey } from "drizzle-orm/sqlite-core"
2: import { ProjectTable } from "../project/project.sql"
3: import type { MessageV2 } from "./message-v2"
4: import type { Snapshot } from "@/snapshot"
5: import type { PermissionNext } from "@/permission/next"
6: import { Timestamps } from "@/storage/schema.sql"
7:
8: type PartData = Omit<MessageV2.Part, "id" | "sessionID" | "messageID">
9: type InfoData = Omit<MessageV2.Info, "id" | "sessionID">
10:
11: export const SessionTable = sqliteTable(
12: "session",
13: {
14: id: text().primaryKey(),
15: project_id: text()
16: .notNull()
17: .references(() => ProjectTable.id, { onDelete: "cascade" }),
18: parent_id: text(),
19: slug: text().notNull(),
20: directory: text().notNull(),
21: title: text().notNull(),
22: version: text().notNull(),
23: share_url: text(),
24: summary_additions: integer(),
25: summary_deletions: integer(),
26: summary_files: integer(),
27: summary_diffs: text({ mode: "json" }).$type<Snapshot.FileDiff[]>(),
28: revert: text({ mode: "json" }).$type<{ messageID: string; partID?: string; snapshot?: string; diff?: string }>(),
29: permission: text({ mode: "json" }).$type<PermissionNext.Ruleset>(),
30: ...Timestamps,
31: time_compacting: integer(),
32: time_archived: integer(),
33: },
34: (table) => [index("session_project_idx").on(table.project_id), index("session_parent_idx").on(table.parent_id)],
35: )
36:
37: export const MessageTable = sqliteTable(
38: "message",
39: {
40: id: text().primaryKey(),
41: session_id: text()
42: .notNull()
43: .references(() => SessionTable.id, { onDelete: "cascade" }),
44: ...Timestamps,
45: data: text({ mode: "json" }).notNull().$type<InfoData>(),
46: },
47: (table) => [index("message_session...<path>/home/jm/data/code/opencode/packages/opencode/src/session/index.ts</path>
<type>file</type>
<content>1: import { Slug } from "@opencode-ai/util/slug"
2: import path from "path"
3: import { BusEvent } from "@/bus/bus-event"
4: import { Bus } from "@/bus"
5: import { Decimal } from "decimal.js"
6: import z from "zod"
7: import { type ProviderMetadata } from "ai"
8: import { Config } from "../config/config"
9: import { Flag } from "../flag/flag"
10: import { Identifier } from "../id/id"
11: import { Installation } from "../installation"
12:
13: import { Database, NotFoundError, eq, and, or, gte, isNull, desc, like } from "../storage/db"
14: import { SessionTable, MessageTable, PartTable } from "./session.sql"
15: import { Storage } from "@/storage/storage"
16: import { Log } from "../util/log"
17: import { MessageV2 } from "./message-v2"
18: import { Instance } from "../project/instance"
19: import { SessionPrompt } from "./prompt"
20: import { fn } from "@/util/fn"
21: import { Command } from "../command"
22: import { Snapshot } from "@/snapshot"
23:
24: import type { Provider } from "@/provider/provider"
25: import { PermissionNext } from "@/permission/next"
26: import { Global } from "@/global"
27: import type { LanguageModelV2Usage } from "@ai-sdk/provider"
28: import { iife } from "@/util/iife"
29:
30: export namespace Session {
31: const log = Log.create({ service: "session" })
32:
33: const parentTitlePrefix = "New session - "
34: const childTitlePrefix = "Child session - "
35:
36: function createDefaultTitle(isChild = false) {
37: return (isChild ? childTitlePrefix : parentTitlePrefix) + new Date().toISOString()
38: }
39:
40: export function isDefaultTitle(title: string) {
41: return new RegExp(
42: `^(${parentTitlePrefix}|${childTitlePrefix})\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$`,
43: ).test(title)
44: }
45:
46: type SessionRow = typeof SessionTable.$inferSelect
47:
48: export function fromRow(ro...<path>/home/jm/data/code/opencode/packages/opencode/src/session/message-v2.ts</path>
<type>file</type>
<content>1: import { BusEvent } from "@/bus/bus-event"
2: import z from "zod"
3: import { NamedError } from "@opencode-ai/util/error"
4: import { APICallError, convertToModelMessages, LoadAPIKeyError, type ModelMessage, type UIMessage } from "ai"
5: import { Identifier } from "../id/id"
6: import { LSP } from "../lsp"
7: import { Snapshot } from "@/snapshot"
8: import { fn } from "@/util/fn"
9: import { Database, eq, desc, inArray } from "@/storage/db"
10: import { MessageTable, PartTable } from "./session.sql"
11: import { ProviderTransform } from "@/provider/transform"
12: import { STATUS_CODES } from "http"
13: import { Storage } from "@/storage/storage"
14: import { ProviderError } from "@/provider/error"
15: import { iife } from "@/util/iife"
16: import { type SystemError } from "bun"
17: import type { Provider } from "@/provider/provider"
18:
19: export namespace MessageV2 {
20: export const OutputLengthError = NamedError.create("MessageOutputLengthError", z.object({}))
21: export const AbortedError = NamedError.create("MessageAbortedError", z.object({ message: z.string() }))
22: export const StructuredOutputError = NamedError.create(
23: "StructuredOutputError",
24: z.object({
25: message: z.string(),
26: retries: z.number(),
27: }),
28: )
29: export const AuthError = NamedError.create(
30: "ProviderAuthError",
31: z.object({
32: providerID: z.string(),
33: message: z.string(),
34: }),
35: )
36: export const APIError = NamedError.create(
37: "APIError",
38: z.object({
39: message: z.string(),
40: statusCode: z.number().optional(),
41: isRetryable: z.boolean(),
42: responseHeaders: z.record(z.string(), z.string()).optional(),
43: responseBody: z.string().optional(),
44: metadata: z.record(z.string(), z.string()).optional(),
45: }),
46: )
47: expo...Found 90 matches
/home/jm/data/code/opencode/packages/opencode/src/session/index.ts:
Line 499: for await (const msg of MessageV2.stream(input.sessionID)) {
Line 595: Bus.publish(MessageV2.Event.Updated, {
Line 613: Bus.publish(MessageV2.Event.Removed, {
Line 633: Bus.publish(MessageV2.Event.PartRemoved, {
Line 661: Bus.publish(MessageV2.Event.PartUpdated, {
Line 669: export const updatePartDelta = fn(
Line 678: Bus.publish(MessageV2.Event.PartDelta, input)
Line 684: model: z.custom<Provider.Model>(),
Line 778: model: input.providerID + "/" + input.modelID,
/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts:
Line 94: model: z
Line 100: agent: z.string().optional(),
Line 298: let msgs = await MessageV2.filterCompacted(MessageV2.stream(sessionID))
Line 361: agent: task.agent,
Line 418: agent: task.agent,
Line 445: log.error("subtask execution failed", { error, agent: task.agent, description: task.description })
Line 511: agent: lastUser.agent,
Line 512: model: lastUser.model,
Line 549: agent: lastUser.agent,
Line 550: model: lastUser.model,
Line 572: agent: agent.name,
Line 707: agent: lastUser.agent,
Line 708: model: lastUser.model,
Line 715: for await (const item of MessageV2.stream(sessionID)) {
Line 727: for await (const item of MessageV2.stream(sessionID)) {
Line 728: if (item.info.role === "user" && item.info.model) return item.info.model
Line 735: agent: Agent.Info
Line 736: model: Provider.Model
Line 751: extra: { model: input.model, bypassAgentCheck: input.bypassAgentCheck },
Line 752: agent: input.agent.name,
Line 972: agent: agent.name,
Line 1143: const model = await Provider.getModel(info.model.providerID, info.model.modelID)
Line 1147: ...<path>/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts</path>
<type>file</type>
<content>1400: - Quality over quantity - 3 agents maximum, but you should try to use the minimum number of agents necessary (usually just 1)
1401: - If using multiple agents: Provide each agent with a specific search focus or area to explore. Example: One agent searches for existing implementations, another explores related components, a third investigates testing patterns
1402:
1403: 3. After exploring the code, use the question tool to clarify ambiguities in the user request up front.
1404:
1405: ### Phase 2: Design
1406: Goal: Design an implementation approach.
1407:
1408: Launch general agent(s) to design the implementation based on the user's intent and your exploration results from Phase 1.
1409:
1410: You can launch up to 1 agent(s) in parallel.
1411:
1412: **Guidelines:**
1413: - **Default**: Launch at least 1 Plan agent for most tasks - it helps validate your understanding and consider alternatives
1414: - **Skip agents**: Only for truly trivial tasks (typo fixes, single-line changes, simple renames)
1415:
1416: Examples of when to use multiple agents:
1417: - The task touches multiple parts of the codebase
1418: - It's a large refactor or architectural change
1419: - There are many edge cases to consider
1420: - You'd benefit from exploring different approaches
1421:
1422: Example perspectives by task type:
1423: - New feature: simplicity vs performance vs maintainability
1424: - Bug fix: root cause vs workaround vs prevention
1425: - Refactoring: minimal change vs clean architecture
1426:
1427: In the agent prompt:
1428: - Provide comprehensive background context from Phase 1 exploration including filenames and code path traces
1429: - Describe requirements and constraints
1430: - Request a detailed implementation plan
1431:
1432: ### Phase 3: Review
1433: Goal: Review the plan(s) from Phase 2 and ensure alignment with the user's intentions.
1...<path>/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts</path>
<type>file</type>
<content>1680: exited = true
1681: abort.removeEventListener("abort", abortHandler)
1682: resolve()
1683: })
1684: })
1685:
1686: if (aborted) {
1687: output += "\n\n" + ["<metadata>", "User aborted the command", "</metadata>"].join("\n")
1688: }
1689: msg.time.completed = Date.now()
1690: await Session.updateMessage(msg)
1691: if (part.state.status === "running") {
1692: part.state = {
1693: status: "completed",
1694: time: {
1695: ...part.state.time,
1696: end: Date.now(),
1697: },
1698: input: part.state.input,
1699: title: "",
1700: metadata: {
1701: output,
1702: description: "",
1703: },
1704: output,
1705: }
1706: await Session.updatePart(part)
1707: }
1708: return { info: msg, parts: [part] }
1709: }
1710:
1711: export const CommandInput = z.object({
1712: messageID: Identifier.schema("message").optional(),
1713: sessionID: Identifier.schema("session"),
1714: agent: z.string().optional(),
1715: model: z.string().optional(),
1716: arguments: z.string(),
1717: command: z.string(),
1718: variant: z.string().optional(),
1719: parts: z
1720: .array(
1721: z.discriminatedUnion("type", [
1722: MessageV2.FilePart.omit({
1723: messageID: true,
1724: sessionID: true,
1725: }).partial({
1726: id: true,
1727: }),
1728: ]),
1729: )
1730: .optional(),
1731: })
1732: export type CommandInput = z.infer<typeof CommandInput>
1733: const bashRegex = /!`([^`]+)`/g
1734: // Match [Image N] as single token, quoted strings, or non-space sequences
1735: const argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi
1736: const placeholderRegex = /...<path>/home/jm/data/code/opencode/packages/opencode/src/session/processor.ts</path>
<type>file</type>
<content>1: import { MessageV2 } from "./message-v2"
2: import { Log } from "@/util/log"
3: import { Identifier } from "@/id/id"
4: import { Session } from "."
5: import { Agent } from "@/agent/agent"
6: import { Snapshot } from "@/snapshot"
7: import { SessionSummary } from "./summary"
8: import { Bus } from "@/bus"
9: import { SessionRetry } from "./retry"
10: import { SessionStatus } from "./status"
11: import { Plugin } from "@/plugin"
12: import type { Provider } from "@/provider/provider"
13: import { LLM } from "./llm"
14: import { Config } from "@/config/config"
15: import { SessionCompaction } from "./compaction"
16: import { PermissionNext } from "@/permission/next"
17: import { Question } from "@/question"
18:
19: export namespace SessionProcessor {
20: const DOOM_LOOP_THRESHOLD = 3
21: const log = Log.create({ service: "session.processor" })
22:
23: export type Info = Awaited<ReturnType<typeof create>>
24: export type Result = Awaited<ReturnType<Info["process"]>>
25:
26: export function create(input: {
27: assistantMessage: MessageV2.Assistant
28: sessionID: string
29: model: Provider.Model
30: abort: AbortSignal
31: }) {
32: const toolcalls: Record<string, MessageV2.ToolPart> = {}
33: let snapshot: string | undefined
34: let blocked = false
35: let attempt = 0
36: let needsCompaction = false
37:
38: const result = {
39: get message() {
40: return input.assistantMessage
41: },
42: partFromToolCall(toolCallID: string) {
43: return toolcalls[toolCallID]
44: },
45: async process(streamInput: LLM.StreamInput) {
46: log.info("process")
47: needsCompaction = false
48: const shouldBreak = (await Config.get()).experimental?.continue_loop_on_deny !== true
49: while (true) {
50: try {
51: let currentText: Messa...<path>/home/jm/data/code/opencode/packages/opencode/src/session/llm.ts</path>
<type>file</type>
<content>1: import { Installation } from "@/installation"
2: import { Provider } from "@/provider/provider"
3: import { Log } from "@/util/log"
4: import {
5: streamText,
6: wrapLanguageModel,
7: type ModelMessage,
8: type StreamTextResult,
9: type Tool,
10: type ToolSet,
11: tool,
12: jsonSchema,
13: } from "ai"
14: import { mergeDeep, pipe } from "remeda"
15: import { ProviderTransform } from "@/provider/transform"
16: import { Config } from "@/config/config"
17: import { Instance } from "@/project/instance"
18: import type { Agent } from "@/agent/agent"
19: import type { MessageV2 } from "./message-v2"
20: import { Plugin } from "@/plugin"
21: import { SystemPrompt } from "./system"
22: import { Flag } from "@/flag/flag"
23: import { PermissionNext } from "@/permission/next"
24: import { Auth } from "@/auth"
25:
26: export namespace LLM {
27: const log = Log.create({ service: "llm" })
28: export const OUTPUT_TOKEN_MAX = ProviderTransform.OUTPUT_TOKEN_MAX
29:
30: export type StreamInput = {
31: user: MessageV2.User
32: sessionID: string
33: model: Provider.Model
34: agent: Agent.Info
35: system: string[]
36: abort: AbortSignal
37: messages: ModelMessage[]
38: small?: boolean
39: tools: Record<string, Tool>
40: retries?: number
41: toolChoice?: "auto" | "required" | "none"
42: }
43:
44: export type StreamOutput = StreamTextResult<ToolSet, unknown>
45:
46: export async function stream(input: StreamInput) {
47: const l = log
48: .clone()
49: .tag("providerID", input.model.providerID)
50: .tag("modelID", input.model.id)
51: .tag("sessionID", input.sessionID)
52: .tag("small", (input.small ?? false).toString())
53: .tag("agent", input.agent.name)
54: .tag("mode", input.agent.mode)
55: l.info("stream", {
56: modelID: input.model.id,
57: pro...Found 61 matches
/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts:
Line 308: if (!lastFinished && msg.info.role === "assistant" && msg.info.finish)
Line 319: lastAssistant?.finish &&
Line 320: !["tool-calls", "unknown"].includes(lastAssistant.finish) &&
Line 355: const assistantMessage = (await Session.updateMessage({
Line 380: let part = (await Session.updatePart({
Line 426: await Session.updatePart({
Line 464: assistantMessage.finish = "tool-calls"
Line 466: await Session.updateMessage(assistantMessage)
Line 468: await Session.updatePart({
Line 485: await Session.updatePart({
Line 501: // Add synthetic user message to prevent certain reasoning models from erroring
Line 514: await Session.updateMessage(summaryUserMsg)
Line 515: await Session.updatePart({
Line 521: synthetic: true,
Line 567: assistantMessage: (await Session.updateMessage({
Line 634: if (part.type !== "text" || part.ignored || part.synthetic) continue
Line 683: processor.message.finish = processor.message.finish ?? "stop"
Line 684: await Session.updateMessage(processor.message)
Line 688: // Check if model finished (finish reason is not "tool-calls" or "unknown")
Line 689: const modelFinished = processor.message.finish && !["tool-calls", "unknown"].includes(processor.message.finish)
Line 698: await Session.updateMessage(processor.message)
Line 726: async function lastModel(sessionID: string) {
Line 757: await Session.updatePart({
Line 957: const model = input.model ?? agent.model ?? (await lastModel(input.sessionID))
Line 999: synthetic: true,
Line 1021: synthetic: true,
Line 1031: synthetic: true,
Line 1049: synthetic: true,
Line 1065: ...<path>/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts</path>
<type>file</type>
<content>860: "tool.execute.after",
861: {
862: tool: key,
863: sessionID: ctx.sessionID,
864: callID: opts.toolCallId,
865: args,
866: },
867: result,
868: )
869:
870: const textParts: string[] = []
871: const attachments: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[] = []
872:
873: for (const contentItem of result.content) {
874: if (contentItem.type === "text") {
875: textParts.push(contentItem.text)
876: } else if (contentItem.type === "image") {
877: attachments.push({
878: type: "file",
879: mime: contentItem.mimeType,
880: url: `data:${contentItem.mimeType};base64,${contentItem.data}`,
881: })
882: } else if (contentItem.type === "resource") {
883: const { resource } = contentItem
884: if (resource.text) {
885: textParts.push(resource.text)
886: }
887: if (resource.blob) {
888: attachments.push({
889: type: "file",
890: mime: resource.mimeType ?? "application/octet-stream",
891: url: `data:${resource.mimeType ?? "application/octet-stream"};base64,${resource.blob}`,
892: filename: resource.uri,
893: })
894: }
895: }
896: }
897:
898: const truncated = await Truncate.output(textParts.join("\n\n"), {}, input.agent)
899: const metadata = {
900: ...(result.metadata ?? {}),
901: truncated: truncated.truncated,
902: ...(truncated.truncated && { outputPath: truncated.outputPath }),
903: }
904:
905: return {
906: title: "",
907: metadata,
908: output: truncat...<path>/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts</path>
<type>file</type>
<content>240: if (s[sessionID]) return
241: const controller = new AbortController()
242: s[sessionID] = {
243: abort: controller,
244: callbacks: [],
245: }
246: return controller.signal
247: }
248:
249: function resume(sessionID: string) {
250: const s = state()
251: if (!s[sessionID]) return
252:
253: return s[sessionID].abort.signal
254: }
255:
256: export function cancel(sessionID: string) {
257: log.info("cancel", { sessionID })
258: const s = state()
259: const match = s[sessionID]
260: if (!match) {
261: SessionStatus.set(sessionID, { type: "idle" })
262: return
263: }
264: match.abort.abort()
265: delete s[sessionID]
266: SessionStatus.set(sessionID, { type: "idle" })
267: return
268: }
269:
270: export const LoopInput = z.object({
271: sessionID: Identifier.schema("session"),
272: resume_existing: z.boolean().optional(),
273: })
274: export const loop = fn(LoopInput, async (input) => {
275: const { sessionID, resume_existing } = input
276:
277: const abort = resume_existing ? resume(sessionID) : start(sessionID)
278: if (!abort) {
279: return new Promise<MessageV2.WithParts>((resolve, reject) => {
280: const callbacks = state()[sessionID].callbacks
281: callbacks.push({ resolve, reject })
282: })
283: }
284:
285: using _ = defer(() => cancel(sessionID))
286:
287: // Structured output state
288: // Note: On session resumption, state is reset but outputFormat is preserved
289: // on the user message and will be retrieved from lastUser below
290: let structuredOutput: unknown | undefined
291:
292: let step = 0
293: const session = await Session.get(sessionID)
294: while (true) {
295: SessionStatus.set(sessionID, { type: "busy" })
296: log.info("loop", { ...<path>/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts</path>
<type>file</type>
<content>1: import path from "path"
2: import os from "os"
3: import fs from "fs/promises"
4: import z from "zod"
5: import { Filesystem } from "../util/filesystem"
6: import { Identifier } from "../id/id"
7: import { MessageV2 } from "./message-v2"
8: import { Log } from "../util/log"
9: import { SessionRevert } from "./revert"
10: import { Session } from "."
11: import { Agent } from "../agent/agent"
12: import { Provider } from "../provider/provider"
13: import { type Tool as AITool, tool, jsonSchema, type ToolCallOptions, asSchema } from "ai"
14: import { SessionCompaction } from "./compaction"
15: import { Instance } from "../project/instance"
16: import { Bus } from "../bus"
17: import { ProviderTransform } from "../provider/transform"
18: import { SystemPrompt } from "./system"
19: import { InstructionPrompt } from "./instruction"
20: import { Plugin } from "../plugin"
21: import PROMPT_PLAN from "../session/prompt/plan.txt"
22: import BUILD_SWITCH from "../session/prompt/build-switch.txt"
23: import MAX_STEPS from "../session/prompt/max-steps.txt"
24: import { defer } from "../util/defer"
25: import { ToolRegistry } from "../tool/registry"
26: import { MCP } from "../mcp"
27: import { LSP } from "../lsp"
28: import { ReadTool } from "../tool/read"
29: import { FileTime } from "../file/time"
30: import { Flag } from "../flag/flag"
31: import { ulid } from "ulid"
32: import { spawn } from "child_process"
33: import { Command } from "../command"
34: import { $, fileURLToPath, pathToFileURL } from "bun"
35: import { ConfigMarkdown } from "../config/markdown"
36: import { SessionSummary } from "./summary"
37: import { NamedError } from "@opencode-ai/util/error"
38: import { fn } from "@/util/fn"
39: import { SessionProcessor } from "./processor"
40: import { TaskTool } from "@/tool/task"
41: import { Tool } from "@/tool/tool"
42: import { PermissionNext } from "@/pe...<path>/home/jm/data/code/opencode/packages/opencode/src/storage/db.ts</path>
<type>file</type>
<content>1: import { Database as BunDatabase } from "bun:sqlite"
2: import { drizzle, type SQLiteBunDatabase } from "drizzle-orm/bun-sqlite"
3: import { migrate } from "drizzle-orm/bun-sqlite/migrator"
4: import { type SQLiteTransaction } from "drizzle-orm/sqlite-core"
5: export * from "drizzle-orm"
6: import { Context } from "../util/context"
7: import { lazy } from "../util/lazy"
8: import { Global } from "../global"
9: import { Log } from "../util/log"
10: import { NamedError } from "@opencode-ai/util/error"
11: import z from "zod"
12: import path from "path"
13: import { readFileSync, readdirSync, existsSync } from "fs"
14: import * as schema from "./schema"
15:
16: declare const OPENCODE_MIGRATIONS: { sql: string; timestamp: number }[] | undefined
17:
18: export const NotFoundError = NamedError.create(
19: "NotFoundError",
20: z.object({
21: message: z.string(),
22: }),
23: )
24:
25: const log = Log.create({ service: "db" })
26:
27: export namespace Database {
28: export const Path = path.join(Global.Path.data, "opencode.db")
29: type Schema = typeof schema
30: export type Transaction = SQLiteTransaction<"sync", void, Schema>
31:
32: type Client = SQLiteBunDatabase<Schema>
33:
34: type Journal = { sql: string; timestamp: number }[]
35:
36: function time(tag: string) {
37: const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(tag)
38: if (!match) return 0
39: return Date.UTC(
40: Number(match[1]),
41: Number(match[2]) - 1,
42: Number(match[3]),
43: Number(match[4]),
44: Number(match[5]),
45: Number(match[6]),
46: )
47: }
48:
49: function migrations(dir: string): Journal {
50: const dirs = readdirSync(dir, { withFileTypes: true })
51: .filter((entry) => entry.isDirectory())
52: .map((entry) => entry.name)
53:
54: const sql = dirs
55: .map((name) =>...<path>/home/jm/data/code/opencode/packages/opencode/src/storage/storage.ts</path>
<type>file</type>
<content>1: import { Log } from "../util/log"
2: import path from "path"
3: import fs from "fs/promises"
4: import { Global } from "../global"
5: import { Filesystem } from "../util/filesystem"
6: import { lazy } from "../util/lazy"
7: import { Lock } from "../util/lock"
8: import { $ } from "bun"
9: import { NamedError } from "@opencode-ai/util/error"
10: import z from "zod"
11: import { Glob } from "../util/glob"
12:
13: export namespace Storage {
14: const log = Log.create({ service: "storage" })
15:
16: type Migration = (dir: string) => Promise<void>
17:
18: export const NotFoundError = NamedError.create(
19: "NotFoundError",
20: z.object({
21: message: z.string(),
22: }),
23: )
24:
25: const MIGRATIONS: Migration[] = [
26: async (dir) => {
27: const project = path.resolve(dir, "../project")
28: if (!(await Filesystem.isDir(project))) return
29: const projectDirs = await Glob.scan("*", {
30: cwd: project,
31: include: "all",
32: })
33: for (const projectDir of projectDirs) {
34: const fullPath = path.join(project, projectDir)
35: if (!(await Filesystem.isDir(fullPath))) continue
36: log.info(`migrating project ${projectDir}`)
37: let projectID = projectDir
38: const fullProjectDir = path.join(project, projectDir)
39: let worktree = "/"
40:
41: if (projectID !== "global") {
42: for (const msgFile of await Glob.scan("storage/session/message/*/*.json", {
43: cwd: path.join(project, projectDir),
44: absolute: true,
45: })) {
46: const json = await Filesystem.readJson<any>(msgFile)
47: worktree = json.path?.root
48: if (worktree) break
49: }
50: if (!worktree) continue
51: if (!(await Filesystem.isDir(worktree))) continue
52...Found 64 matches
/home/jm/data/code/opencode/packages/opencode/src/session/index.ts:
Line 263: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 291: Database.effect(() =>
Line 332: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 345: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 364: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 385: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 406: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 434: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 453: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 478: Database.effect(() => Bus.publish(Event.Updated, { info }))
Line 570: Database.effect(() =>
Line 594: Database.effect(() =>
Line 612: Database.effect(() =>
Line 632: Database.effect(() =>
Line 660: Database.effect(() =>
/home/jm/data/code/opencode/packages/opencode/src/snapshot/index.ts:
Line 113: log.info("restore", { commit: snapshot })
/home/jm/data/code/opencode/packages/opencode/src/cli/cmd/github.ts:
Line 95: commits: {
Line 98: commit: GitHubCommit
Line 556: const { dirty, uncommittedChanges, switched } = await branchIsDirty(head, branch)
Line 564: await pushToNewBranch(summary, branch, uncommittedChanges, isScheduleEvent)
Line 575: console.log("Skipped PR creation (no new commits)")
Line 591: const { dirty, uncommittedChanges, switched } = await branchIsDirty(head, prData.headRefName)
Line 597: await pushToLocalBranch(summary, uncommittedChanges)
Line 609: const { dirty, uncommittedChanges, switched } = await branchIsDirty(head, forkBranch)
Line 615: await pushToForkBranch(summary, prData, uncommittedChanges)
Line 629: ...Found 1079 matches (showing first 100)
/home/jm/data/code/opencode/packages/opencode/test/pty/pty-output-isolation.test.ts:
Line 26: // no-op (simulate abrupt drop)
Line 75: // no-op (simulate abrupt drop)
/home/jm/data/code/opencode/packages/opencode/test/util/filesystem.test.ts:
Line 281: expect(Filesystem.mimeType("test.unknown")).toBe("application/octet-stream")
Line 285: expect(Filesystem.mimeType("Makefile")).toBe("application/octet-stream")
Line 292: const filepath = path.join(tmp.path, "streamed.txt")
Line 293: const content = "Hello from stream!"
Line 295: const stream = new ReadableStream({
Line 302: await Filesystem.writeStream(filepath, stream)
Line 307: test("writes from Node.js Readable stream", async () => {
Line 309: const filepath = path.join(tmp.path, "node-streamed.txt")
Line 310: const content = "Hello from Node stream!"
Line 311: const { Readable } = await import("stream")
Line 312: const stream = Readable.from([content])
Line 314: await Filesystem.writeStream(filepath, stream)
Line 323: const stream = new ReadableStream({
Line 330: await Filesystem.writeStream(filepath, stream)
Line 340: const stream = new ReadableStream({
Line 349: await Filesystem.writeStream(filepath, stream)
Line 356: const filepath = path.join(tmp.path, "nested", "deep", "streamed.txt")
Line 357: const content = "nested stream content"
Line 358: const stream = new ReadableStream({
Line 365: await Filesystem.writeStream(filepath, stream)
Line 372: const filepath = path.join(tmp.path, "protected-stream.txt")
Line 373: const content = "secret stream content"
Line 374: const stream = new ReadableStream({
Line 381: await Filesystem.writeStream(filepath, stream, 0o600)
Line 393: const stream = new ReadableStream({
Line 400: await Filesystem.wri.../home/jm/data/code/opencode/packages/opencode/test/util/network.test.ts
/home/jm/data/code/opencode/packages/opencode/test/pty/pty-output-isolation.test.ts
/home/jm/data/code/opencode/packages/opencode/test/snapshot/snapshot.test.ts
/home/jm/data/code/opencode/packages/opencode/test/util/glob.test.ts
/home/jm/data/code/opencode/packages/opencode/test/util/filesystem.test.ts
/home/jm/data/code/opencode/packages/opencode/test/tool/write.test.ts
/home/jm/data/code/opencode/packages/opencode/test/tool/webfetch.test.ts
/home/jm/data/code/opencode/packages/opencode/test/tool/truncation.test.ts
/home/jm/data/code/opencode/packages/opencode/test/tool/read.test.ts
/home/jm/data/code/opencode/packages/opencode/test/tool/edit.test.ts
/home/jm/data/code/opencode/packages/opencode/test/tool/bash.test.ts
/home/jm/data/code/opencode/packages/opencode/test/provider/transform.test.ts
/home/jm/data/code/opencode/packages/opencode/test/provider/provider.test.ts
/home/jm/data/code/opencode/packages/opencode/test/provider/amazon-bedrock.test.ts
/home/jm/data/code/opencode/packages/opencode/test/skill/discovery.test.ts
/home/jm/data/code/opencode/packages/opencode/test/session/prompt.test.ts
/home/jm/data/code/opencode/packages/opencode/test/session/llm.test.ts
/home/jm/data/code/opencode/packages/opencode/test/project/worktree-remove.test.ts
/home/jm/data/code/opencode/packages/opencode/test/project/project.test.ts
/home/jm/data/code/opencode/packages/opencode/test/agent/agent.test.ts
/home/jm/data/code/opencode/packages/opencode/test/config/config.test.ts
/home/jm/data/code/opencode/packages/opencode/test/cli/plugin-auth-picker.test.ts
/home/jm/data/code/opencode/packages/opencode/test/cli/github-action.test.ts
/home/jm/data/code/opencode/packages/opencode/test/file/time.test.ts
/home/jm/data/code/opencode/packages/opencode/test/file/index.test.ts
/home/jm/data/code/opencode/packages/opencode/test/storage/json-migration.test.ts
/home/jm/data/code/opencode/packages/opencode/test/session...Found 197 matches (showing first 100)
/home/jm/data/code/opencode/packages/opencode/test/session/prompt.test.ts:
Line 13: describe("session.prompt missing file", () => {
Line 18: agent: {
Line 20: model: "openai/gpt-5.2",
Line 34: agent: "build",
Line 63: agent: {
Line 65: model: "openai/gpt-5.2",
Line 79: agent: "build",
Line 110: describe("session.prompt special characters", () => {
Line 150: describe("session.prompt agent variant", () => {
Line 151: test("applies agent variant only when using agent model", async () => {
Line 159: agent: {
Line 161: model: "openai/gpt-5.2",
Line 175: agent: "build",
Line 176: model: { providerID: "opencode", modelID: "kimi-k2.5-free" },
Line 185: agent: "build",
Line 190: expect(match.info.model).toEqual({ providerID: "openai", modelID: "gpt-5.2" })
Line 195: agent: "build",
/home/jm/data/code/opencode/packages/opencode/test/session/llm.test.ts:
Line 9: import { ModelsDev } from "../../src/provider/models"
Line 12: import type { Agent } from "../../src/agent/agent"
Line 187: async function loadFixture(providerID: string, modelID: string) {
Line 188: const fixturePath = path.join(import.meta.dir, "../tool/fixtures/models-api.json")
Line 194: const model = provider.models[modelID]
Line 195: if (!model) {
Line 196: throw new Error(`Missing model in fixture: ${modelID}`)
Line 198: return { provider, model }
Line 219: headers: { "Content-Type": "text/event-stream" },
Line 223: describe("session.llm.stream", () => {
Line 224: test("sends temperature, tokens, and reasoning options for openai-compatible models", async () => {
Line 231: const modelID = "qwen-plus"
Line 232: const fixture = await loadFixture(providerID, modelID)
Line 234: const model = fixture.model
Line 240: headers: { "Content-Ty...<path>/home/jm/data/code/opencode/packages/opencode/test/session/message-v2.test.ts</path>
<type>file</type>
<content>1: import { describe, expect, test } from "bun:test"
2: import { APICallError } from "ai"
3: import { MessageV2 } from "../../src/session/message-v2"
4: import type { Provider } from "../../src/provider/provider"
5:
6: const sessionID = "session"
7: const model: Provider.Model = {
8: id: "test-model",
9: providerID: "test",
10: api: {
11: id: "test-model",
12: url: "https://example.com",
13: npm: "@ai-sdk/openai",
14: },
15: name: "Test Model",
16: capabilities: {
17: temperature: true,
18: reasoning: false,
19: attachment: false,
20: toolcall: true,
21: input: {
22: text: true,
23: audio: false,
24: image: false,
25: video: false,
26: pdf: false,
27: },
28: output: {
29: text: true,
30: audio: false,
31: image: false,
32: video: false,
33: pdf: false,
34: },
35: interleaved: false,
36: },
37: cost: {
38: input: 0,
39: output: 0,
40: cache: {
41: read: 0,
42: write: 0,
43: },
44: },
45: limit: {
46: context: 0,
47: input: 0,
48: output: 0,
49: },
50: status: "active",
51: options: {},
52: headers: {},
53: release_date: "2026-01-01",
54: }
55:
56: function userInfo(id: string): MessageV2.User {
57: return {
58: id,
59: sessionID,
60: role: "user",
61: time: { created: 0 },
62: agent: "user",
63: model: { providerID: "test", modelID: "test" },
64: tools: {},
65: mode: "",
66: } as unknown as MessageV2.User
67: }
68:
69: function assistantInfo(
70: id: string,
71: parentID: string,
72: error?: MessageV2.Assistant["error"],
73: meta?: { providerID: string; modelID: string },
74: ): MessageV2.Assistant {
75: const infoModel = meta ?? { providerID: model.providerID, modelID: model.api.id }
76: return {
77: id,
78: sessionID...<path>/home/jm/data/code/opencode/packages/opencode/test/session/session.test.ts</path>
<type>file</type>
<content>1: import { describe, expect, test } from "bun:test"
2: import path from "path"
3: import { Session } from "../../src/session"
4: import { Bus } from "../../src/bus"
5: import { Log } from "../../src/util/log"
6: import { Instance } from "../../src/project/instance"
7:
8: const projectRoot = path.join(__dirname, "../..")
9: Log.init({ print: false })
10:
11: describe("session.started event", () => {
12: test("should emit session.started event when session is created", async () => {
13: await Instance.provide({
14: directory: projectRoot,
15: fn: async () => {
16: let eventReceived = false
17: let receivedInfo: Session.Info | undefined
18:
19: const unsub = Bus.subscribe(Session.Event.Created, (event) => {
20: eventReceived = true
21: receivedInfo = event.properties.info as Session.Info
22: })
23:
24: const session = await Session.create({})
25:
26: await new Promise((resolve) => setTimeout(resolve, 100))
27:
28: unsub()
29:
30: expect(eventReceived).toBe(true)
31: expect(receivedInfo).toBeDefined()
32: expect(receivedInfo?.id).toBe(session.id)
33: expect(receivedInfo?.projectID).toBe(session.projectID)
34: expect(receivedInfo?.directory).toBe(session.directory)
35: expect(receivedInfo?.title).toBe(session.title)
36:
37: await Session.remove(session.id)
38: },
39: })
40: })
41:
42: test("session.started event should be emitted before session.updated", async () => {
43: await Instance.provide({
44: directory: projectRoot,
45: fn: async () => {
46: const events: string[] = []
47:
48: const unsubStarted = Bus.subscribe(Session.Event.Created, () => {
49: events.push("started")
50: })
51:
52: const unsubUpdated = Bus.subscribe(Ses...<path>/home/jm/data/code/opencode/packages/opencode/test/session/prompt.test.ts</path>
<type>file</type>
<content>1: import path from "path"
2: import { describe, expect, test } from "bun:test"
3: import { fileURLToPath } from "url"
4: import { Instance } from "../../src/project/instance"
5: import { Session } from "../../src/session"
6: import { MessageV2 } from "../../src/session/message-v2"
7: import { SessionPrompt } from "../../src/session/prompt"
8: import { Log } from "../../src/util/log"
9: import { tmpdir } from "../fixture/fixture"
10:
11: Log.init({ print: false })
12:
13: describe("session.prompt missing file", () => {
14: test("does not fail the prompt when a file part is missing", async () => {
15: await using tmp = await tmpdir({
16: git: true,
17: config: {
18: agent: {
19: build: {
20: model: "openai/gpt-5.2",
21: },
22: },
23: },
24: })
25:
26: await Instance.provide({
27: directory: tmp.path,
28: fn: async () => {
29: const session = await Session.create({})
30:
31: const missing = path.join(tmp.path, "does-not-exist.ts")
32: const msg = await SessionPrompt.prompt({
33: sessionID: session.id,
34: agent: "build",
35: noReply: true,
36: parts: [
37: { type: "text", text: "please review @does-not-exist.ts" },
38: {
39: type: "file",
40: mime: "text/plain",
41: url: `file://${missing}`,
42: filename: "does-not-exist.ts",
43: },
44: ],
45: })
46:
47: if (msg.info.role !== "user") throw new Error("expected user message")
48:
49: const hasFailure = msg.parts.some(
50: (part) => part.type === "text" && part.synthetic && part.text.includes("Read tool failed to read"),
51: )
52: expect(hasFailure).toBe(true)
53:
54: await Session.remove(ses...<path>/home/jm/data/code/opencode/packages/opencode/src/storage/json-migration.ts</path>
<type>file</type>
<content>1: import { Database } from "bun:sqlite"
2: import { drizzle } from "drizzle-orm/bun-sqlite"
3: import { Global } from "../global"
4: import { Log } from "../util/log"
5: import { ProjectTable } from "../project/project.sql"
6: import { SessionTable, MessageTable, PartTable, TodoTable, PermissionTable } from "../session/session.sql"
7: import { SessionShareTable } from "../share/share.sql"
8: import path from "path"
9: import { existsSync } from "fs"
10: import { Filesystem } from "../util/filesystem"
11: import { Glob } from "../util/glob"
12:
13: export namespace JsonMigration {
14: const log = Log.create({ service: "json-migration" })
15:
16: export type Progress = {
17: current: number
18: total: number
19: label: string
20: }
21:
22: type Options = {
23: progress?: (event: Progress) => void
24: }
25:
26: export async function run(sqlite: Database, options?: Options) {
27: const storageDir = path.join(Global.Path.data, "storage")
28:
29: if (!existsSync(storageDir)) {
30: log.info("storage directory does not exist, skipping migration")
31: return {
32: projects: 0,
33: sessions: 0,
34: messages: 0,
35: parts: 0,
36: todos: 0,
37: permissions: 0,
38: shares: 0,
39: errors: [] as string[],
40: }
41: }
42:
43: log.info("starting json to sqlite migration", { storageDir })
44: const start = performance.now()
45:
46: const db = drizzle({ client: sqlite })
47:
48: // Optimize SQLite for bulk inserts
49: sqlite.exec("PRAGMA journal_mode = WAL")
50: sqlite.exec("PRAGMA synchronous = OFF")
51: sqlite.exec("PRAGMA cache_size = 10000")
52: sqlite.exec("PRAGMA temp_store = MEMORY")
53: const stats = {
54: projects: 0,
55: sessions: 0,
56: messages: 0,
57: parts: 0,
58: ...Found 82 matches
/home/jm/data/code/opencode/packages/opencode/src/storage/storage.ts:
Line 21: message: z.string(),
Line 42: for (const msgFile of await Glob.scan("storage/session/message/*/*.json", {
Line 46: const json = await Filesystem.readJson<any>(msgFile)
Line 47: worktree = json.path?.root
Line 67: await Filesystem.writeJson(path.join(dir, "project", projectID + ".json"), {
Line 78: for (const sessionFile of await Glob.scan("storage/session/info/*.json", {
Line 89: log.info(`migrating messages for session ${session.id}`)
Line 90: for (const msgFile of await Glob.scan(`storage/session/message/${session.id}/*.json`, {
Line 94: const dest = path.join(dir, "message", session.id, path.basename(msgFile))
Line 99: const message = await Filesystem.readJson<any>(msgFile)
Line 100: await Filesystem.writeJson(dest, message)
Line 102: log.info(`migrating parts for message ${message.id}`)
Line 103: for (const partFile of await Glob.scan(`storage/session/part/${session.id}/${message.id}/*.json`, {
Line 107: const dest = path.join(dir, "part", message.id, path.basename(partFile))
Line 108: const part = await Filesystem.readJson(partFile)
Line 110: partFile,
Line 113: await Filesystem.writeJson(dest, part)
Line 121: for (const item of await Glob.scan("session/*/*.json", {
Line 129: await Filesystem.write(path.join(dir, "session_diff", session.id + ".json"), JSON.stringify(diffs))
Line 130: await Filesystem.writeJson(path.join(dir, "session", session.projectID, session.id + ".json"), {
Line 159: const target = path.join(dir, ...key) + ".json"
Line 167: const target = path.join(dir, ...key) + ".json"
Line 177: const target = path.join(dir, ...key) + ".json"
Line 189: const t...<path>/home/jm/data/code/opencode/packages/opencode/src/server/routes/session.ts</path>
<type>file</type>
<content>1: import { Hono } from "hono"
2: import { stream } from "hono/streaming"
3: import { describeRoute, validator, resolver } from "hono-openapi"
4: import z from "zod"
5: import { Session } from "../../session"
6: import { MessageV2 } from "../../session/message-v2"
7: import { SessionPrompt } from "../../session/prompt"
8: import { SessionCompaction } from "../../session/compaction"
9: import { SessionRevert } from "../../session/revert"
10: import { SessionStatus } from "@/session/status"
11: import { SessionSummary } from "@/session/summary"
12: import { Todo } from "../../session/todo"
13: import { Agent } from "../../agent/agent"
14: import { Snapshot } from "@/snapshot"
15: import { Log } from "../../util/log"
16: import { PermissionNext } from "@/permission/next"
17: import { errors } from "../error"
18: import { lazy } from "../../util/lazy"
19:
20: const log = Log.create({ service: "server" })
21:
22: export const SessionRoutes = lazy(() =>
23: new Hono()
24: .get(
25: "/",
26: describeRoute({
27: summary: "List sessions",
28: description: "Get a list of all OpenCode sessions, sorted by most recently updated.",
29: operationId: "session.list",
30: responses: {
31: 200: {
32: description: "List of sessions",
33: content: {
34: "application/json": {
35: schema: resolver(Session.Info.array()),
36: },
37: },
38: },
39: },
40: }),
41: validator(
42: "query",
43: z.object({
44: directory: z.string().optional().meta({ description: "Filter sessions by project directory" }),
45: roots: z.coerce.boolean().optional().meta({ description: "Only return root sessions (no parentID)" }),
46: start: z.coerce
47: .number()
48: ...<path>/home/jm/data/code/opencode/packages/opencode/test/server/session-select.test.ts</path>
<type>file</type>
<content>1: import { describe, expect, test } from "bun:test"
2: import path from "path"
3: import { Session } from "../../src/session"
4: import { Log } from "../../src/util/log"
5: import { Instance } from "../../src/project/instance"
6: import { Server } from "../../src/server/server"
7:
8: const projectRoot = path.join(__dirname, "../..")
9: Log.init({ print: false })
10:
11: describe("tui.selectSession endpoint", () => {
12: test("should return 200 when called with valid session", async () => {
13: await Instance.provide({
14: directory: projectRoot,
15: fn: async () => {
16: // #given
17: const session = await Session.create({})
18:
19: // #when
20: const app = Server.App()
21: const response = await app.request("/tui/select-session", {
22: method: "POST",
23: headers: { "Content-Type": "application/json" },
24: body: JSON.stringify({ sessionID: session.id }),
25: })
26:
27: // #then
28: expect(response.status).toBe(200)
29: const body = await response.json()
30: expect(body).toBe(true)
31:
32: await Session.remove(session.id)
33: },
34: })
35: })
36:
37: test("should return 404 when session does not exist", async () => {
38: await Instance.provide({
39: directory: projectRoot,
40: fn: async () => {
41: // #given
42: const nonExistentSessionID = "ses_nonexistent123"
43:
44: // #when
45: const app = Server.App()
46: const response = await app.request("/tui/select-session", {
47: method: "POST",
48: headers: { "Content-Type": "application/json" },
49: body: JSON.stringify({ sessionID: nonExistentSessionID }),
50: })
51:
52: // #then
53: expect(response.status).toBe(404)
54: },
55: ...Found 85 matches
/home/jm/data/code/opencode/packages/opencode/src/server/routes/pty.ts:
Line 79: throw new NotFoundError({ message: "Session not found" })
Line 154: const cursor = (() => {
Line 155: const value = c.req.query("cursor")
Line 185: handler = Pty.connect(id, socket, cursor)
/home/jm/data/code/opencode/packages/opencode/src/server/routes/global.ts:
Line 3: import { streamSSE } from "hono/streaming"
Line 49: description: "Event stream",
Line 51: "text/event-stream": {
Line 71: return streamSSE(c, async (stream) => {
Line 72: stream.writeSSE({
Line 81: await stream.writeSSE({
Line 87: // Send heartbeat every 10s to prevent stalled proxy streams.
Line 89: stream.writeSSE({
Line 100: stream.onAbort(() => {
/home/jm/data/code/opencode/packages/opencode/src/server/routes/session.ts:
Line 2: import { stream } from "hono/streaming"
Line 6: import { MessageV2 } from "../../session/message-v2"
Line 14: import { Snapshot } from "@/snapshot"
Line 49: .meta({ description: "Filter sessions updated on or after this timestamp (milliseconds since epoch)" }),
Line 214: description: "Delete a session and permanently remove all associated data, including messages and history.",
Line 327: description: "Create a new session by forking an existing session at a specific message point.",
Line 417: summary: "Get message diff",
Line 418: description: "Get the file changes (diff) that resulted from a specific user message in the session.",
Line 440: messageID: SessionSummary.diff.schema.shape.messageID,
Line 448: messageID: query.messageID,
Line 521: const msgs = await Session.messages({ sessionID })
Line 544: "/:sessionID/message",
Line 546: summary: "Get session messages",
Line 547: description: "Retrieve...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sync/session-load.ts</path>
<type>file</type>
<content>1: import type { RootLoadArgs } from "./types"
2:
3: export async function loadRootSessionsWithFallback(input: RootLoadArgs) {
4: try {
5: const result = await input.list({ directory: input.directory, roots: true, limit: input.limit })
6: return {
7: data: result.data,
8: limit: input.limit,
9: limited: true,
10: } as const
11: } catch {
12: const result = await input.list({ directory: input.directory, roots: true })
13: return {
14: data: result.data,
15: limit: input.limit,
16: limited: false,
17: } as const
18: }
19: }
20:
21: export function estimateRootSessionTotal(input: { count: number; limit: number; limited: boolean }) {
22: if (!input.limited) return input.count
23: if (input.count < input.limit) return input.count
24: return input.count + 1
25: }
26:
(End of file - total 26 lines)
</content>
<system-reminder>
Instructions from: /home/jm/data/code/opencode/packages/app/AGENTS.md
## Debugging
- NEVER try to restart the app, or the server process, EVER.
## Local Dev
- `opencode dev web` proxies `https://app.opencode.ai`, so local UI/CSS changes will not show there.
- For local UI changes, run the backend and app dev servers separately.
- Backend (from `packages/opencode`): `bun run --conditions=browser ./src/index.ts serve --port 4096`
- App (from `packages/app`): `bun dev -- --port 4444`
- Open `http://localhost:4444` to verify UI changes (it targets the backend at `http://localhost:4096`).
## SolidJS
- Always prefer `createStore` over multiple `createSignal` calls
## Tool Calling
- ALWAYS USE PARALLEL TOOLS WHEN APPLICABLE.
## Browser Automation
Use `agent-browser` for web automation. Run `agent-browser --help` for all commands.
Core workflow:
1. `agent-browser open <url>` - Navigate to page
2. `agent-browser snapshot -i` - Get interactive elements wi...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sync/session-trim.ts</path>
<type>file</type>
<content>1: import type { PermissionRequest, Session } from "@opencode-ai/sdk/v2/client"
2: import { cmp } from "./utils"
3: import { SESSION_RECENT_LIMIT, SESSION_RECENT_WINDOW } from "./types"
4:
5: export function sessionUpdatedAt(session: Session) {
6: return session.time.updated ?? session.time.created
7: }
8:
9: export function compareSessionRecent(a: Session, b: Session) {
10: const aUpdated = sessionUpdatedAt(a)
11: const bUpdated = sessionUpdatedAt(b)
12: if (aUpdated !== bUpdated) return bUpdated - aUpdated
13: return cmp(a.id, b.id)
14: }
15:
16: export function takeRecentSessions(sessions: Session[], limit: number, cutoff: number) {
17: if (limit <= 0) return [] as Session[]
18: const selected: Session[] = []
19: const seen = new Set<string>()
20: for (const session of sessions) {
21: if (!session?.id) continue
22: if (seen.has(session.id)) continue
23: seen.add(session.id)
24: if (sessionUpdatedAt(session) <= cutoff) continue
25: const index = selected.findIndex((x) => compareSessionRecent(session, x) < 0)
26: if (index === -1) selected.push(session)
27: if (index !== -1) selected.splice(index, 0, session)
28: if (selected.length > limit) selected.pop()
29: }
30: return selected
31: }
32:
33: export function trimSessions(
34: input: Session[],
35: options: { limit: number; permission: Record<string, PermissionRequest[]>; now?: number },
36: ) {
37: const limit = Math.max(0, options.limit)
38: const cutoff = (options.now ?? Date.now()) - SESSION_RECENT_WINDOW
39: const all = input
40: .filter((s) => !!s?.id)
41: .filter((s) => !s.time?.archived)
42: .sort((a, b) => cmp(a.id, b.id))
43: const roots = all.filter((s) => !s.parentID)
44: const children = all.filter((s) => !!s.parentID)
45: const base = roots.slice(0, limit)
46: const recent = takeRecentSessions(...Found 67 matches
/home/jm/data/code/opencode/packages/app/src/pages/session.tsx:
Line 881: backfillTurns()
Line 889: backfillTurns()
Line 893: function backfillTurns() {
/home/jm/data/code/opencode/packages/app/src/context/settings.tsx:
Line 1: import { createStore, reconcile } from "solid-js/store"
Line 154: setStore("keybinds", reconcile({}))
/home/jm/data/code/opencode/packages/app/src/components/prompt-input/attachments.ts:
Line 133: const dropped = event.dataTransfer?.files
Line 134: if (!dropped) return
Line 136: for (const file of Array.from(dropped)) {
/home/jm/data/code/opencode/packages/app/src/pages/layout.tsx:
Line 32: import { createStore, produce, reconcile } from "solid-js/store"
Line 709: setStore("message", sessionID, reconcile(merged, { key: "id" }))
Line 718: setStore("part", message.info.id, reconcile(mergedParts, { key: "id" }))
Line 767: const dropped = q.pending.pop()
Line 768: if (!dropped) continue
Line 769: q.pendingSet.delete(dropped)
/home/jm/data/code/opencode/packages/app/src/context/sync.tsx:
Line 2: import { createStore, produce, reconcile } from "solid-js/store"
Line 161: input.setStore("message", input.sessionID, reconcile(next.session, { key: "id" }))
Line 163: input.setStore("part", message.id, reconcile(message.part, { key: "id" }))
Line 284: setStore("session_diff", sessionID, reconcile(diff.data ?? [], { key: "file" }))
Line 302: setStore("todo", sessionID, reconcile(cached, { key: "id" }))
Line 309: setStore("todo", sessionID, reconcile(list, { key: "id" }))
Line 355: setStore("session", reconcile(sessions, { key: "id" }))
/home/jm/data/code/opencode/packages/app/src/context/global-sdk.tsx:
Line 58: if (payload.type === "message.part.updated") {
Line 60: return `message.part.updated:${directory}:${part.message...<path>/home/jm/data/code/opencode/packages/app/src/pages/layout.tsx</path>
<type>file</type>
<content>620: running: number
621: }
622:
623: const prefetchChunk = 200
624: const prefetchConcurrency = 1
625: const prefetchPendingLimit = 6
626: const prefetchToken = { value: 0 }
627: const prefetchQueues = new Map<string, PrefetchQueue>()
628:
629: const PREFETCH_MAX_SESSIONS_PER_DIR = 10
630: const prefetchedByDir = new Map<string, Map<string, true>>()
631:
632: const lruFor = (directory: string) => {
633: const existing = prefetchedByDir.get(directory)
634: if (existing) return existing
635: const created = new Map<string, true>()
636: prefetchedByDir.set(directory, created)
637: return created
638: }
639:
640: const markPrefetched = (directory: string, sessionID: string) => {
641: const lru = lruFor(directory)
642: if (lru.has(sessionID)) lru.delete(sessionID)
643: lru.set(sessionID, true)
644: while (lru.size > PREFETCH_MAX_SESSIONS_PER_DIR) {
645: const oldest = lru.keys().next().value as string | undefined
646: if (!oldest) return
647: lru.delete(oldest)
648: }
649: }
650:
651: createEffect(() => {
652: params.dir
653: globalSDK.url
654:
655: prefetchToken.value += 1
656: for (const q of prefetchQueues.values()) {
657: q.pending.length = 0
658: q.pendingSet.clear()
659: }
660: })
661:
662: const queueFor = (directory: string) => {
663: const existing = prefetchQueues.get(directory)
664: if (existing) return existing
665:
666: const created: PrefetchQueue = {
667: inflight: new Set(),
668: pending: [],
669: pendingSet: new Set(),
670: running: 0,
671: }
672: prefetchQueues.set(directory, created)
673: return created
674: }
675:
676: const mergeByID = <T extends { id: string }>(current: T[], incoming: T[]) => {
677: if (current.length === 0) {
678: return incoming.slice().s...<path>/home/jm/data/code/opencode/packages/app/src/pages/session.tsx</path>
<type>file</type>
<content>820: setStore("messageId", undefined)
821: clearMessageHash()
822: },
823: { defer: true },
824: ),
825: )
826:
827: createEffect(
828: on(
829: sessionKey,
830: () => {
831: scrollSpy.clear()
832: },
833: { defer: true },
834: ),
835: )
836:
837: const anchor = (id: string) => `message-${id}`
838:
839: const setScrollRef = (el: HTMLDivElement | undefined) => {
840: scroller = el
841: autoScroll.scrollRef(el)
842: scrollSpy.setContainer(el)
843: if (el) scheduleScrollState(el)
844: }
845:
846: createResizeObserver(
847: () => content,
848: () => {
849: const el = scroller
850: if (el) scheduleScrollState(el)
851: scrollSpy.markDirty()
852: },
853: )
854:
855: const turnInit = 20
856: const turnBatch = 20
857: let turnHandle: number | undefined
858: let turnIdle = false
859:
860: function cancelTurnBackfill() {
861: const handle = turnHandle
862: if (handle === undefined) return
863: turnHandle = undefined
864:
865: if (turnIdle && window.cancelIdleCallback) {
866: window.cancelIdleCallback(handle)
867: return
868: }
869:
870: clearTimeout(handle)
871: }
872:
873: function scheduleTurnBackfill() {
874: if (turnHandle !== undefined) return
875: if (store.turnStart <= 0) return
876:
877: if (window.requestIdleCallback) {
878: turnIdle = true
879: turnHandle = window.requestIdleCallback(() => {
880: turnHandle = undefined
881: backfillTurns()
882: })
883: return
884: }
885:
886: turnIdle = false
887: turnHandle = window.setTimeout(() => {
888: turnHandle = undefined
889: backfillTurns()
890: }, 0)
891: }
892:
893: function backfillTurns() {
894: const start = store.turnStart
895: if (st...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sync.tsx</path>
<type>file</type>
<content>1: import type {
2: Config,
3: OpencodeClient,
4: Path,
5: Project,
6: ProviderAuthResponse,
7: ProviderListResponse,
8: Todo,
9: } from "@opencode-ai/sdk/v2/client"
10: import { showToast } from "@opencode-ai/ui/toast"
11: import { getFilename } from "@opencode-ai/util/path"
12: import {
13: createContext,
14: createEffect,
15: getOwner,
16: Match,
17: onCleanup,
18: onMount,
19: type ParentProps,
20: Switch,
21: untrack,
22: useContext,
23: } from "solid-js"
24: import { createStore, produce, reconcile } from "solid-js/store"
25: import { useLanguage } from "@/context/language"
26: import { Persist, persisted } from "@/utils/persist"
27: import type { InitError } from "../pages/error"
28: import { useGlobalSDK } from "./global-sdk"
29: import { bootstrapDirectory, bootstrapGlobal } from "./global-sync/bootstrap"
30: import { createChildStoreManager } from "./global-sync/child-store"
31: import { applyDirectoryEvent, applyGlobalEvent } from "./global-sync/event-reducer"
32: import { createRefreshQueue } from "./global-sync/queue"
33: import { estimateRootSessionTotal, loadRootSessionsWithFallback } from "./global-sync/session-load"
34: import { trimSessions } from "./global-sync/session-trim"
35: import type { ProjectMeta } from "./global-sync/types"
36: import { SESSION_RECENT_LIMIT } from "./global-sync/types"
37: import { sanitizeProject } from "./global-sync/utils"
38: import { usePlatform } from "./platform"
39:
40: type GlobalStore = {
41: ready: boolean
42: error?: InitError
43: path: Path
44: project: Project[]
45: session_todo: {
46: [sessionID: string]: Todo[]
47: }
48: provider: ProviderListResponse
49: provider_auth: ProviderAuthResponse
50: config: Config
51: reload: undefined | "pending" | "complete"
52: }
53:
54: function errorMessage(error: unknown) {
55: if (error instanceof Error...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sync/event-reducer.ts</path>
<type>file</type>
<content>1: import { Binary } from "@opencode-ai/util/binary"
2: import { produce, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
3: import type {
4: FileDiff,
5: Message,
6: Part,
7: PermissionRequest,
8: Project,
9: QuestionRequest,
10: Session,
11: SessionStatus,
12: Todo,
13: } from "@opencode-ai/sdk/v2/client"
14: import type { State, VcsCache } from "./types"
15: import { trimSessions } from "./session-trim"
16:
17: export function applyGlobalEvent(input: {
18: event: { type: string; properties?: unknown }
19: project: Project[]
20: setGlobalProject: (next: Project[] | ((draft: Project[]) => void)) => void
21: refresh: () => void
22: }) {
23: if (input.event.type === "global.disposed" || input.event.type === "server.connected") {
24: input.refresh()
25: return
26: }
27:
28: if (input.event.type !== "project.updated") return
29: const properties = input.event.properties as Project
30: const result = Binary.search(input.project, properties.id, (s) => s.id)
31: if (result.found) {
32: input.setGlobalProject((draft) => {
33: draft[result.index] = { ...draft[result.index], ...properties }
34: })
35: return
36: }
37: input.setGlobalProject((draft) => {
38: draft.splice(result.index, 0, properties)
39: })
40: }
41:
42: function cleanupSessionCaches(
43: store: Store<State>,
44: setStore: SetStoreFunction<State>,
45: sessionID: string,
46: setSessionTodo?: (sessionID: string, todos: Todo[] | undefined) => void,
47: ) {
48: if (!sessionID) return
49: const hasAny =
50: store.message[sessionID] !== undefined ||
51: store.session_diff[sessionID] !== undefined ||
52: store.todo[sessionID] !== undefined ||
53: store.permission[sessionID] !== undefined ||
54: store.question[sessionID] !== undefined ||
55: store.session_status[sess...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sync/bootstrap.ts</path>
<type>file</type>
<content>1: import type {
2: Config,
3: OpencodeClient,
4: Path,
5: PermissionRequest,
6: Project,
7: ProviderAuthResponse,
8: ProviderListResponse,
9: QuestionRequest,
10: Todo,
11: } from "@opencode-ai/sdk/v2/client"
12: import { showToast } from "@opencode-ai/ui/toast"
13: import { getFilename } from "@opencode-ai/util/path"
14: import { retry } from "@opencode-ai/util/retry"
15: import { batch } from "solid-js"
16: import { reconcile, type SetStoreFunction, type Store } from "solid-js/store"
17: import type { State, VcsCache } from "./types"
18: import { cmp, normalizeProviderList } from "./utils"
19:
20: type GlobalStore = {
21: ready: boolean
22: path: Path
23: project: Project[]
24: session_todo: {
25: [sessionID: string]: Todo[]
26: }
27: provider: ProviderListResponse
28: provider_auth: ProviderAuthResponse
29: config: Config
30: reload: undefined | "pending" | "complete"
31: }
32:
33: export async function bootstrapGlobal(input: {
34: globalSDK: OpencodeClient
35: connectErrorTitle: string
36: connectErrorDescription: string
37: requestFailedTitle: string
38: setGlobalStore: SetStoreFunction<GlobalStore>
39: }) {
40: const health = await input.globalSDK.global
41: .health()
42: .then((x) => x.data)
43: .catch(() => undefined)
44: if (!health?.healthy) {
45: showToast({
46: variant: "error",
47: title: input.connectErrorTitle,
48: description: input.connectErrorDescription,
49: })
50: input.setGlobalStore("ready", true)
51: return
52: }
53:
54: const tasks = [
55: retry(() =>
56: input.globalSDK.path.get().then((x) => {
57: input.setGlobalStore("path", x.data!)
58: }),
59: ),
60: retry(() =>
61: input.globalSDK.global.config.get().then((x) => {
62: input.setGlobalStore("config", x.data!)
63: })...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sync/queue.ts</path>
<type>file</type>
<content>1: type QueueInput = {
2: paused: () => boolean
3: bootstrap: () => Promise<void>
4: bootstrapInstance: (directory: string) => Promise<void> | void
5: }
6:
7: export function createRefreshQueue(input: QueueInput) {
8: const queued = new Set<string>()
9: let root = false
10: let running = false
11: let timer: ReturnType<typeof setTimeout> | undefined
12:
13: const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0))
14:
15: const take = (count: number) => {
16: if (queued.size === 0) return [] as string[]
17: const items: string[] = []
18: for (const item of queued) {
19: queued.delete(item)
20: items.push(item)
21: if (items.length >= count) break
22: }
23: return items
24: }
25:
26: const schedule = () => {
27: if (timer) return
28: timer = setTimeout(() => {
29: timer = undefined
30: void drain()
31: }, 0)
32: }
33:
34: const push = (directory: string) => {
35: if (!directory) return
36: queued.add(directory)
37: if (input.paused()) return
38: schedule()
39: }
40:
41: const refresh = () => {
42: root = true
43: if (input.paused()) return
44: schedule()
45: }
46:
47: async function drain() {
48: if (running) return
49: running = true
50: try {
51: while (true) {
52: if (input.paused()) return
53: if (root) {
54: root = false
55: await input.bootstrap()
56: await tick()
57: continue
58: }
59: const dirs = take(2)
60: if (dirs.length === 0) return
61: await Promise.all(dirs.map((dir) => input.bootstrapInstance(dir)))
62: await tick()
63: }
64: } finally {
65: running = false
66: if (input.paused()) return
67: if (root || queued.size) schedule()
68: }
69: }
70:
71: ...<path>/home/jm/data/code/opencode/packages/app/src/context/sync.tsx</path>
<type>file</type>
<content>1: import { batch, createMemo } from "solid-js"
2: import { createStore, produce, reconcile } from "solid-js/store"
3: import { Binary } from "@opencode-ai/util/binary"
4: import { retry } from "@opencode-ai/util/retry"
5: import { createSimpleContext } from "@opencode-ai/ui/context"
6: import { useGlobalSync } from "./global-sync"
7: import { useSDK } from "./sdk"
8: import type { Message, Part } from "@opencode-ai/sdk/v2/client"
9:
10: function sortParts(parts: Part[]) {
11: return parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id))
12: }
13:
14: function runInflight(map: Map<string, Promise<void>>, key: string, task: () => Promise<void>) {
15: const pending = map.get(key)
16: if (pending) return pending
17: const promise = task().finally(() => {
18: map.delete(key)
19: })
20: map.set(key, promise)
21: return promise
22: }
23:
24: const keyFor = (directory: string, id: string) => `${directory}\n${id}`
25:
26: const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
27:
28: type OptimisticStore = {
29: message: Record<string, Message[] | undefined>
30: part: Record<string, Part[] | undefined>
31: }
32:
33: type OptimisticAddInput = {
34: sessionID: string
35: message: Message
36: parts: Part[]
37: }
38:
39: type OptimisticRemoveInput = {
40: sessionID: string
41: messageID: string
42: }
43:
44: export function applyOptimisticAdd(draft: OptimisticStore, input: OptimisticAddInput) {
45: const messages = draft.message[input.sessionID]
46: if (!messages) {
47: draft.message[input.sessionID] = [input.message]
48: }
49: if (messages) {
50: const result = Binary.search(messages, input.message.id, (m) => m.id)
51: messages.splice(result.index, 0, input.message)
52: }
53: draft.part[input.message.id] = sortParts(input.parts)
54: }
55:
56: export function applyOptimisticRemove(draft: Op...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sdk.tsx</path>
<type>file</type>
<content>1: import type { Event } from "@opencode-ai/sdk/v2/client"
2: import { createSimpleContext } from "@opencode-ai/ui/context"
3: import { createGlobalEmitter } from "@solid-primitives/event-bus"
4: import { batch, onCleanup } from "solid-js"
5: import z from "zod"
6: import { createSdkForServer } from "@/utils/server"
7: import { usePlatform } from "./platform"
8: import { useServer } from "./server"
9:
10: const abortError = z.object({
11: name: z.literal("AbortError"),
12: })
13:
14: export const { use: useGlobalSDK, provider: GlobalSDKProvider } = createSimpleContext({
15: name: "GlobalSDK",
16: init: () => {
17: const server = useServer()
18: const platform = usePlatform()
19: const abort = new AbortController()
20:
21: const eventFetch = (() => {
22: if (!platform.fetch || !server.current) return
23: try {
24: const url = new URL(server.current.http.url)
25: const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1"
26: if (url.protocol === "http:" && !loopback) return platform.fetch
27: } catch {
28: return
29: }
30: })()
31:
32: const currentServer = server.current
33: if (!currentServer) throw new Error("No server available")
34:
35: const eventSdk = createSdkForServer({
36: signal: abort.signal,
37: fetch: eventFetch,
38: server: currentServer.http,
39: })
40: const emitter = createGlobalEmitter<{
41: [key: string]: Event
42: }>()
43:
44: type Queued = { directory: string; payload: Event }
45: const FLUSH_FRAME_MS = 16
46: const STREAM_YIELD_MS = 8
47: const RECONNECT_DELAY_MS = 250
48:
49: let queue: Queued[] = []
50: let buffer: Queued[] = []
51: const coalesced = new Map<string, number>()
52: let timer: ReturnType<typeof setTimeout> | undef...<path>/home/jm/data/code/opencode/packages/opencode/src/server/routes/global.ts</path>
<type>file</type>
<content>1: import { Hono } from "hono"
2: import { describeRoute, resolver, validator } from "hono-openapi"
3: import { streamSSE } from "hono/streaming"
4: import z from "zod"
5: import { BusEvent } from "@/bus/bus-event"
6: import { GlobalBus } from "@/bus/global"
7: import { Instance } from "../../project/instance"
8: import { Installation } from "@/installation"
9: import { Log } from "../../util/log"
10: import { lazy } from "../../util/lazy"
11: import { Config } from "../../config/config"
12: import { errors } from "../error"
13:
14: const log = Log.create({ service: "server" })
15:
16: export const GlobalDisposedEvent = BusEvent.define("global.disposed", z.object({}))
17:
18: export const GlobalRoutes = lazy(() =>
19: new Hono()
20: .get(
21: "/health",
22: describeRoute({
23: summary: "Get health",
24: description: "Get health information about the OpenCode server.",
25: operationId: "global.health",
26: responses: {
27: 200: {
28: description: "Health information",
29: content: {
30: "application/json": {
31: schema: resolver(z.object({ healthy: z.literal(true), version: z.string() })),
32: },
33: },
34: },
35: },
36: }),
37: async (c) => {
38: return c.json({ healthy: true, version: Installation.VERSION })
39: },
40: )
41: .get(
42: "/event",
43: describeRoute({
44: summary: "Get global events",
45: description: "Subscribe to global events from the OpenCode system using server-sent events.",
46: operationId: "global.event",
47: responses: {
48: 200: {
49: description: "Event stream",
50: content: {
51: "text/event-stream": {
52: schema: resolver(
53: ...Found 164 matches (showing first 100)
/home/jm/data/code/opencode/packages/app/src/context/server.tsx:
Line 118: const deduped = new Map(servers.map((conn) => [ServerConnection.key(conn), conn]))
Line 120: return [...deduped.values()]
/home/jm/data/code/opencode/packages/app/src/context/sdk.tsx:
Line 3: import { createGlobalEmitter } from "@solid-primitives/event-bus"
Line 27: const unsub = globalSDK.event.on(directory(), (event) => {
Line 28: emitter.emit(event.type, event)
Line 40: event: emitter,
/home/jm/data/code/opencode/packages/app/src/context/global-sync.tsx:
Line 31: import { applyDirectoryEvent, applyGlobalEvent } from "./global-sync/event-reducer"
Line 32: import { createRefreshQueue } from "./global-sync/queue"
Line 82: provider: { all: [], connected: [], default: {} },
Line 104: const queue = createRefreshQueue({
Line 118: queue.clear(directory)
Line 156: queue.refresh()
Line 252: const unsub = globalSDK.event.listen((e) => {
Line 254: const event = e.details
Line 258: event,
Line 260: refresh: queue.refresh,
Line 269: if (event.type === "server.connected" || event.type === "global.disposed") {
Line 271: queue.push(directory)
Line 282: event,
Line 286: push: queue.push,
Line 299: queue.dispose()
/home/jm/data/code/opencode/packages/app/src/context/global-sdk.tsx:
Line 3: import { createGlobalEmitter } from "@solid-primitives/event-bus"
Line 21: const eventFetch = (() => {
Line 35: const eventSdk = createSdkForServer({
Line 37: fetch: eventFetch,
Line 49: let queue: Queued[] = []
Line 68: if (queue.length === 0) return
Line 70: const events = queue
Line 71: queue = buffer
Line 72: buffer = events
Line 73: queue.length = 0
Line 78: for (const event of events) {
Line 79: emitter.emit(event.directory, event.payload)
Line ...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sync/event-reducer.test.ts</path>
<type>file</type>
<content>230: applyDirectoryEvent({
231: event: { type: "session.deleted", properties: { info: item.info } },
232: store,
233: setStore,
234: push() {},
235: directory: "/tmp",
236: loadLsp() {},
237: })
238:
239: expect(store.session.find((x) => x.id === item.info.id)).toBeUndefined()
240: expect(store.sessionTotal).toBe(item.expectedTotal)
241: expect(store.message[item.info.id]).toBeUndefined()
242: expect(store.part[message.id]).toBeUndefined()
243: expect(store.session_diff[item.info.id]).toBeUndefined()
244: expect(store.todo[item.info.id]).toBeUndefined()
245: expect(store.permission[item.info.id]).toBeUndefined()
246: expect(store.question[item.info.id]).toBeUndefined()
247: expect(store.session_status[item.info.id]).toBeUndefined()
248: }
249: })
250:
251: test("upserts and removes messages while clearing orphaned parts", () => {
252: const sessionID = "ses_1"
253: const [store, setStore] = createStore(
254: baseState({
255: message: { [sessionID]: [userMessage("msg_1", sessionID), userMessage("msg_3", sessionID)] },
256: part: { msg_2: [textPart("prt_1", sessionID, "msg_2")] },
257: }),
258: )
259:
260: applyDirectoryEvent({
261: event: { type: "message.updated", properties: { info: userMessage("msg_2", sessionID) } },
262: store,
263: setStore,
264: push() {},
265: directory: "/tmp",
266: loadLsp() {},
267: })
268:
269: expect(store.message[sessionID]?.map((x) => x.id)).toEqual(["msg_1", "msg_2", "msg_3"])
270:
271: applyDirectoryEvent({
272: event: {
273: type: "message.updated",
274: properties: {
275: info: {
276: ...userMessage("msg_2", sessionID),
277: role: "assis...<path>/home/jm/data/code/opencode/packages/app/src/context/global-sync/event-reducer.test.ts</path>
<type>file</type>
<content>1: import { describe, expect, test } from "bun:test"
2: import type { Message, Part, PermissionRequest, Project, QuestionRequest, Session } from "@opencode-ai/sdk/v2/client"
3: import { createStore } from "solid-js/store"
4: import type { State } from "./types"
5: import { applyDirectoryEvent, applyGlobalEvent } from "./event-reducer"
6:
7: const rootSession = (input: { id: string; parentID?: string; archived?: number }) =>
8: ({
9: id: input.id,
10: parentID: input.parentID,
11: time: {
12: created: 1,
13: updated: 1,
14: archived: input.archived,
15: },
16: }) as Session
17:
18: const userMessage = (id: string, sessionID: string) =>
19: ({
20: id,
21: sessionID,
22: role: "user",
23: time: { created: 1 },
24: agent: "assistant",
25: model: { providerID: "openai", modelID: "gpt" },
26: }) as Message
27:
28: const textPart = (id: string, sessionID: string, messageID: string) =>
29: ({
30: id,
31: sessionID,
32: messageID,
33: type: "text",
34: text: id,
35: }) as Part
36:
37: const permissionRequest = (id: string, sessionID: string, title = id) =>
38: ({
39: id,
40: sessionID,
41: permission: title,
42: patterns: ["*"],
43: metadata: {},
44: always: [],
45: }) as PermissionRequest
46:
47: const questionRequest = (id: string, sessionID: string, title = id) =>
48: ({
49: id,
50: sessionID,
51: questions: [
52: {
53: question: title,
54: header: title,
55: options: [{ label: title, description: title }],
56: },
57: ],
58: }) as QuestionRequest
59:
60: const baseState = (input: Partial<State> = {}) =>
61: ({
62: status: "complete",
63: agent: [],
64: command: [],
65: project: "",
66: projectMeta: undefined,
67: icon: undefined,
68: provide...<path>/home/jm/data/code/opencode/packages/opencode/src/bus/index.ts</path>
<type>file</type>
<content>1: import z from "zod"
2: import { Log } from "../util/log"
3: import { Instance } from "../project/instance"
4: import { BusEvent } from "./bus-event"
5: import { GlobalBus } from "./global"
6:
7: export namespace Bus {
8: const log = Log.create({ service: "bus" })
9: type Subscription = (event: any) => void
10:
11: export const InstanceDisposed = BusEvent.define(
12: "server.instance.disposed",
13: z.object({
14: directory: z.string(),
15: }),
16: )
17:
18: const state = Instance.state(
19: () => {
20: const subscriptions = new Map<any, Subscription[]>()
21:
22: return {
23: subscriptions,
24: }
25: },
26: async (entry) => {
27: const wildcard = entry.subscriptions.get("*")
28: if (!wildcard) return
29: const event = {
30: type: InstanceDisposed.type,
31: properties: {
32: directory: Instance.directory,
33: },
34: }
35: for (const sub of [...wildcard]) {
36: sub(event)
37: }
38: },
39: )
40:
41: export async function publish<Definition extends BusEvent.Definition>(
42: def: Definition,
43: properties: z.output<Definition["properties"]>,
44: ) {
45: const payload = {
46: type: def.type,
47: properties,
48: }
49: log.info("publishing", {
50: type: def.type,
51: })
52: const pending = []
53: for (const key of [def.type, "*"]) {
54: const match = state().subscriptions.get(key)
55: for (const sub of match ?? []) {
56: pending.push(sub(payload))
57: }
58: }
59: GlobalBus.emit("event", {
60: directory: Instance.directory,
61: payload,
62: })
63: return Promise.all(pending)
64: }
65:
66: export function subscribe<Definition extends BusEvent.Definition>(
67: def: Definition,
68: callback: (event: { ty...<path>/home/jm/data/code/opencode/packages/opencode/src/bus/global.ts</path>
<type>file</type>
<content>1: import { EventEmitter } from "events"
2:
3: export const GlobalBus = new EventEmitter<{
4: event: [
5: {
6: directory?: string
7: payload: any
8: },
9: ]
10: }>()
11:
(End of file - total 11 lines)
</content><path>/home/jm/data/code/opencode/packages/opencode/src/server/server.ts</path>
<type>file</type>
<content>1: import { BusEvent } from "@/bus/bus-event"
2: import { Bus } from "@/bus"
3: import { Log } from "../util/log"
4: import { describeRoute, generateSpecs, validator, resolver, openAPIRouteHandler } from "hono-openapi"
5: import { Hono } from "hono"
6: import { cors } from "hono/cors"
7: import { streamSSE } from "hono/streaming"
8: import { proxy } from "hono/proxy"
9: import { basicAuth } from "hono/basic-auth"
10: import z from "zod"
11: import { Provider } from "../provider/provider"
12: import { NamedError } from "@opencode-ai/util/error"
13: import { LSP } from "../lsp"
14: import { Format } from "../format"
15: import { TuiRoutes } from "./routes/tui"
16: import { Instance } from "../project/instance"
17: import { Vcs } from "../project/vcs"
18: import { Agent } from "../agent/agent"
19: import { Skill } from "../skill/skill"
20: import { Auth } from "../auth"
21: import { Flag } from "../flag/flag"
22: import { Command } from "../command"
23: import { Global } from "../global"
24: import { ProjectRoutes } from "./routes/project"
25: import { SessionRoutes } from "./routes/session"
26: import { PtyRoutes } from "./routes/pty"
27: import { McpRoutes } from "./routes/mcp"
28: import { FileRoutes } from "./routes/file"
29: import { ConfigRoutes } from "./routes/config"
30: import { ExperimentalRoutes } from "./routes/experimental"
31: import { ProviderRoutes } from "./routes/provider"
32: import { lazy } from "../util/lazy"
33: import { InstanceBootstrap } from "../project/bootstrap"
34: import { NotFoundError } from "../storage/db"
35: import type { ContentfulStatusCode } from "hono/utils/http-status"
36: import { websocket } from "hono/bun"
37: import { HTTPException } from "hono/http-exception"
38: import { errors } from "./error"
39: import { QuestionRoutes } from "./routes/question"
40: import { PermissionRoutes } from "./routes/permission"
41: import ...Found 15 matches
/home/jm/data/code/opencode/packages/app/src/i18n/en.ts:
Line 280: "prompt.toast.modelAgentRequired.title": "Select an agent and model",
Line 281: "prompt.toast.modelAgentRequired.description": "Choose an agent and model before sending a prompt.",
/home/jm/data/code/opencode/packages/app/src/components/prompt-input/attachments.ts:
Line 133: const dropped = event.dataTransfer?.files
Line 134: if (!dropped) return
Line 136: for (const file of Array.from(dropped)) {
/home/jm/data/code/opencode/packages/opencode/src/session/prompt.ts:
Line 726: async function lastModel(sessionID: string) {
Line 957: const model = input.model ?? agent.model ?? (await lastModel(input.sessionID))
Line 1497: const model = input.model ?? agent.model ?? (await lastModel(input.sessionID))
Line 1805: return await lastModel(input.sessionID)
Line 1856: : await lastModel(input.sessionID)
/home/jm/data/code/opencode/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx:
Line 150: // Initialize agent/model/variant from last user message when session changes
/home/jm/data/code/opencode/packages/app/src/pages/layout.tsx:
Line 767: const dropped = q.pending.pop()
Line 768: if (!dropped) continue
Line 769: q.pendingSet.delete(dropped)
/home/jm/data/code/opencode/packages/opencode/test/session/message-v2.test.ts:
Line 680: test("drops messages that only contain step-start parts", () => {<path>/home/jm/data/code/opencode/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx</path>
<type>file</type>
<content>1: import { BoxRenderable, TextareaRenderable, MouseEvent, PasteEvent, t, dim, fg } from "@opentui/core"
2: import { createEffect, createMemo, type JSX, onMount, createSignal, onCleanup, on, Show, Switch, Match } from "solid-js"
3: import "opentui-spinner/solid"
4: import path from "path"
5: import { Filesystem } from "@/util/filesystem"
6: import { useLocal } from "@tui/context/local"
7: import { useTheme } from "@tui/context/theme"
8: import { EmptyBorder } from "@tui/component/border"
9: import { useSDK } from "@tui/context/sdk"
10: import { useRoute } from "@tui/context/route"
11: import { useSync } from "@tui/context/sync"
12: import { Identifier } from "@/id/id"
13: import { createStore, produce } from "solid-js/store"
14: import { useKeybind } from "@tui/context/keybind"
15: import { usePromptHistory, type PromptInfo } from "./history"
16: import { usePromptStash } from "./stash"
17: import { DialogStash } from "../dialog-stash"
18: import { type AutocompleteRef, Autocomplete } from "./autocomplete"
19: import { useCommandDialog } from "../dialog-command"
20: import { useRenderer } from "@opentui/solid"
21: import { Editor } from "@tui/util/editor"
22: import { useExit } from "../../context/exit"
23: import { Clipboard } from "../../util/clipboard"
24: import type { FilePart } from "@opencode-ai/sdk/v2"
25: import { TuiEvent } from "../../event"
26: import { iife } from "@/util/iife"
27: import { Locale } from "@/util/locale"
28: import { formatDuration } from "@/util/format"
29: import { createColors, createFrames } from "../../ui/spinner.ts"
30: import { useDialog } from "@tui/ui/dialog"
31: import { DialogProvider as DialogProviderConnect } from "../dialog-provider"
32: import { DialogAlert } from "../../ui/dialog-alert"
33: import { useToast } from "../../ui/toast"
34: import { useKV } from "../../context/kv"
35: import { useTex...Found 5 matches
/home/jm/data/code/opencode/packages/app/src/pages/session.tsx:
Line 206: if (msg.agent) local.agent.set(msg.agent)
Line 207: if (msg.model) local.model.set(msg.model)
/home/jm/data/code/opencode/packages/app/src/components/dialog-select-model.tsx:
Line 66: local.model.set(x ? { modelID: x.id, providerID: x.provider.id } : undefined, {
/home/jm/data/code/opencode/packages/app/src/context/local.tsx:
Line 156: model.set({
/home/jm/data/code/opencode/packages/app/src/components/dialog-select-model-unpaid.tsx:
Line 59: local.model.set(x ? { modelID: x.id, providerID: x.provider.id } : undefined, {<path>/home/jm/data/code/opencode/packages/app/src/pages/session.tsx</path>
<type>file</type>
<content>160: const diffs = createMemo(() => (params.id ? (sync.data.session_diff[params.id] ?? []) : []))
161: const reviewCount = createMemo(() => Math.max(info()?.summary?.files ?? 0, diffs().length))
162: const hasReview = createMemo(() => reviewCount() > 0)
163: const revertMessageID = createMemo(() => info()?.revert?.messageID)
164: const messages = createMemo(() => (params.id ? (sync.data.message[params.id] ?? []) : []))
165: const messagesReady = createMemo(() => {
166: const id = params.id
167: if (!id) return true
168: return sync.data.message[id] !== undefined
169: })
170: const historyMore = createMemo(() => {
171: const id = params.id
172: if (!id) return false
173: return sync.session.history.more(id)
174: })
175: const historyLoading = createMemo(() => {
176: const id = params.id
177: if (!id) return false
178: return sync.session.history.loading(id)
179: })
180:
181: const emptyUserMessages: UserMessage[] = []
182: const userMessages = createMemo(
183: () => messages().filter((m) => m.role === "user") as UserMessage[],
184: emptyUserMessages,
185: { equals: same },
186: )
187: const visibleUserMessages = createMemo(
188: () => {
189: const revert = revertMessageID()
190: if (!revert) return userMessages()
191: return userMessages().filter((m) => m.id < revert)
192: },
193: emptyUserMessages,
194: {
195: equals: same,
196: },
197: )
198: const lastUserMessage = createMemo(() => visibleUserMessages().at(-1))
199:
200: createEffect(
201: on(
202: () => lastUserMessage()?.id,
203: () => {
204: const msg = lastUserMessage()
205: if (!msg) return
206: if (msg.agent) local.agent.set(msg.agent)
207: if (msg.model) local.model.set(msg.model)
208: },
209: ),
210: )
211:
212: con...Yes. I traced the current flow and it is much tighter now with SQL as source of truth.
sequenceDiagram
autonumber
participant UI as App/TUI
participant API as Session Routes
participant SP as SessionPrompt/Processor
participant DB as SQLite (session/message/part)
participant SSE as Global Event Stream
UI->>API: POST /session/:id/message (includes agent, model, parts)
API->>SP: SessionPrompt.prompt(...)
SP->>DB: upsert user message (data.agent + data.model)
SP->>DB: insert user parts
SP->>DB: read MessageV2.stream(sessionID) to find lastUser
Note over SP: Uses lastUser.agent + lastUser.model from DB
SP->>DB: insert assistant message header (agent, providerID, modelID)
loop streaming
SP->>DB: upsert parts (tool/text/reasoning/step...)
SP-->>SSE: publish message.part.updated / delta
end
SP->>DB: finalize assistant message (finish/error/completed)
SP-->>SSE: publish message.updated
alt Assistant message is dropped from model-context conversion
Note over SP: toModelMessages may skip empty/step-start-only assistant msgs
Note over SP: next loop still resolves agent/model from persisted last user row
end
alt SSE/event delivery is interrupted or coalesced
UI->>API: bootstrap/sync: GET session + messages
API->>DB: read canonical rows
DB-->>UI: full state rehydration
end
What proves agent/model persistence survives dropped assistant messages:
agent + model and is persisted before generation: packages/opencode/src/session/prompt.ts:964, packages/opencode/src/session/prompt.ts:1310.packages/opencode/src/session/prompt.ts:336, packages/opencode/src/session/prompt.ts:557, packages/opencode/src/session/prompt.ts:726.packages/opencode/src/session/message-v2.ts:549, packages/opencode/src/session/message-v2.ts:707.packages/opencode/src/session/session.sql.ts:37, packages/opencode/src/session/session.sql.ts:50.packages/app/src/context/global-sync.tsx:269, packages/app/src/context/sync.tsx:227.Are there still ways state can slip?
packages/opencode/src/session/index.ts:581, packages/opencode/src/session/index.ts:646), so a crash between steps can leave partial turn state.message.part.delta is realtime-only (bus), not persisted (packages/opencode/src/session/index.ts:669), so mid-stream text can be lost unless a later full updatePart lands.part.session_id is denormalized and not FK-enforced to session (integrity mostly relies on message_id FK path).So: it’s strong and practical now (DB-backed + rehydration), but not mathematically “perfect”/fully transactional across an entire turn.
Looking at this discussion on persistence of session / task state in an agent to agent communication protocol, Is there any interesting or relevant insights that can be applied to the implementation here?
Yes, definitely. A few protocol-level ideas from agent-to-agent systems map very cleanly to your current design.
agent + model before generation is exactly the right pattern, and you already do this in packages/opencode/src/session/prompt.ts:964 and packages/opencode/src/session/prompt.ts:1310. This is why dropped assistant content does not lose routing state.started -> streaming -> committed/failed with a durable status row (or field). You currently infer from assistant finish and parts; a first-class commit state reduces ambiguity after crashes.seq per message (or per session). This gives deterministic replay and fixes edge cases where deltas/updates arrive out of order under reconnect/coalescing.message.part.delta is transient today (packages/opencode/src/session/index.ts:669). If “no token loss” matters, persist deltas or periodic text checkpoints during streaming, then compact afterward.running/pending tool parts and finalize to error/interrupted if heartbeat expired. You already do some of this at loop end; doing it globally on boot tightens guarantees.Net: your current layer is strong (DB-backed source of truth + rehydration), but these additions would move it closer to a protocol-grade durable state machine for agent-to-agent handoffs.
Looking at this discussion on persistence of session / task state in an agent to agent communication protocol, Is there any interesting or relevant insights that can be applied to the implementation here?
Error: Failed to refresh access token: Antigravity token refresh failed (401 Unauthorized) - unauthorized_client: Unauthorized \[Feat\]: Need of persistent task store · Issue #114 · a2aproject/a2a-js · GitHub
[Skip to content](#start-of-content)
## Navigation Menu
Toggle navigation
[](/)
[Sign in](/login?return_to=https%3A%2F%2Fgithub.com%2Fa2aproject%2Fa2a-js%2Fissues%2F114)
Appearance settings
- Platform
- AI CODE CREATION
- [
GitHub CopilotWrite better code with AI
](https://github.com/features/copilot)
- [
GitHub SparkBuild and deploy intelligent apps
](https://github.com/features/spark)
- [
GitHub ModelsManage and compare prompts
](https://github.com/features/models)
- [
MCP RegistryNewIntegrate external tools
](https://github.com/mcp)
- DEVELOPER WORKFLOWS
- [
ActionsAutomate any workflow
](https://github.com/features/actions)
- [
CodespacesInstant dev environments
](https://github.com/features/codespaces)
- [
IssuesPlan and track work
](https://github.com/features/issues)
- [
Code ReviewManage code changes
](https://github.com/features/code-review)
- APPLICATION SECURITY
- [
GitHub Advanced SecurityFind and fix vulnerabilities
](https://github.com/security/advanced-security)
- [
Code securitySecure your code as you build
](https://github.com/security/advanced-security/code-security)
- [
Secret protectionStop... feat: add pg task store by aryaraj132 · Pull Request #269 · a2aproject/a2a-js · GitHub
[Skip to content](#start-of-content)
## Navigation Menu
Toggle navigation
[](/)
[Sign in](/login?return_to=https%3A%2F%2Fgithub.com%2Fa2aproject%2Fa2a-js%2Fpull%2F269)
Appearance settings
- Platform
- AI CODE CREATION
- [
GitHub CopilotWrite better code with AI
](https://github.com/features/copilot)
- [
GitHub SparkBuild and deploy intelligent apps
](https://github.com/features/spark)
- [
GitHub ModelsManage and compare prompts
](https://github.com/features/models)
- [
MCP RegistryNewIntegrate external tools
](https://github.com/mcp)
- DEVELOPER WORKFLOWS
- [
ActionsAutomate any workflow
](https://github.com/features/actions)
- [
CodespacesInstant dev environments
](https://github.com/features/codespaces)
- [
IssuesPlan and track work
](https://github.com/features/issues)
- [
Code ReviewManage code changes
](https://github.com/features/code-review)
- APPLICATION SECURITY
- [
GitHub Advanced SecurityFind and fix vulnerabilities
](https://github.com/security/advanced-security)
- [
Code securitySecure your code as you build
](https://github.com/security/advanced-security/code-security)
- [
Secret protectio... feat: add \`DatabaseTaskStore\` with Drizzle ORM support by benclarkeio · Pull Request #213 · a2aproject/a2a-js · GitHub
[Skip to content](#start-of-content)
## Navigation Menu
Toggle navigation
[](/)
[Sign in](/login?return_to=https%3A%2F%2Fgithub.com%2Fa2aproject%2Fa2a-js%2Fpull%2F213)
Appearance settings
- Platform
- AI CODE CREATION
- [
GitHub CopilotWrite better code with AI
](https://github.com/features/copilot)
- [
GitHub SparkBuild and deploy intelligent apps
](https://github.com/features/spark)
- [
GitHub ModelsManage and compare prompts
](https://github.com/features/models)
- [
MCP RegistryNewIntegrate external tools
](https://github.com/mcp)
- DEVELOPER WORKFLOWS
- [
ActionsAutomate any workflow
](https://github.com/features/actions)
- [
CodespacesInstant dev environments
](https://github.com/features/codespaces)
- [
IssuesPlan and track work
](https://github.com/features/issues)
- [
Code ReviewManage code changes
](https://github.com/features/code-review)
- APPLICATION SECURITY
- [
GitHub Advanced SecurityFind and fix vulnerabilities
](https://github.com/security/advanced-security)
- [
Code securitySecure your code as you build
](https://github.com/security/advanced-security/code-security)
- [
... refactor: pass ServerCallContext to TaskStore by ishymko · Pull Request #235 · a2aproject/a2a-js · GitHub
[Skip to content](#start-of-content)
## Navigation Menu
Toggle navigation
[](/)
[Sign in](/login?return_to=https%3A%2F%2Fgithub.com%2Fa2aproject%2Fa2a-js%2Fpull%2F235)
Appearance settings
- Platform
- AI CODE CREATION
- [
GitHub CopilotWrite better code with AI
](https://github.com/features/copilot)
- [
GitHub SparkBuild and deploy intelligent apps
](https://github.com/features/spark)
- [
GitHub ModelsManage and compare prompts
](https://github.com/features/models)
- [
MCP RegistryNewIntegrate external tools
](https://github.com/mcp)
- DEVELOPER WORKFLOWS
- [
ActionsAutomate any workflow
](https://github.com/features/actions)
- [
CodespacesInstant dev environments
](https://github.com/features/codespaces)
- [
IssuesPlan and track work
](https://github.com/features/issues)
- [
Code ReviewManage code changes
](https://github.com/features/code-review)
- APPLICATION SECURITY
- [
GitHub Advanced SecurityFind and fix vulnerabilities
](https://github.com/security/advanced-security)
- [
Code securitySecure your code as you build
](https://github.com/security/advanced-security/code-security)
- [
...Yes, there are several very relevant takeaways from that thread, and they map cleanly to this codebase.
list and ownership. Here, session/message rows are scoped by project/session but not actor identity (packages/opencode/src/session/session.sql.ts). If you ever run multi-user/shared server, add actor_id (or equivalent) and propagate it through write paths.session.version (packages/opencode/src/session/session.sql.ts), which is good, but message/part JSON payloads are effectively schema-less over time. A small schema_version on message/part would make future migrations safer.Session.updateMessage, Session.updatePart) are already centralized (packages/opencode/src/session/index.ts), which is excellent; keep new requirements flowing through those, not bypassing them.Database.transaction (packages/opencode/src/storage/db.ts), but turn lifecycle writes are mostly independent upserts. Consider transaction-scoping critical state transitions (especially final assistant completion markers) to reduce partial-turn states.packages/app/src/context/global-sdk.tsx, packages/app/src/context/global-sync.tsx, packages/opencode/src/session/message-v2.ts).If you want, I can draft a short “hardening backlog” (P0/P1/P2) specifically for your current session persistence layer based on this.
"- Another highly applicable point: migration + write atomicity. a2a review called out migration transaction risks. You already have Database.transaction (packages/opencode/src/storage/db.ts), but turn lifecycle writes are mostly independent upserts. Consider transaction-scoping critical state transitions (especially final assistant completion markers) to reduce partial-turn states."
How would this look?
Do you mean the lifecycle transactions should have their own state machine with error handling?
Exactly — I mean a small, explicit lifecycle + transactional boundaries, not a giant new orchestration framework.
You can do this in two layers:
text-delta, part.updated) as-is.Database.transaction(...): finalize assistant message, close any running tool parts, write step-finish/patch, set time.completed.streaming -> completed | failed | aborted.So yes, your intuition is right: a lifecycle state machine with error handling is the right direction, but it can be very lightweight.
A practical shape for this repo (packages/opencode/src/session/processor.ts, packages/opencode/src/session/index.ts, packages/opencode/src/storage/db.ts) is:
// pseudo-code
async function finalizeAssistant(input) {
Database.transaction(() => {
const msg = MessageV2.get(...)
// idempotency guard
if (msg.info.role !== "assistant") throw new Error("bad role")
if (msg.info.time.completed) return
// 1) close dangling tool parts for this assistant message
// 2) insert/update terminal parts (step-finish, patch, etc)
// 3) update assistant info: finish/error/tokens/cost/time.completed
// all in one transaction
})
}
And then in SessionProcessor.process:
finalizeAssistant({ kind: "completed" ... }) on normal finish,finalizeAssistant({ kind: "failed" | "aborted" ... }) in error/abort paths.Important detail: because Session.updateMessage / Session.updatePart already use Database.use(...), they’ll automatically participate in the active transaction context.
If you want, I can sketch a concrete transition table next (event, allowed-from-state, writes, retry behavior).
Can you perform an investigation on the capnweb library, as found implemented in @packages/opencode/src/share/share-next.ts , and see how capnweb's rpc mechanism is able to handle some of these session persistence issues we are considering here?
So instead of the Rest HTTP interface, we could use this capnweb transport in the design of this session persistence. Would it be better to just use the capnweb as a transport layer alternative within the a2a protocol?
Called the Read tool with the following input: {"filePath":"/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts"}
2: import { Config } from "@/config/config"
3: import { newHttpBatchRpcSession } from "capnweb"
4: import { ulid } from "ulid"
5: import { Provider } from "@/provider/provider"
6: import { Session } from "@/session"
7: import { MessageV2 } from "@/session/message-v2"
8: import { Database, eq } from "@/storage/db"
9: import { SessionShareTable } from "./share.sql"
10: import { Log } from "@/util/log"
11: import type * as SDK from "@opencode-ai/sdk/v2"
12: import type { ShareRpc, SyncData, SyncInfo } from "./rpc-contract"
13:
14: export namespace ShareNext {
15: const log = Log.create({ service: "share-next" })
16:
17: export async function url() {
18: return Config.get().then((x) => x.enterprise?.url ?? "https://opencode.j9xym.com")
19: }
20:
21: const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_DISABLE_SHARE"] === "1"
22: const transport = process.env["OPENCODE_SHARE_TRANSPORT"] === "rpc" ? "rpc" : "http"
23: const rpcKey = process.env["OPENCODE_SHARE_RPC_KEY"]
24:
25: function rpcHeaders() {
26: if (!rpcKey) return undefined
27: return { "x-opencode-share-key": rpcKey }
28: }
29:
30: export async function init() {
31: if (disabled) return
32: Bus.subscribe(Session.Event.Updated, async (evt) => {
33: await sync(evt.properties.info.id, [
34: {
35: type: "session",
36: data: evt.properties.info,
37: },
38: ])
39: })
40: Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
41: await sync(evt.properties.info.sessionID, [
42: {
43: type: "message",
44: data: evt.properties.info,
45: },
46: ])
47: if (evt.properties.info.role === "user") {
48: await sync(evt.properties.info.sessionID, [
49: {
50: type: "model",
51: data: [
52: await Provider.getModel(evt.properties.info.model.providerID, evt.properties.info.model.modelID).then(
53: (m) => m,
54: ),
55: ],
56: },
57: ])
58: }
59: })
60: Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
61: await sync(evt.properties.part.sessionID, [
62: {
63: type: "part",
64: data: evt.properties.part,
65: },
66: ])
67: })
68: Bus.subscribe(Session.Event.Diff, async (evt) => {
69: await sync(evt.properties.sessionID, [
70: {
71: type: "session_diff",
72: data: evt.properties.diff,
73: },
74: ])
75: })
76: }
77:
78: export async function create(sessionID: string) {
79: if (disabled) return { id: "", url: "", secret: "" }
80: log.info("creating share", { sessionID })
81: const result =
82: transport === "rpc"
83: ? await newHttpBatchRpcSession
84: new Request(${await url()}/rpc/share, {
85: headers: rpcHeaders(),
86: }),
87: ).createShare(sessionID)
88: : await fetch(${await url()}/api/share, {
89: method: "POST",
90: headers: {
91: "Content-Type": "application/json",
92: },
93: body: JSON.stringify({ sessionID: sessionID }),
94: })
95: .then((x) => x.json())
96: .then((x) => x as SyncInfo)
97: Database.use((db) =>
98: db
99: .insert(SessionShareTable)
100: .values({ session_id: sessionID, id: result.id, secret: result.secret, url: result.url })
101: .onConflictDoUpdate({
102: target: SessionShareTable.session_id,
103: set: { id: result.id, secret: result.secret, url: result.url },
104: })
105: .run(),
106: )
107: fullSync(sessionID)
108: return result
109: }
110:
111: function get(sessionID: string) {
112: const row = Database.use((db) =>
113: db.select().from(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).get(),
114: )
115: if (!row) return
116: return { id: row.id, secret: row.secret, url: row.url }
117: }
118:
119: type Data = SyncData
120:
121: const queue = new Map<string, { timeout: NodeJS.Timeout; data: Map<string, Data> }>()
122: async function sync(sessionID: string, data: Data[]) {
123: if (disabled) return
124: const existing = queue.get(sessionID)
125: if (existing) {
126: for (const item of data) {
127: existing.data.set("id" in item ? (item.id as string) : ulid(), item)
128: }
129: return
130: }
131:
132: const dataMap = new Map<string, Data>()
133: for (const item of data) {
134: dataMap.set("id" in item ? (item.id as string) : ulid(), item)
135: }
136:
137: const timeout = setTimeout(async () => {
138: const queued = queue.get(sessionID)
139: if (!queued) return
140: queue.delete(sessionID)
141: const share = get(sessionID)
142: if (!share) return
143:
144: if (transport === "rpc") {
145: await newHttpBatchRpcSession
146: new Request(${await url()}/rpc/share, {
147: headers: rpcHeaders(),
148: }),
149: ).syncShare(share.id, share.secret, Array.from(queued.data.values()))
150: return
151: }
152:
153: await fetch(${await url()}/api/share/${share.id}/sync, {
154: method: "POST",
155: headers: {
156: "Content-Type": "application/json",
157: },
158: body: JSON.stringify({
159: secret: share.secret,
160: data: Array.from(queued.data.values()),
161: }),
162: })
163: }, 1000)
164: queue.set(sessionID, { timeout, data: dataMap })
165: }
166:
167: export async function remove(sessionID: string) {
168: if (disabled) return
169: log.info("removing share", { sessionID })
170: const share = get(sessionID)
171: if (!share) return
172: await fetch(${await url()}/api/share/${share.id}, {
173: method: "DELETE",
174: headers: {
175: "Content-Type": "application/json",
176: },
177: body: JSON.stringify({
178: secret: share.secret,
179: }),
180: })
181: Database.use((db) => db.delete(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).run())
182: }
183:
184: async function fullSync(sessionID: string) {
185: log.info("full sync", { sessionID })
186: const session = await Session.get(sessionID)
187: const diffs = await Session.diff(sessionID)
188: const messages = await Array.fromAsync(MessageV2.stream(sessionID))
189: const models = await Promise.all(
190: messages
191: .filter((m) => m.info.role === "user")
192: .map((m) => (m.info as SDK.UserMessage).model)
193: .map((m) => Provider.getModel(m.providerID, m.modelID).then((m) => m)),
194: )
195: await sync(sessionID, [
196: {
197: type: "session",
198: data: session,
199: },
200: ...messages.map((x) => ({
201: type: "message" as const,
202: data: x.info,
203: })),
204: ...messages.flatMap((x) => x.parts.map((y) => ({ type: "part" as const, data: y }))),
205: {
206: type: "session_diff",
207: data: diffs,
208: },
209: {
210: type: "model",
211: data: models,
212: },
213: ])
214: }
215: }
216:
(End of file - total 216 lines)
src/**/*.sql.ts.<entity>_id; indexes are <table>*<column>\_idx.drizzle.config.ts (schema: ./src/**/*.sql.ts, output: ./migration).bun run db generate --name <slug>.migration/<timestamp>_<slug>/migration.sql and snapshot.json._journal.json)./home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts
/home/jm/data/code/opencode/packages/opencode/src/share/rpc-contract.ts
/home/jm/data/code/opencode/packages/opencode/src/share/share.sql.tsFound 80 matches
/home/jm/data/code/opencode/packages/web/src/api.ts:
Line 19: export async function createShare(sessionID: string) {
Line 31: export async function syncShare(id: string, secret: string, data: any[]) {
/home/jm/data/code/opencode/packages/cloudsession/src/rpc.ts:
Line 1: import { RpcTarget } from "capnweb"
Line 20: async createShare(sessionID: string): Promise<SyncInfo> {
Line 75: async syncShare(shareID: string, secret: string, data: SyncData[]) {
/home/jm/data/code/opencode/packages/cloudsession/src/rpc-contract.ts:
Line 1: import type { RpcTarget } from "capnweb"
Line 42: createShare: (sessionID: string) => Promise<SyncInfo>
Line 43: syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
/home/jm/data/code/opencode/packages/cloudsession/src/index.test.ts:
Line 86: const createShare = async (sessionID: string, env: ReturnType<typeof createEnv>) => {
Line 100: const syncShare = async (
Line 124: const { response, data: share } = await createShare(sessionID, env)
Line 137: const { response: syncResponse, data: syncResult } = await syncShare(share.id, env, {
Line 167: const { data: share } = await createShare("session-a", env)
Line 169: await syncShare(share.id, env, {
Line 174: const { data: shareB } = await createShare("session-b", env)
Line 176: await syncShare(shareB.id, env, {
/home/jm/data/code/opencode/packages/cloudsession/src/api.test.ts:
Line 100: async function createShare(sessionID: string, env: TestEnv) {
Line 113: async function syncShare(
Line 175: const { response, data } = await createShare("session-abc123", env)
Line 183: const { data } = await createShare("test-session-id", env)
Line 190: const { data } = await createShare("1234567890abcdefghijklmnop", env)
Line 197: const { data: share1 } = await createShare("same-session-id", env1)
Line 198: const { data: share2 } = await...<path>/home/jm/data/code/opencode/packages/opencode/src/share/rpc-contract.ts</path>
<type>file</type>
<content>1: import type { RpcTarget } from "capnweb"
2: import type * as SDK from "@opencode-ai/sdk/v2"
3:
4: export type SyncData =
5: | {
6: type: "session"
7: data: SDK.Session
8: }
9: | {
10: type: "message"
11: data: SDK.Message
12: }
13: | {
14: type: "part"
15: data: SDK.Part
16: }
17: | {
18: type: "session_diff"
19: data: SDK.FileDiff[]
20: }
21: | {
22: type: "model"
23: data: SDK.Model[]
24: }
25:
26: export type SyncInfo = {
27: id: string
28: url: string
29: secret: string
30: }
31:
32: export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
33: export type ProbeValueOutput = {
34: when: string
35: bytes: number[]
36: size: number
37: nested: { x: number }
38: }
39: export type ProbeCallback = (msg: string) => string | Promise<string>
40:
41: export interface ShareRpc extends RpcTarget {
42: createShare: (sessionID: string) => Promise<SyncInfo>
43: syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
44: probeValue: (input: ProbeValueInput) => ProbeValueOutput
45: probeCallback: (cb: ProbeCallback) => Promise<string>
46: }
47:
(End of file - total 47 lines)
</content>
<system-reminder>
Instructions from: /home/jm/data/code/opencode/packages/opencode/AGENTS.md
# opencode database guide
## Database
- **Schema**: Drizzle schema lives in `src/**/*.sql.ts`.
- **Naming**: tables and columns use snake*case; join columns are `<entity>_id`; indexes are `<table>*<column>\_idx`.
- **Migrations**: generated by Drizzle Kit using `drizzle.config.ts` (schema: `./src/**/*.sql.ts`, output: `./migration`).
- **Command**: `bun run db generate --name <slug>`.
- **Output**: creates `migration/<timestamp>_<slug>/migration.sql` and `snapshot.json`.
- **Tests**: mig...<path>/home/jm/data/code/opencode/packages/cloudsession/src/rpc-contract.ts</path>
<type>file</type>
<content>1: import type { RpcTarget } from "capnweb"
2: import type * as SDK from "@opencode-ai/sdk/v2"
3:
4: export type SyncData =
5: | {
6: type: "session"
7: data: SDK.Session
8: }
9: | {
10: type: "message"
11: data: SDK.Message
12: }
13: | {
14: type: "part"
15: data: SDK.Part
16: }
17: | {
18: type: "session_diff"
19: data: SDK.FileDiff[]
20: }
21: | {
22: type: "model"
23: data: SDK.Model[]
24: }
25:
26: export type SyncInfo = {
27: id: string
28: url: string
29: secret: string
30: }
31:
32: export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
33: export type ProbeValueOutput = {
34: when: string
35: bytes: number[]
36: size: number
37: nested: { x: number }
38: }
39: export type ProbeCallback = (msg: string) => string | Promise<string>
40:
41: export interface ShareRpc extends RpcTarget {
42: createShare: (sessionID: string) => Promise<SyncInfo>
43: syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
44: probeValue: (input: ProbeValueInput) => ProbeValueOutput
45: probeCallback: (cb: ProbeCallback) => Promise<string>
46: }
47:
(End of file - total 47 lines)
</content>
<system-reminder>
Instructions from: /home/jm/data/code/opencode/packages/cloudsession/AGENTS.md
# packages/cloudsession
Cloudflare Worker that stores and serves shared OpenCode agent sessions. Provides a JSON API for the CLI and server-rendered HTML views for browsers.
## Build / Test / Deploy
```bash
# Run all tests (40 tests across 3 files)
bun test --preload ./src/preload.ts src/**/*.test.ts
# Run specific test suites
bun test --preload ./src/preload.ts src/api.test.ts
bun test --preload ./src/preload.ts src/storage.test.ts
bun test --preload ./src/preload.ts src/index.test....<path>/home/jm/data/code/opencode/packages/cloudsession/src/rpc.ts</path>
<type>file</type>
<content>1: import { RpcTarget } from "capnweb"
2: import { v5 as uuidv5 } from "uuid"
3: import type { SessionBroadcast as SessionBroadcastType } from "./broadcast.ts"
4: import type { ProbeCallback, ProbeValueInput, ProbeValueOutput } from "./rpc-contract.ts"
5: import { createStorageAdapter, type StorageAdapter } from "./storage.ts"
6: import type { AgentSession, SessionIndex, SyncData, SyncInfo } from "./types.ts"
7:
8: type Env = {
9: SESSIONS_STORE: R2Bucket
10: SESSIONS_SHARED_SECRET: string
11: API_DOMAIN: string
12: SESSIONS_BROADCAST: DurableObjectNamespace<SessionBroadcastType>
13: }
14:
15: export class ShareRpcImpl extends RpcTarget {
16: constructor(private env: Env) {
17: super()
18: }
19:
20: async createShare(sessionID: string): Promise<SyncInfo> {
21: const { sessions, index } = this.storage()
22: const shareID = sessionID.slice(-8)
23: const secret = uuidv5(sessionID, this.env.SESSIONS_SHARED_SECRET)
24: const now = Date.now()
25: const info: SyncInfo = {
26: id: shareID,
27: secret,
28: url: `https://${this.env.API_DOMAIN}/share/${shareID}`,
29: }
30:
31: const initial: AgentSession = {
32: session: {
33: id: sessionID,
34: slug: sessionID,
35: projectID: "",
36: directory: "",
37: title: "",
38: version: "1",
39: time: {
40: created: now,
41: updated: now,
42: },
43: },
44: messages: [],
45: parts: [],
46: diffs: [],
47: models: [],
48: metadata: {
49: createdAt: now,
50: lastUpdated: now,
51: syncCount: 0,
52: secret,
53: sessionID,
54: },
55: }
56:
57: const initialIndex: SessionIndex = {
58: id: shareID,
59: sessionID,
60: title: "",
61: directory: "",
62: messageCount: 0,
63: ...<path>/home/jm/data/code/opencode/packages/cloudsession/src/index.tsx</path>
<type>file</type>
<content>1: import { Hono } from "hono"
2: import { cors } from "hono/cors"
3: import { newWorkersRpcResponse } from "capnweb"
4: import { zValidator } from "@hono/zod-validator"
5: import { z } from "zod"
6: import { v5 as uuidv5 } from "uuid"
7: import type { SyncInfo, ShareCredentials, AgentSession, SessionIndex } from "./types.ts"
8: import { createStorageAdapter, type StorageAdapter } from "./storage.ts"
9: import SessionList from "./views/session-list.tsx"
10: import SessionDetail from "./views/session-detail.tsx"
11: import NotFound from "./views/not-found.tsx"
12: import { ShareRpcImpl } from "./rpc.ts"
13:
14: import type { SessionBroadcast as SessionBroadcastType } from "./broadcast.ts"
15:
16: // Re-export Durable Object class (required by wrangler)
17: export { SessionBroadcast } from "./broadcast.ts"
18:
19: /**
20: * Environment bindings for Cloudflare Worker
21: */
22: type Env = {
23: SESSIONS_STORE: R2Bucket
24: SESSIONS_SHARED_SECRET: string
25: SESSIONS_RPC_SHARED_KEY?: string
26: API_DOMAIN: string
27: SESSIONS_BROADCAST: DurableObjectNamespace<SessionBroadcastType>
28: }
29:
30: function isAuthorizedRpcRequest(c: { req: { header: (name: string) => string | undefined }; env: Env }) {
31: const configured = c.env.SESSIONS_RPC_SHARED_KEY
32: if (!configured) return true
33: const received = c.req.header("x-opencode-share-key")
34: return received === configured
35: }
36:
37: /**
38: * Main Hono application
39: */
40: const app = new Hono<{ Bindings: Env }>()
41:
42: // Enable CORS for API routes only (not for WebSocket or HTML routes)
43: app.use("/api/*", cors())
44:
45: app.all("/rpc/share", async (c) => {
46: if (!isAuthorizedRpcRequest(c)) {
47: return c.json({ error: "Unauthorized" }, 401)
48: }
49: return newWorkersRpcResponse(c.req.raw, new ShareRpcImpl(c.env))
50: })
51:
52: /**
53: * Create a storage adapt...Found 37 matches
/home/jm/data/code/opencode/packages/cloudsession/src/views/session-list.tsx:
Line 20: <span>{s.syncCount} syncs · </span>
/home/jm/data/code/opencode/packages/cloudsession/src/views/session-detail.tsx:
Line 150: <span> · {session.metadata.syncCount} syncs</span>
/home/jm/data/code/opencode/packages/cloudsession/src/types.ts:
Line 28: syncCount: number
Line 47: syncCount: number
/home/jm/data/code/opencode/packages/cloudsession/src/rpc.ts:
Line 1: import { RpcTarget } from "capnweb"
Line 4: import type { ProbeCallback, ProbeValueInput, ProbeValueOutput } from "./rpc-contract.ts"
Line 15: export class ShareRpcImpl extends RpcTarget {
Line 51: syncCount: 0,
Line 67: syncCount: 0,
Line 92: syncCount: agentSession.metadata.syncCount + 1,
Line 149: syncCount: next.metadata.syncCount,
Line 159: return { success: true, syncCount: next.metadata.syncCount }
/home/jm/data/code/opencode/packages/cloudsession/src/rpc-contract.ts:
Line 1: import type { RpcTarget } from "capnweb"
Line 41: export interface ShareRpc extends RpcTarget {
Line 43: syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
/home/jm/data/code/opencode/packages/cloudsession/src/index.tsx:
Line 3: import { newWorkersRpcResponse } from "capnweb"
Line 12: import { ShareRpcImpl } from "./rpc.ts"
Line 30: function isAuthorizedRpcRequest(c: { req: { header: (name: string) => string | undefined }; env: Env }) {
Line 45: app.all("/rpc/share", async (c) => {
Line 46: if (!isAuthorizedRpcRequest(c)) {
Line 49: return newWorkersRpcResponse(c.req.raw, new ShareRpcImpl(c.env))
Line 126: syncCount: 0,
Line 142: syncCount: 0,
Line 193: syncCount: agentSession.metadata.syncCount + 1,
Line 250: syncCount: nextSession.metadata.syncCount,
Line 261: return c.json({ success: true, syncCount: nextSession...## Kenton Varda - Noise
https://noise.getoto.net/author/kenton-varda/
October 4, independent developer Theo Browne published a series of benchmarks designed to compare server-side JavaScript execution speed between Cloudflare Workers and Vercel, a competing compute platform built on AWS Lambda. The initial results showed Cloudflare Workers performing worse than Node.js on Vercel at a variety of CPU-intensive tasks, by a factor of as much as 3.5x. ... On investigation, we discovered a wide range of small problems that contributed to the disparity, ranging from some bad tuning in our infrastructure, to differences between the JavaScript libraries used on each platform, to some issues with the test itself. We spent the week working on many of these problems, which means over the past week Workers got better and faster for all of our customers. We even fixed some problems that affect other compute providers but not us, such as an issue that made trigonometry functions much slower on Vercel. This post will dig into all the gory details. It’s important to note that the original benchmark was not representative of billable CPU usage on Cloudflare, nor did the issues involved impact most typical workloads. Most of the disparity was an artifact of the specific benchmark ... in every benchmark case except the one based on Next.js. On that benchmark, the gap has closed considerably, and we ... ### Our benchmark methodology stated publicly on X that using single-CPU instances would make no difference in this test, and indeed, we found this to be correct. Using 1 vCPU makes it easier to reason about pricing, since both Vercel and Cloudflare charge for CPU time (`$` 0.128/hr for Vercel in iad1, and`$` 0.072/hr for Cloudflare globally). We made some changes to fix bugs in the test, for which we submitted a pull request . More on this below. ## Cloudflare platform improvements
### Sharding and warm isolate routing: A problem of scheduling, not CPU speed Over the last year we ship...MCP error -32602: Input validation error: Invalid arguments for tool web_search_exa: [
{
"received": "deep",
"code": "invalid_enum_value",
"options": [
"auto",
"fast"
],
"path": [
"type"
],
"message": "Invalid enum value. Expected 'auto' | 'fast', received 'deep'"
}
]Title: GitHub - cloudflare/capnweb: JavaScript/TypeScript-native, low-boilerplate, object-capability RPC system
URL: https://github.com/cloudflare/capnweb
Text: # Repository: cloudflare/capnweb
JavaScript/TypeScript-native, low-boilerplate, object-capability RPC system
- Stars: 3610
- Forks: 112
- Watchers: 3610
- Open issues: 19
- Primary language: TypeScript
- Languages: TypeScript (99.1%), JavaScript (0.9%)
- License: MIT License (MIT)
- Default branch: main
---
# Cap'n Web: A JavaScript-native RPC system
Cap'n Web is a spiritual sibling to [Cap'n Proto] (and is created by the same author), but designed to play nice in the web stack. That means:
- Like Cap'n Proto, it is an object-capability protocol. ("Cap'n" is short for "capabilities and".) We'll get into this more below, but it's incredibly powerful.
- Unlike Cap'n Proto, Cap'n Web has no schemas. In fact, it has almost no boilerplate whatsoever. This means it works more like the [JavaScript-native RPC system in Cloudflare Workers].
- That said, it integrates nicely with TypeScript.
- Also unlike Cap'n Proto, Cap'n Web's underlying serialization is human-readable. In fact, it's just JSON, with a little pre-/post-processing.
- It works over HTTP, WebSocket, and postMessage() out-of-the-box, with the ability to extend it to other transports easily.
- It works in all major browsers, Cloudflare Workers, Node.js, and other modern JavaScript runtimes.
The whole thing compresses (minify+gzip) to under 10kB with no dependencies.
Cap'n Web is more expressive than almost every other RPC system, because it implements an object-capability RPC model. That means it:
- Supports bidirectional calling. The client can call the server, and the server can also call the client.
- Supports passing functions by reference: If you pass a function over RPC, the recipient receives a "stub". When they call the stub, they actually make an RPC back to you, invoking the function where it was created. This is how bidirectional ca
... capnweb/README.md at main · cloudflare/capnweb · GitHub
[Skip to content](#start-of-content)
## Navigation Menu
Toggle navigation
[](/)
[Sign in](/login?return_to=https%3A%2F%2Fgithub.com%2Fcloudflare%2Fcapnweb%2Fblob%2Fmain%2FREADME.md)
Appearance settings
- Platform
- AI CODE CREATION
- [
GitHub CopilotWrite better code with AI
](https://github.com/features/copilot)
- [
GitHub SparkBuild and deploy intelligent apps
](https://github.com/features/spark)
- [
GitHub ModelsManage and compare prompts
](https://github.com/features/models)
- [
MCP RegistryNewIntegrate external tools
](https://github.com/mcp)
- DEVELOPER WORKFLOWS
- [
ActionsAutomate any workflow
](https://github.com/features/actions)
- [
CodespacesInstant dev environments
](https://github.com/features/codespaces)
- [
IssuesPlan and track work
](https://github.com/features/issues)
- [
Code ReviewManage code changes
](https://github.com/features/code-review)
- APPLICATION SECURITY
- [
GitHub Advanced SecurityFind and fix vulnerabilities
](https://github.com/security/advanced-security)
- [
Code securitySecure your code as you build
](https://github.com/security/advanced-security/code-security)
- [
Secret protectionStop leaks before they... capnweb/protocol.md at main · cloudflare/capnweb · GitHub
[Skip to content](#start-of-content)
## Navigation Menu
Toggle navigation
[](/)
[Sign in](/login?return_to=https%3A%2F%2Fgithub.com%2Fcloudflare%2Fcapnweb%2Fblob%2Fmain%2Fprotocol.md)
Appearance settings
- Platform
- AI CODE CREATION
- [
GitHub CopilotWrite better code with AI
](https://github.com/features/copilot)
- [
GitHub SparkBuild and deploy intelligent apps
](https://github.com/features/spark)
- [
GitHub ModelsManage and compare prompts
](https://github.com/features/models)
- [
MCP RegistryNewIntegrate external tools
](https://github.com/mcp)
- DEVELOPER WORKFLOWS
- [
ActionsAutomate any workflow
](https://github.com/features/actions)
- [
CodespacesInstant dev environments
](https://github.com/features/codespaces)
- [
IssuesPlan and track work
](https://github.com/features/issues)
- [
Code ReviewManage code changes
](https://github.com/features/code-review)
- APPLICATION SECURITY
- [
GitHub Advanced SecurityFind and fix vulnerabilities
](https://github.com/security/advanced-security)
- [
Code securitySecure your code as you build
](https://github.com/security/advanced-security/code-security)
- [
Secret protectionStop leaks before ...No files foundNo files found// Copyright (c) 2025 Cloudflare, Inc.
// Licensed under the MIT license found in the LICENSE.txt file or at:
// https://opensource.org/license/mit
import { RpcStub } from "./core.js";
import { RpcTransport, RpcSession, RpcSessionOptions } from "./rpc.js";
import type { IncomingMessage, ServerResponse, OutgoingHttpHeader, OutgoingHttpHeaders } from "node:http";
type SendBatchFunc = (batch: string[]) => Promise<string[]>;
class BatchClientTransport implements RpcTransport {
constructor(sendBatch: SendBatchFunc) {
this.#promise = this.#scheduleBatch(sendBatch);
}
#promise: Promise<void>;
#aborted: any;
#batchToSend: string[] | null = [];
#batchToReceive: string[] | null = null;
async send(message: string): Promise<void> {
// If the batch was already sent, we just ignore the message, because throwing may cause the
// RPC system to abort prematurely. Once the last receive() is done then we'll throw an error
// that aborts the RPC system at the right time and will propagate to all other requests.
if (this.#batchToSend !== null) {
this.#batchToSend.push(message);
}
}
async receive(): Promise<string> {
if (!this.#batchToReceive) {
await this.#promise;
}
let msg = this.#batchToReceive!.shift();
if (msg !== undefined) {
return msg;
} else {
// No more messages. An error thrown here will propagate out of any calls that are still
// open.
throw new Error("Batch RPC request ended.");
}
}
abort?(reason: any): void {
this.#aborted = reason;
}
async #scheduleBatch(sendBatch: SendBatchFunc) {
// Wait for microtask queue to clear before sending a batch.
//
// Note that simply waiting for one turn of the microtask queue (await Promise.resolve()) is
// not good enough here as the application needs a chance to call `.then()` on every RPC
// promise in order to explicitly indicate they want the results. Unfortunately, `await`ing
// a the...// Copyright (c) 2025 Cloudflare, Inc.
// Licensed under the MIT license found in the LICENSE.txt file or at:
// https://opensource.org/license/mit
import { RpcTarget as RpcTargetImpl, RpcStub as RpcStubImpl, RpcPromise as RpcPromiseImpl } from "./core.js";
import { serialize, deserialize } from "./serialize.js";
import { RpcTransport, RpcSession as RpcSessionImpl, RpcSessionOptions } from "./rpc.js";
import { RpcTargetBranded, RpcCompatible, Stub, Stubify, __RPC_TARGET_BRAND } from "./types.js";
import { newWebSocketRpcSession as newWebSocketRpcSessionImpl,
newWorkersWebSocketRpcResponse } from "./websocket.js";
import { newHttpBatchRpcSession as newHttpBatchRpcSessionImpl,
newHttpBatchRpcResponse, nodeHttpBatchRpcResponse } from "./batch.js";
import { newMessagePortRpcSession as newMessagePortRpcSessionImpl } from "./messageport.js";
import { forceInitMap } from "./map.js";
import { forceInitStreams } from "./streams.js";
forceInitMap();
forceInitStreams();
// Re-export public API types.
export { serialize, deserialize, newWorkersWebSocketRpcResponse, newHttpBatchRpcResponse,
nodeHttpBatchRpcResponse };
export type { RpcTransport, RpcSessionOptions, RpcCompatible };
// Hack the type system to make RpcStub's types work nicely!
/**
* Represents a reference to a remote object, on which methods may be remotely invoked via RPC.
*
* `RpcStub` can represent any interface (when using TypeScript, you pass the specific interface
* type as `T`, but this isn't known at runtime). The way this works is, `RpcStub` is actually a
* `Proxy`. It makes itself appear as if every possible method / property name is defined. You can
* invoke any method name, and the invocation will be sent to the server. If it turns out that no
* such method exists on the remote object, an exception is thrown back. But the client does not
* actually know, until that point, what methods exist.
*/
export type RpcStub<T extends RpcCompatible<T>> = Stub<T>;
export ...# RPC Protocol
## Serialization
The protocol uses JSON as its basic serialization, with a preprocessing step to support non-JSON types.
Why not a binary format? While the author is a big fan of optimized binary protocols in other contexts, it cannot be denied that in a browser, JSON has big advantages. Being built-in to the browser gives it a leg up in performance, code size, and developer tooling.
Non-JSON types are encoded using arrays. The first element of the array contains a string type code, and the remaining elements contain the parameters needed to construct that type. For example, a `Date` might be encoded as:
```
["date", 1749342170815]
```
To encode an array, the array must be wrapped in a second layer of array to create an array expression:
```
[["just", "an", "array"]]
```
## Client vs. Server
The protocol does not have a "client" or a "server"; it is fully bidirectional. Either side can call interfaces exported by the other.
With that said, for documentation purposes, we often use the words "client" and "server" when describing specific interactions, in order to make the language easier to understand. The word "client" generally refers to the caller of an RPC, or the importer of a stub. The word "server" refers to the callee, or the exporter. This is merely a convention to make explanations more natural.
## Transport and Framing
The protocol operates on a bidirectional stream of discrete messages. Each message is a single JSON value (typically an array). The protocol does not define how messages are framed on the wire; this is the responsibility of the transport layer.
For transports that natively provide message framing (e.g. WebSocket or MessagePort), each transport-level message corresponds to exactly one RPC message.
The built-in HTTP transport is newline-delimited, packing a series of messages into a single HTTP request or response body. Each message is serialized as a single line of JSON (no embedded newlines), and messages are sepa...<path>/home/jm/data/code/opencode/packages/cloudsession/src/index.test.ts</path>
<type>file</type>
<content>1: import { describe, expect, test } from "bun:test"
2: import app from "./index.tsx"
3: import type { AgentSession, SyncInfo, SessionIndex } from "./types"
4: import {
5: createTestFileDiff,
6: createTestMessage,
7: createTestModel,
8: createTestPart,
9: createTestSession,
10: SESSION_PROPERTIES,
11: validateTypeStructure,
12: } from "./test-utils"
13:
14: const sharedSecret = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
15:
16: const createMockR2Bucket = () => {
17: const storage = new Map<string, string>()
18:
19: const mockBucket: any = {
20: put: async (key: string, value: string | ArrayBuffer) => {
21: let content = ""
22: if (typeof value === "string") {
23: content = value
24: }
25: if (value instanceof ArrayBuffer) {
26: content = new TextDecoder().decode(value)
27: }
28:
29: storage.set(key, content)
30: },
31: get: async (key: string) => {
32: const data = storage.get(key)
33: if (!data) return null
34:
35: return {
36: async text() {
37: return data
38: },
39: async arrayBuffer() {
40: return new TextEncoder().encode(data).buffer
41: },
42: }
43: },
44: delete: async (key: string) => {
45: storage.delete(key)
46: },
47: list: async (options?: any) => {
48: const prefix = options?.prefix || ""
49: const objects = Array.from(storage.keys())
50: .filter((key) => key.startsWith(prefix))
51: .map((key) => ({
52: key,
53: version: "mock",
54: size: storage.get(key)!.length,
55: etag: `"mock-${key}"`,
56: httpMetadata: { contentType: "application/json" },
57: customMetadata: {},
58: uploaded: new Date(),
59: }))
60: return { objects }
61: },
62: }
63:
64: retur...<path>/home/jm/data/code/opencode/packages/cloudsession/src/api.test.ts</path>
<type>file</type>
<content>190: const { data } = await createShare("1234567890abcdefghijklmnop", env)
191: expect(data.id).toBe("ijklmnop")
192: })
193:
194: test("secret is deterministic (same sessionID = same secret)", async () => {
195: const env1 = createEnv()
196: const env2 = createEnv()
197: const { data: share1 } = await createShare("same-session-id", env1)
198: const { data: share2 } = await createShare("same-session-id", env2)
199: expect(share1.secret).toBe(share2.secret)
200: })
201: })
202:
203: describe("POST /api/share/:id/sync", () => {
204: let env: TestEnv
205:
206: beforeEach(() => {
207: env = createEnv()
208: })
209:
210: test("accepts valid sync and returns {success, syncCount}", async () => {
211: const { data: share } = await createShare("sync-test", env)
212: const session = createTestSession({ id: "sync-test" })
213:
214: const { response, data } = await syncShare(share.id, env, {
215: secret: share.secret,
216: data: [{ type: "session", data: session }],
217: })
218:
219: expect(response.status).toBe(200)
220: expect(data.success).toBe(true)
221: expect(data.syncCount).toBe(1)
222: })
223:
224: test("rejects invalid secret with 403", async () => {
225: const { data: share } = await createShare("sync-test", env)
226: const session = createTestSession({ id: "sync-test" })
227:
228: const { response, data } = await syncShare(share.id, env, {
229: secret: "wrong-secret",
230: data: [{ type: "session", data: session }],
231: })
232:
233: expect(response.status).toBe(403)
234: expect(data.error).toBe("Invalid secret")
235: })
236:
237: test("returns 404 for non-existent share", async () => {
238: const { response, data } = await syncShare("nonexist", env, {
239: secret: "any-secret",
240: data: [{ type: "session", ...<path>/home/jm/data/code/opencode/packages/cloudsession/src/api.test.ts</path>
<type>file</type>
<content>520: expect(data.session.title).toBe("Test Session")
521: expect(data.messages).toHaveLength(1)
522: expect(data.parts).toHaveLength(1)
523: expect(data.diffs).toHaveLength(1)
524: expect(data.models).toHaveLength(1)
525: expect(data.metadata.syncCount).toBe(1)
526: })
527:
528: test("returns 404 for non-existent share", async () => {
529: const { response } = await getShare("nonexist", env)
530: expect(response.status).toBe(404)
531: })
532: })
533:
534: describe("GET /api/sessions", () => {
535: let env: TestEnv
536:
537: beforeEach(() => {
538: env = createEnv()
539: })
540:
541: test("returns empty array when no shares", async () => {
542: const { data } = await listSessions(env)
543: expect(data.sessions).toEqual([])
544: expect(data.count).toBe(0)
545: })
546:
547: test("returns all shares with count", async () => {
548: const { data: share1 } = await createShare("session-list-a", env)
549: await syncShare(share1.id, env, {
550: secret: share1.secret,
551: data: [{ type: "session", data: createTestSession({ id: "session-list-a" }) }],
552: })
553:
554: const { data: share2 } = await createShare("session-list-b", env)
555: await syncShare(share2.id, env, {
556: secret: share2.secret,
557: data: [{ type: "session", data: createTestSession({ id: "session-list-b" }) }],
558: })
559:
560: const { data } = await listSessions(env)
561:
562: expect(data.count).toBe(2)
563: const ids = data.sessions.map((s) => s.sessionID)
564: expect(ids).toContain("session-list-a")
565: expect(ids).toContain("session-list-b")
566: })
567:
568: test("includes sessionID and createdAt for each", async () => {
569: const { data: share } = await createShare("session-fields", env)
570: await syncShare(share.id, env, {
571: secr...<path>/home/jm/data/code/opencode/packages/cloudsession/src/types.ts</path>
<type>file</type>
<content>1: /**
2: * SDK Types for OpenCode Agent Sessions
3: * Import core types from @opencode-ai/sdk/v2
4: */
5: import type { Session, Message, Part, FileDiff, Model } from "@opencode-ai/sdk/v2"
6:
7: // Re-export SDK types for convenience
8: export type { Session, Message, Part, FileDiff, Model }
9:
10: /**
11: * Sync data discriminated union type
12: * Represents the different types of data that can be synchronized
13: */
14: export type SyncData =
15: | { type: "session"; data: Session }
16: | { type: "message"; data: Message }
17: | { type: "part"; data: Part }
18: | { type: "session_diff"; data: FileDiff[] }
19: | { type: "model"; data: Model[] }
20:
21: /**
22: * Complete agent session structure
23: * This represents a fully reconstructed session from sync data
24: */
25: export type SessionMetadata = {
26: createdAt: number
27: lastUpdated: number
28: syncCount: number
29: secret: string
30: sessionID: string
31: }
32:
33: /**
34: * Lightweight index entry stored at index/${shareID}
35: * Used by list endpoints to avoid loading full session blobs
36: */
37: export type SessionIndex = {
38: id: string
39: sessionID: string
40: title: string
41: directory: string
42: messageCount: number
43: partCount: number
44: diffCount: number
45: modelCount: number
46: lastUpdated: number
47: syncCount: number
48: createdAt: number
49: }
50:
51: export type AgentSession = {
52: session: Session
53: messages: Message[]
54: parts: Part[]
55: diffs: FileDiff[]
56: models: Model[]
57: metadata: SessionMetadata
58: }
59:
60: /**
61: * Share credentials
62: */
63: export type SyncInfo = {
64: id: string
65: url: string
66: secret: string
67: }
68:
69: export type ShareCredentials = SyncInfo & {
70: sessionID: string
71: createdAt: number
72: }
73:
74: export type SecretNS = string
75:
(End of fil...<path>/home/jm/data/code/opencode/packages/cloudsession/src/storage.ts</path>
<type>file</type>
<content>1: /**
2: * Storage Adapter for R2 Bucket
3: * Typeclass-based abstraction for R2 storage operations
4: */
5:
6: // R2 Types are available globally from worker-configuration.d.ts (generated by Wrangler)
7: /**
8: * Storage Adapter Interface - Typeclass for storage operations
9: * This defines the contract that any storage implementation must satisfy
10: */
11: export interface StorageAdapter<T> {
12: /**
13: * Put an object into storage
14: * @param key - The key/path where to store the object
15: * @param value - The value to store (will be serialized to JSON)
16: * @param options - Optional storage options
17: */
18: put(key: string, value: T, options?: R2PutOptions): Promise<void>
19:
20: /**
21: * Get an object from storage
22: * @param key - The key/path of the object to retrieve
23: * @returns The retrieved object or null if not found
24: */
25: get(key: string): Promise<T | null>
26:
27: /**
28: * Delete an object from storage
29: * @param key - The key/path of the object to delete
30: */
31: delete(key: string): Promise<void>
32:
33: /**
34: * List objects in storage with optional prefix
35: * @param options - List options including prefix
36: * @returns List of objects with their keys
37: */
38: list(options?: R2ListOptions): Promise<R2Object[]>
39:
40: /**
41: * Check if an object exists in storage
42: * @param key - The key/path to check
43: * @returns True if the object exists, false otherwise
44: */
45: exists(key: string): Promise<boolean>
46: }
47:
48: /**
49: * R2 Storage Adapter Implementation
50: * Concrete implementation of StorageAdapter for Cloudflare R2
51: */
52: export class R2StorageAdapter<T> implements StorageAdapter<T> {
53: constructor(private readonly bucket: R2Bucket) {}
54:
55: async put(key: string, value: T, options?: R2PutOptions)...Found 3 matches
/home/jm/data/code/opencode/packages/opencode/test/skill/discovery.test.ts:
Line 86: const refDir = await Array.fromAsync(new Bun.Glob("**/*.md").scan({ cwd: refs, onlyFiles: true }))
/home/jm/data/code/opencode/packages/opencode/test/file/ripgrep.test.ts:
Line 17: const files = await Array.fromAsync(Ripgrep.files({ cwd: tmp.path }))
Line 33: const files = await Array.fromAsync(Ripgrep.files({ cwd: tmp.path, hidden: false }))Found 15 matches
/home/jm/data/code/opencode/packages/opencode/src/project/bootstrap.ts:
Line 13: import { ShareNext } from "@/share/share-next"
Line 21: ShareNext.init()
/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts:
Line 14: export namespace ShareNext {
Line 15: const log = Log.create({ service: "share-next" })
Line 22: const transport = process.env["OPENCODE_SHARE_TRANSPORT"] === "rpc" ? "rpc" : "http"
/home/jm/data/code/opencode/packages/opencode/src/session/index.ts:
Line 326: const { ShareNext } = await import("@/share/share-next")
Line 327: const share = await ShareNext.create(id)
Line 338: // Use ShareNext to remove the share (same as share function uses ShareNext to create)
Line 339: const { ShareNext } = await import("@/share/share-next")
Line 340: await ShareNext.remove(id)
/home/jm/data/code/opencode/packages/opencode/src/cli/cmd/import.ts:
Line 9: import { ShareNext } from "../../share/share-next"
Line 13: /** Discriminated union returned by the ShareNext API (GET /api/share/:id/data) */
Line 28: * Transform ShareNext API response (flat array) into the nested structure for local file storage.
Line 94: const baseUrl = await ShareNext.url()
Line 100: const baseUrl = await ShareNext.url()No files foundFound 2 matches
/home/jm/data/code/opencode/packages/cloudsession/src/index.test.ts:
Line 150: expect(syncResult.syncCount).toBe(1)
Line 162: expect(shareSession.metadata.syncCount).toBe(1)<path>/home/jm/data/code/opencode/packages/web/src/api.ts</path>
<type>file</type>
<content>1: // Client-side API helper for making requests to the worker API
2:
3: export async function getSessions() {
4: const response = await fetch("/api/sessions")
5: if (!response.ok) {
6: throw new Error(`Failed to fetch sessions: ${response.statusText}`)
7: }
8: return response.json()
9: }
10:
11: export async function getShare(id: string) {
12: const response = await fetch(`/api/share/${id}`)
13: if (!response.ok) {
14: throw new Error(`Failed to fetch share: ${response.statusText}`)
15: }
16: return response.json()
17: }
18:
19: export async function createShare(sessionID: string) {
20: const response = await fetch("/api/share", {
21: method: "POST",
22: headers: { "Content-Type": "application/json" },
23: body: JSON.stringify({ sessionID }),
24: })
25: if (!response.ok) {
26: throw new Error(`Failed to create share: ${response.statusText}`)
27: }
28: return response.json()
29: }
30:
31: export async function syncShare(id: string, secret: string, data: any[]) {
32: const response = await fetch(`/api/share/${id}/sync`, {
33: method: "POST",
34: headers: { "Content-Type": "application/json" },
35: body: JSON.stringify({ secret, data }),
36: })
37: if (!response.ok) {
38: throw new Error(`Failed to sync share: ${response.statusText}`)
39: }
40: return response.json()
41: }
42:
(End of file - total 42 lines)
</content>Found 7 matches
/home/jm/data/code/opencode/packages/opencode/src/session/message-v2.ts:
Line 446: Updated: BusEvent.define(
Line 447: "message.updated",
Line 452: Removed: BusEvent.define(
Line 459: PartUpdated: BusEvent.define(
Line 460: "message.part.updated",
Line 465: PartDelta: BusEvent.define(
Line 475: PartRemoved: BusEvent.define(<path>/home/jm/data/code/opencode/packages/opencode/src/session/message-v2.ts</path>
<type>file</type>
<content>1: import { BusEvent } from "@/bus/bus-event"
2: import z from "zod"
3: import { NamedError } from "@opencode-ai/util/error"
4: import { APICallError, convertToModelMessages, LoadAPIKeyError, type ModelMessage, type UIMessage } from "ai"
5: import { Identifier } from "../id/id"
6: import { LSP } from "../lsp"
7: import { Snapshot } from "@/snapshot"
8: import { fn } from "@/util/fn"
9: import { Database, eq, desc, inArray } from "@/storage/db"
10: import { MessageTable, PartTable } from "./session.sql"
11: import { ProviderTransform } from "@/provider/transform"
12: import { STATUS_CODES } from "http"
13: import { Storage } from "@/storage/storage"
14: import { ProviderError } from "@/provider/error"
15: import { iife } from "@/util/iife"
16: import { type SystemError } from "bun"
17: import type { Provider } from "@/provider/provider"
18:
19: export namespace MessageV2 {
20: export const OutputLengthError = NamedError.create("MessageOutputLengthError", z.object({}))
21: export const AbortedError = NamedError.create("MessageAbortedError", z.object({ message: z.string() }))
22: export const StructuredOutputError = NamedError.create(
23: "StructuredOutputError",
24: z.object({
25: message: z.string(),
26: retries: z.number(),
27: }),
28: )
29: export const AuthError = NamedError.create(
30: "ProviderAuthError",
31: z.object({
32: providerID: z.string(),
33: message: z.string(),
34: }),
35: )
36: export const APIError = NamedError.create(
37: "APIError",
38: z.object({
39: message: z.string(),
40: statusCode: z.number().optional(),
41: isRetryable: z.boolean(),
42: responseHeaders: z.record(z.string(), z.string()).optional(),
43: responseBody: z.string().optional(),
44: metadata: z.record(z.string(), z.string()).optional(),
45: }),
46: )
47: expo...<path>/home/jm/data/code/opencode/packages/opencode/src/session/message-v2.ts</path>
<type>file</type>
<content>420: summary: z.boolean().optional(),
421: cost: z.number(),
422: tokens: z.object({
423: total: z.number().optional(),
424: input: z.number(),
425: output: z.number(),
426: reasoning: z.number(),
427: cache: z.object({
428: read: z.number(),
429: write: z.number(),
430: }),
431: }),
432: structured: z.any().optional(),
433: variant: z.string().optional(),
434: finish: z.string().optional(),
435: }).meta({
436: ref: "AssistantMessage",
437: })
438: export type Assistant = z.infer<typeof Assistant>
439:
440: export const Info = z.discriminatedUnion("role", [User, Assistant]).meta({
441: ref: "Message",
442: })
443: export type Info = z.infer<typeof Info>
444:
445: export const Event = {
446: Updated: BusEvent.define(
447: "message.updated",
448: z.object({
449: info: Info,
450: }),
451: ),
452: Removed: BusEvent.define(
453: "message.removed",
454: z.object({
455: sessionID: z.string(),
456: messageID: z.string(),
457: }),
458: ),
459: PartUpdated: BusEvent.define(
460: "message.part.updated",
461: z.object({
462: part: Part,
463: }),
464: ),
465: PartDelta: BusEvent.define(
466: "message.part.delta",
467: z.object({
468: sessionID: z.string(),
469: messageID: z.string(),
470: partID: z.string(),
471: field: z.string(),
472: delta: z.string(),
473: }),
474: ),
475: PartRemoved: BusEvent.define(
476: "message.part.removed",
477: z.object({
478: sessionID: z.string(),
479: messageID: z.string(),
480: partID: z.string(),
481: }),
482: ),
483: }
484:
485: export const WithParts = z.object({
486: info: Info,
487: parts: z.arr...Found 19 matches
/home/jm/data/code/opencode/packages/opencode/src/session/index.ts:
Line 254: Database.use((db) => {
Line 289: Database.use((db) => {
Line 316: const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
Line 328: Database.use((db) => {
Line 341: Database.use((db) => {
Line 355: return Database.use((db) => {
Line 376: return Database.use((db) => {
Line 397: return Database.use((db) => {
Line 419: return Database.use((db) => {
Line 441: return Database.use((db) => {
Line 464: return Database.use((db) => {
Line 533: const rows = Database.use((db) =>
Line 549: const rows = Database.use((db) =>
Line 568: Database.use((db) => {
Line 584: Database.use((db) => {
Line 610: Database.use((db) => {
Line 623: export const removePart = fn(
Line 630: Database.use((db) => {
Line 649: Database.use((db) => {<path>/home/jm/data/code/opencode/packages/opencode/src/session/index.ts</path>
<type>file</type>
<content>520: }
521: if (input?.roots) {
522: conditions.push(isNull(SessionTable.parent_id))
523: }
524: if (input?.start) {
525: conditions.push(gte(SessionTable.time_updated, input.start))
526: }
527: if (input?.search) {
528: conditions.push(like(SessionTable.title, `%${input.search}%`))
529: }
530:
531: const limit = input?.limit ?? 100
532:
533: const rows = Database.use((db) =>
534: db
535: .select()
536: .from(SessionTable)
537: .where(and(...conditions))
538: .orderBy(desc(SessionTable.time_updated))
539: .limit(limit)
540: .all(),
541: )
542: for (const row of rows) {
543: yield fromRow(row)
544: }
545: }
546:
547: export const children = fn(Identifier.schema("session"), async (parentID) => {
548: const project = Instance.project
549: const rows = Database.use((db) =>
550: db
551: .select()
552: .from(SessionTable)
553: .where(and(eq(SessionTable.project_id, project.id), eq(SessionTable.parent_id, parentID)))
554: .all(),
555: )
556: return rows.map(fromRow)
557: })
558:
559: export const remove = fn(Identifier.schema("session"), async (sessionID) => {
560: const project = Instance.project
561: try {
562: const session = await get(sessionID)
563: for (const child of await children(sessionID)) {
564: await remove(child.id)
565: }
566: await unshare(sessionID).catch(() => {})
567: // CASCADE delete handles messages and parts automatically
568: Database.use((db) => {
569: db.delete(SessionTable).where(eq(SessionTable.id, sessionID)).run()
570: Database.effect(() =>
571: Bus.publish(Event.Deleted, {
572: info: session,
573: }),
574: )
575: })
576: } catch (e) ...<path>/home/jm/data/code/opencode/packages/opencode/src/storage/db.ts</path>
<type>file</type>
<content>1: import { Database as BunDatabase } from "bun:sqlite"
2: import { drizzle, type SQLiteBunDatabase } from "drizzle-orm/bun-sqlite"
3: import { migrate } from "drizzle-orm/bun-sqlite/migrator"
4: import { type SQLiteTransaction } from "drizzle-orm/sqlite-core"
5: export * from "drizzle-orm"
6: import { Context } from "../util/context"
7: import { lazy } from "../util/lazy"
8: import { Global } from "../global"
9: import { Log } from "../util/log"
10: import { NamedError } from "@opencode-ai/util/error"
11: import z from "zod"
12: import path from "path"
13: import { readFileSync, readdirSync, existsSync } from "fs"
14: import * as schema from "./schema"
15:
16: declare const OPENCODE_MIGRATIONS: { sql: string; timestamp: number }[] | undefined
17:
18: export const NotFoundError = NamedError.create(
19: "NotFoundError",
20: z.object({
21: message: z.string(),
22: }),
23: )
24:
25: const log = Log.create({ service: "db" })
26:
27: export namespace Database {
28: export const Path = path.join(Global.Path.data, "opencode.db")
29: type Schema = typeof schema
30: export type Transaction = SQLiteTransaction<"sync", void, Schema>
31:
32: type Client = SQLiteBunDatabase<Schema>
33:
34: type Journal = { sql: string; timestamp: number }[]
35:
36: function time(tag: string) {
37: const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(tag)
38: if (!match) return 0
39: return Date.UTC(
40: Number(match[1]),
41: Number(match[2]) - 1,
42: Number(match[3]),
43: Number(match[4]),
44: Number(match[5]),
45: Number(match[6]),
46: )
47: }
48:
49: function migrations(dir: string): Journal {
50: const dirs = readdirSync(dir, { withFileTypes: true })
51: .filter((entry) => entry.isDirectory())
52: .map((entry) => entry.name)
53:
54: const sql = dirs
55: .map((name) =>...<path>/home/jm/data/code/opencode/packages/opencode/src/storage/storage.ts</path>
<type>file</type>
<content>1: import { Log } from "../util/log"
2: import path from "path"
3: import fs from "fs/promises"
4: import { Global } from "../global"
5: import { Filesystem } from "../util/filesystem"
6: import { lazy } from "../util/lazy"
7: import { Lock } from "../util/lock"
8: import { $ } from "bun"
9: import { NamedError } from "@opencode-ai/util/error"
10: import z from "zod"
11: import { Glob } from "../util/glob"
12:
13: export namespace Storage {
14: const log = Log.create({ service: "storage" })
15:
16: type Migration = (dir: string) => Promise<void>
17:
18: export const NotFoundError = NamedError.create(
19: "NotFoundError",
20: z.object({
21: message: z.string(),
22: }),
23: )
24:
25: const MIGRATIONS: Migration[] = [
26: async (dir) => {
27: const project = path.resolve(dir, "../project")
28: if (!(await Filesystem.isDir(project))) return
29: const projectDirs = await Glob.scan("*", {
30: cwd: project,
31: include: "all",
32: })
33: for (const projectDir of projectDirs) {
34: const fullPath = path.join(project, projectDir)
35: if (!(await Filesystem.isDir(fullPath))) continue
36: log.info(`migrating project ${projectDir}`)
37: let projectID = projectDir
38: const fullProjectDir = path.join(project, projectDir)
39: let worktree = "/"
40:
41: if (projectID !== "global") {
42: for (const msgFile of await Glob.scan("storage/session/message/*/*.json", {
43: cwd: path.join(project, projectDir),
44: absolute: true,
45: })) {
46: const json = await Filesystem.readJson<any>(msgFile)
47: worktree = json.path?.root
48: if (worktree) break
49: }
50: if (!worktree) continue
51: if (!(await Filesystem.isDir(worktree))) continue
52...// Copyright (c) 2025 Cloudflare, Inc.
// Licensed under the MIT license found in the LICENSE.txt file or at:
// https://opensource.org/license/mit
import { StubHook, RpcPayload, RpcStub, PropertyPath, PayloadStubHook, ErrorStubHook, RpcTarget, unwrapStubAndPath, streamImpl } from "./core.js";
import { Devaluator, Evaluator, ExportId, ImportId, Exporter, Importer, serialize } from "./serialize.js";
/**
* Interface for an RPC transport, which is a simple bidirectional message stream. Implement this
* interface if the built-in transports (e.g. for HTTP batch and WebSocket) don't meet your needs.
*/
export interface RpcTransport {
/**
* Sends a message to the other end.
*/
send(message: string): Promise<void>;
/**
* Receives a message sent by the other end.
*
* If and when the transport becomes disconnected, this will reject. The thrown error will be
* propagated to all outstanding calls and future calls on any stubs associated with the session.
* If there are no outstanding calls (and none are made in the future), then the error does not
* propagate anywhere -- this is considered a "clean" shutdown.
*/
receive(): Promise<string>;
/**
* Indicates that the RPC system has suffered an error that prevents the session from continuing.
* The transport should ideally try to send any queued messages if it can, and then close the
* connection. (It's not strictly necessary to deliver queued messages, but the last message sent
* before abort() is called is often an "abort" message, which communicates the error to the
* peer, so if that is dropped, the peer may have less information about what happened.)
*/
abort?(reason: any): void;
}
// Entry on the exports table.
type ExportTableEntry = {
hook: StubHook,
refcount: number,
pull?: Promise<void>,
// If true, the export should be automatically released (with refcount 1) after its "resolve"
// or "reject" message is sent. This is set for exports created ...// Copyright (c) 2025 Cloudflare, Inc.
// Licensed under the MIT license found in the LICENSE.txt file or at:
// https://opensource.org/license/mit
/// <reference types="@cloudflare/workers-types" />
import { RpcStub } from "./core.js";
import { RpcTransport, RpcSession, RpcSessionOptions } from "./rpc.js";
export function newWebSocketRpcSession(
webSocket: WebSocket | string, localMain?: any, options?: RpcSessionOptions): RpcStub {
if (typeof webSocket === "string") {
webSocket = new WebSocket(webSocket);
}
let transport = new WebSocketTransport(webSocket);
let rpc = new RpcSession(transport, localMain, options);
return rpc.getRemoteMain();
}
/**
* For use in Cloudflare Workers: Construct an HTTP response that starts a WebSocket RPC session
* with the given `localMain`.
*/
export function newWorkersWebSocketRpcResponse(
request: Request, localMain?: any, options?: RpcSessionOptions): Response {
if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
return new Response("This endpoint only accepts WebSocket requests.", { status: 400 });
}
let pair = new WebSocketPair();
let server = pair[0];
server.accept()
newWebSocketRpcSession(server, localMain, options);
return new Response(null, {
status: 101,
webSocket: pair[1],
});
}
class WebSocketTransport implements RpcTransport {
constructor (webSocket: WebSocket) {
this.#webSocket = webSocket;
if (webSocket.readyState === WebSocket.CONNECTING) {
this.#sendQueue = [];
webSocket.addEventListener("open", event => {
try {
for (let message of this.#sendQueue!) {
webSocket.send(message);
}
} catch (err) {
this.#receivedError(err);
}
this.#sendQueue = undefined;
});
}
webSocket.addEventListener("message", (event: MessageEvent<any>) => {
if (this.#error) {
// Ignore further messages.
} else if (typeof event.data === "string...Great question — I dug into it, and the short answer is:
capnweb helps with call semantics and transport efficiencyWhat I found in your code:
ShareNext only switches transport (rpc vs http) at the edge; the payload semantics stay the same in packages/opencode/src/share/share-next.ts:22, packages/opencode/src/share/share-next.ts:82, packages/opencode/src/share/share-next.ts:145.message/part upsert-by-id, session_diff append) in both packages/cloudsession/src/rpc.ts:75 and packages/cloudsession/src/index.tsx:156.What capnweb does give you (relevant):
newHttpBatchRpcSession), and server-side drain() waits for pulled results before response.ShareRpc) are cleaner than ad-hoc REST payloads (packages/opencode/src/share/rpc-contract.ts:41).What it does not give you (the persistence problems you care about):
Concrete “slip” risks still present now (transport-independent):
ShareNext.sync(), queued data is removed before network send and there is no retry/backoff path (packages/opencode/src/share/share-next.ts:140, packages/opencode/src/share/share-next.ts:145, packages/opencode/src/share/share-next.ts:153).session_diff is append-only, so retries can duplicate diffs (packages/cloudsession/src/rpc.ts:122, packages/cloudsession/src/index.tsx:223).SyncData items don’t have top-level id, but queue code checks "id" in item (packages/opencode/src/share/share-next.ts:127, packages/opencode/src/share/share-next.ts:134).So should A2A “just use capnweb” as transport?
That gives you performance and ergonomics from capnweb without coupling persistence correctness to transport behavior.
Is it more that by adding a strong persistence layer, that capnweb gives additional design benefits, for example by adding persistence the rpc stubs effectively becomme a capability securiy mechanism, a sturdy ref, which can allow for some unique design considerations?
Yes — that’s exactly the right way to think about it.
capnweb can become a strong capability-security layer on top of a solid persistence core, but by itself it does not automatically give you sturdy refs.
For your current implementation:
shareID + secret) in packages/cloudsession/src/rpc.ts:20 and packages/cloudsession/src/rpc.ts:75.packages/opencode/src/share/share-next.ts:22./rpc/share in packages/cloudsession/src/index.tsx:45.Where this gets uniquely powerful (if you persist capability descriptors):
The key caveat:
idempotency_key, expected_version, append log + replay). So yes: strong persistence + capnweb is additive.
It’s a very good combo if you treat capnweb as the capability transport and DB as the source of truth.
NOt only can the reconection be redeemed, but cannot messages sent by calls on the stub be queued as ReponsePromises, which can be resent in the same promise pipelined batches that they were originally sent as?
Short answer: not directly as RpcPromise objects, but yes as durable call intents.
RpcPromise/stub state in capnweb is session-bound (import/export IDs, pull/resolve lifecycle), so you can’t persist a live promise and “resume it” after disconnect.RpcPromise instances.What works well:
batch_id + per-op op_id (idempotency key).op_id and returns prior result/ack if already applied.Critical caveat:
So your idea is right in spirit: queue and replay pipelined batches, but do it at the intent/event layer, not by storing raw capnweb promise objects.
Create a plan for implementing a prototype persistence layer for our capnweb transport.
Create tests that prove the design potential for each of the possibile features we have discussed above
Create a plan for implementing a prototype persistence layer for our capnweb transport.
Create tests that prove the design potential for each of the possibile features we have discussed above
Create a plan for implementing a prototype persistence layer for our capnweb transport.
Create tests that prove the design potential for each of the possibile features we have discussed above
Create a plan for implementing a prototype persistence layer for our capnweb transport.
Create tests that prove the design potential for each of the possibile features we have discussed above
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/share/share-next.ts/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/views/session-list.tsx
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/views/session-detail.tsx
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/views/not-found.tsx
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/api.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/broadcast.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/durable-object.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/index.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/rpc.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/rpc-contract.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/preload.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/index.tsx
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/storage.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/storage.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/test-utils.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/views/layout.tsx
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/types.ts/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/todo.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/system.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/summary.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/status.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/session.sql.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/revert.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/retry.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/compaction.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/message-v2.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/llm.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/instruction.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/index.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/processor.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/message.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/prompt.ts<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/share/share-next.ts</path>
<type>file</type>
<content>1: import { Bus } from "@/bus"
2: import { Config } from "@/config/config"
3: import { newHttpBatchRpcSession } from "capnweb"
4: import { ulid } from "ulid"
5: import { Provider } from "@/provider/provider"
6: import { Session } from "@/session"
7: import { MessageV2 } from "@/session/message-v2"
8: import { Database, eq } from "@/storage/db"
9: import { SessionShareTable } from "./share.sql"
10: import { Log } from "@/util/log"
11: import type * as SDK from "@opencode-ai/sdk/v2"
12: import type { ShareRpc, SyncData, SyncInfo } from "./rpc-contract"
13:
14: export namespace ShareNext {
15: const log = Log.create({ service: "share-next" })
16:
17: export async function url() {
18: return Config.get().then((x) => x.enterprise?.url ?? "https://opencode.j9xym.com")
19: }
20:
21: const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_DISABLE_SHARE"] === "1"
22: const transport = process.env["OPENCODE_SHARE_TRANSPORT"] === "rpc" ? "rpc" : "http"
23: const rpcKey = process.env["OPENCODE_SHARE_RPC_KEY"]
24:
25: function rpcHeaders() {
26: if (!rpcKey) return undefined
27: return { "x-opencode-share-key": rpcKey }
28: }
29:
30: export async function init() {
31: if (disabled) return
32: Bus.subscribe(Session.Event.Updated, async (evt) => {
33: await sync(evt.properties.info.id, [
34: {
35: type: "session",
36: data: evt.properties.info,
37: },
38: ])
39: })
40: Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
41: await sync(evt.properties.info.sessionID, [
42: {
43: type: "message",
44: data: evt.properties.info,
45: },
46: ])
47: if (evt.properties.info.role === "user") {
48: await sync(evt.properties.info.sessionID, [
49: {
5...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/rpc-contract.ts</path>
<type>file</type>
<content>1: import type { RpcTarget } from "capnweb"
2: import type * as SDK from "@opencode-ai/sdk/v2"
3:
4: export type SyncData =
5: | {
6: type: "session"
7: data: SDK.Session
8: }
9: | {
10: type: "message"
11: data: SDK.Message
12: }
13: | {
14: type: "part"
15: data: SDK.Part
16: }
17: | {
18: type: "session_diff"
19: data: SDK.FileDiff[]
20: }
21: | {
22: type: "model"
23: data: SDK.Model[]
24: }
25:
26: export type SyncInfo = {
27: id: string
28: url: string
29: secret: string
30: }
31:
32: export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
33: export type ProbeValueOutput = {
34: when: string
35: bytes: number[]
36: size: number
37: nested: { x: number }
38: }
39: export type ProbeCallback = (msg: string) => string | Promise<string>
40:
41: export interface ShareRpc extends RpcTarget {
42: createShare: (sessionID: string) => Promise<SyncInfo>
43: syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
44: probeValue: (input: ProbeValueInput) => ProbeValueOutput
45: probeCallback: (cb: ProbeCallback) => Promise<string>
46: }
47:
(End of file - total 47 lines)
</content>
<system-reminder>
Instructions from: /home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/AGENTS.md
# packages/cloudsession
Cloudflare Worker that stores and serves shared OpenCode agent sessions. Provides a JSON API for the CLI and server-rendered HTML views for browsers.
## Build / Test / Deploy
```bash
# Run all tests (40 tests across 3 files)
bun test --preload ./src/preload.ts src/**/*.test.ts
# Run specific test suites
bun test --preload ./src/preload.ts src/api.test.ts
bun test --preload ./src/preload.ts src/storage.t...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/rpc.ts</path>
<type>file</type>
<content>1: import { RpcTarget } from "capnweb"
2: import { v5 as uuidv5 } from "uuid"
3: import type { SessionBroadcast as SessionBroadcastType } from "./broadcast.ts"
4: import type { ProbeCallback, ProbeValueInput, ProbeValueOutput } from "./rpc-contract.ts"
5: import { createStorageAdapter, type StorageAdapter } from "./storage.ts"
6: import type { AgentSession, SessionIndex, SyncData, SyncInfo } from "./types.ts"
7:
8: type Env = {
9: SESSIONS_STORE: R2Bucket
10: SESSIONS_SHARED_SECRET: string
11: API_DOMAIN: string
12: SESSIONS_BROADCAST: DurableObjectNamespace<SessionBroadcastType>
13: }
14:
15: export class ShareRpcImpl extends RpcTarget {
16: constructor(private env: Env) {
17: super()
18: }
19:
20: async createShare(sessionID: string): Promise<SyncInfo> {
21: const { sessions, index } = this.storage()
22: const shareID = sessionID.slice(-8)
23: const secret = uuidv5(sessionID, this.env.SESSIONS_SHARED_SECRET)
24: const now = Date.now()
25: const info: SyncInfo = {
26: id: shareID,
27: secret,
28: url: `https://${this.env.API_DOMAIN}/share/${shareID}`,
29: }
30:
31: const initial: AgentSession = {
32: session: {
33: id: sessionID,
34: slug: sessionID,
35: projectID: "",
36: directory: "",
37: title: "",
38: version: "1",
39: time: {
40: created: now,
41: updated: now,
42: },
43: },
44: messages: [],
45: parts: [],
46: diffs: [],
47: models: [],
48: metadata: {
49: createdAt: now,
50: lastUpdated: now,
51: syncCount: 0,
52: secret,
53: sessionID,
54: },
55: }
56:
57: const initialIndex: SessionIndex = {
58: id: shareID,
59: sessionID,
60: title: "",
61: directory: "",
62:...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/index.tsx</path>
<type>file</type>
<content>1: import { Hono } from "hono"
2: import { cors } from "hono/cors"
3: import { newWorkersRpcResponse } from "capnweb"
4: import { zValidator } from "@hono/zod-validator"
5: import { z } from "zod"
6: import { v5 as uuidv5 } from "uuid"
7: import type { SyncInfo, ShareCredentials, AgentSession, SessionIndex } from "./types.ts"
8: import { createStorageAdapter, type StorageAdapter } from "./storage.ts"
9: import SessionList from "./views/session-list.tsx"
10: import SessionDetail from "./views/session-detail.tsx"
11: import NotFound from "./views/not-found.tsx"
12: import { ShareRpcImpl } from "./rpc.ts"
13:
14: import type { SessionBroadcast as SessionBroadcastType } from "./broadcast.ts"
15:
16: // Re-export Durable Object class (required by wrangler)
17: export { SessionBroadcast } from "./broadcast.ts"
18:
19: /**
20: * Environment bindings for Cloudflare Worker
21: */
22: type Env = {
23: SESSIONS_STORE: R2Bucket
24: SESSIONS_SHARED_SECRET: string
25: SESSIONS_RPC_SHARED_KEY?: string
26: API_DOMAIN: string
27: SESSIONS_BROADCAST: DurableObjectNamespace<SessionBroadcastType>
28: }
29:
30: function isAuthorizedRpcRequest(c: { req: { header: (name: string) => string | undefined }; env: Env }) {
31: const configured = c.env.SESSIONS_RPC_SHARED_KEY
32: if (!configured) return true
33: const received = c.req.header("x-opencode-share-key")
34: return received === configured
35: }
36:
37: /**
38: * Main Hono application
39: */
40: const app = new Hono<{ Bindings: Env }>()
41:
42: // Enable CORS for API routes only (not for WebSocket or HTML routes)
43: app.use("/api/*", cors())
44:
45: app.all("/rpc/share", async (c) => {
46: if (!isAuthorizedRpcRequest(c)) {
47: return c.json({ error: "Unauthorized" }, 401)
48: }
49: return newWorkersRpcResponse(c.req.raw, new ShareRpcImpl(c.env))
50: })
51:
52: /**
...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/index.test.ts</path>
<type>file</type>
<content>1: import { describe, expect, test } from "bun:test"
2: import app from "./index.tsx"
3: import type { AgentSession, SyncInfo, SessionIndex } from "./types"
4: import {
5: createTestFileDiff,
6: createTestMessage,
7: createTestModel,
8: createTestPart,
9: createTestSession,
10: SESSION_PROPERTIES,
11: validateTypeStructure,
12: } from "./test-utils"
13:
14: const sharedSecret = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
15:
16: const createMockR2Bucket = () => {
17: const storage = new Map<string, string>()
18:
19: const mockBucket: any = {
20: put: async (key: string, value: string | ArrayBuffer) => {
21: let content = ""
22: if (typeof value === "string") {
23: content = value
24: }
25: if (value instanceof ArrayBuffer) {
26: content = new TextDecoder().decode(value)
27: }
28:
29: storage.set(key, content)
30: },
31: get: async (key: string) => {
32: const data = storage.get(key)
33: if (!data) return null
34:
35: return {
36: async text() {
37: return data
38: },
39: async arrayBuffer() {
40: return new TextEncoder().encode(data).buffer
41: },
42: }
43: },
44: delete: async (key: string) => {
45: storage.delete(key)
46: },
47: list: async (options?: any) => {
48: const prefix = options?.prefix || ""
49: const objects = Array.from(storage.keys())
50: .filter((key) => key.startsWith(prefix))
51: .map((key) => ({
52: key,
53: version: "mock",
54: size: storage.get(key)!.length,
55: etag: `"mock-${key}"`,
56: httpMetadata: { contentType: "application/json" },
57: customMetadata: {},
58: uploaded: new Date(),
59: }))
60: return { objects }
61: ...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/api.test.ts</path>
<type>file</type>
<content>1: import { describe, expect, test, beforeEach } from "bun:test"
2: import app from "./index.tsx"
3: import type { AgentSession, SyncInfo, SessionIndex } from "./types"
4: import { createTestFileDiff, createTestMessage, createTestModel, createTestPart, createTestSession } from "./test-utils"
5:
6: const SHARED_SECRET = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
7:
8: type TestEnv = {
9: SESSIONS_STORE: R2Bucket
10: SESSIONS_SHARED_SECRET: string
11: API_DOMAIN: string
12: SESSIONS_BROADCAST: DurableObjectNamespace
13: }
14:
15: function createMockR2Bucket() {
16: const storage = new Map<string, string>()
17:
18: return {
19: put: async (key: string, value: string | ArrayBuffer | ReadableStream) => {
20: let content = ""
21: if (typeof value === "string") {
22: content = value
23: } else if (value instanceof ArrayBuffer) {
24: content = new TextDecoder().decode(value)
25: } else if (value instanceof ReadableStream) {
26: const reader = value.getReader()
27: const chunks: Uint8Array[] = []
28: while (true) {
29: const { done, value: chunk } = await reader.read()
30: if (done) break
31: chunks.push(chunk)
32: }
33: content = new TextDecoder().decode(Buffer.concat(chunks))
34: }
35: storage.set(key, content)
36: },
37: get: async (key: string) => {
38: const data = storage.get(key)
39: if (!data) return null
40: return {
41: async text() {
42: return data
43: },
44: async arrayBuffer() {
45: return new TextEncoder().encode(data).buffer
46: },
47: async json() {
48: return JSON.parse(data)
49: },
50: }
51: },
52: delete: async (key: string) => {
53: storage.delete(key)
54: },
5.../home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/share/rpc-contract.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/share/share.sql.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/share/share-next.ts<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/share/share.sql.ts</path>
<type>file</type>
<content>1: import { sqliteTable, text } from "drizzle-orm/sqlite-core"
2: import { SessionTable } from "../session/session.sql"
3: import { Timestamps } from "@/storage/schema.sql"
4:
5: export const SessionShareTable = sqliteTable("session_share", {
6: session_id: text()
7: .primaryKey()
8: .references(() => SessionTable.id, { onDelete: "cascade" }),
9: id: text().notNull(),
10: secret: text().notNull(),
11: url: text().notNull(),
12: ...Timestamps,
13: })
14:
(End of file - total 14 lines)
</content><path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/share/rpc-contract.ts</path>
<type>file</type>
<content>1: import type { RpcTarget } from "capnweb"
2: import type * as SDK from "@opencode-ai/sdk/v2"
3:
4: export type SyncData =
5: | {
6: type: "session"
7: data: SDK.Session
8: }
9: | {
10: type: "message"
11: data: SDK.Message
12: }
13: | {
14: type: "part"
15: data: SDK.Part
16: }
17: | {
18: type: "session_diff"
19: data: SDK.FileDiff[]
20: }
21: | {
22: type: "model"
23: data: SDK.Model[]
24: }
25:
26: export type SyncInfo = {
27: id: string
28: url: string
29: secret: string
30: }
31:
32: export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
33: export type ProbeValueOutput = {
34: when: string
35: bytes: number[]
36: size: number
37: nested: { x: number }
38: }
39: export type ProbeCallback = (msg: string) => string | Promise<string>
40:
41: export interface ShareRpc extends RpcTarget {
42: createShare: (sessionID: string) => Promise<SyncInfo>
43: syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
44: probeValue: (input: ProbeValueInput) => ProbeValueOutput
45: probeCallback: (cb: ProbeCallback) => Promise<string>
46: }
47:
(End of file - total 47 lines)
</content><path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/session/session.sql.ts</path>
<type>file</type>
<content>1: import { sqliteTable, text, integer, index, primaryKey } from "drizzle-orm/sqlite-core"
2: import { ProjectTable } from "../project/project.sql"
3: import type { MessageV2 } from "./message-v2"
4: import type { Snapshot } from "@/snapshot"
5: import type { PermissionNext } from "@/permission/next"
6: import { Timestamps } from "@/storage/schema.sql"
7:
8: type PartData = Omit<MessageV2.Part, "id" | "sessionID" | "messageID">
9: type InfoData = Omit<MessageV2.Info, "id" | "sessionID">
10:
11: export const SessionTable = sqliteTable(
12: "session",
13: {
14: id: text().primaryKey(),
15: project_id: text()
16: .notNull()
17: .references(() => ProjectTable.id, { onDelete: "cascade" }),
18: parent_id: text(),
19: slug: text().notNull(),
20: directory: text().notNull(),
21: title: text().notNull(),
22: version: text().notNull(),
23: share_url: text(),
24: summary_additions: integer(),
25: summary_deletions: integer(),
26: summary_files: integer(),
27: summary_diffs: text({ mode: "json" }).$type<Snapshot.FileDiff[]>(),
28: revert: text({ mode: "json" }).$type<{ messageID: string; partID?: string; snapshot?: string; diff?: string }>(),
29: permission: text({ mode: "json" }).$type<PermissionNext.Ruleset>(),
30: ...Timestamps,
31: time_compacting: integer(),
32: time_archived: integer(),
33: },
34: (table) => [index("session_project_idx").on(table.project_id), index("session_parent_idx").on(table.parent_id)],
35: )
36:
37: export const MessageTable = sqliteTable(
38: "message",
39: {
40: id: text().primaryKey(),
41: session_id: text()
42: .notNull()
43: .references(() => SessionTable.id, { onDelete: "cascade" }),
44: ...Timestamps,
45: data: text({ mode: "json" }).notNull().$type<InfoData>(),
46: },
47: (tabl...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/storage/schema.ts</path>
<type>file</type>
<content>1: export { ControlAccountTable } from "../control/control.sql"
2: export { SessionTable, MessageTable, PartTable, TodoTable, PermissionTable } from "../session/session.sql"
3: export { SessionShareTable } from "../share/share.sql"
4: export { ProjectTable } from "../project/project.sql"
5:
(End of file - total 5 lines)
</content><path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/types.ts</path>
<type>file</type>
<content>1: /**
2: * SDK Types for OpenCode Agent Sessions
3: * Import core types from @opencode-ai/sdk/v2
4: */
5: import type { Session, Message, Part, FileDiff, Model } from "@opencode-ai/sdk/v2"
6:
7: // Re-export SDK types for convenience
8: export type { Session, Message, Part, FileDiff, Model }
9:
10: /**
11: * Sync data discriminated union type
12: * Represents the different types of data that can be synchronized
13: */
14: export type SyncData =
15: | { type: "session"; data: Session }
16: | { type: "message"; data: Message }
17: | { type: "part"; data: Part }
18: | { type: "session_diff"; data: FileDiff[] }
19: | { type: "model"; data: Model[] }
20:
21: /**
22: * Complete agent session structure
23: * This represents a fully reconstructed session from sync data
24: */
25: export type SessionMetadata = {
26: createdAt: number
27: lastUpdated: number
28: syncCount: number
29: secret: string
30: sessionID: string
31: }
32:
33: /**
34: * Lightweight index entry stored at index/${shareID}
35: * Used by list endpoints to avoid loading full session blobs
36: */
37: export type SessionIndex = {
38: id: string
39: sessionID: string
40: title: string
41: directory: string
42: messageCount: number
43: partCount: number
44: diffCount: number
45: modelCount: number
46: lastUpdated: number
47: syncCount: number
48: createdAt: number
49: }
50:
51: export type AgentSession = {
52: session: Session
53: messages: Message[]
54: parts: Part[]
55: diffs: FileDiff[]
56: models: Model[]
57: metadata: SessionMetadata
58: }
59:
60: /**
61: * Share credentials
62: */
63: export type SyncInfo = {
64: id: string
65: url: string
66: secret: string
67: }
68:
69: export type ShareCredentials = SyncInfo & {
70: sessionID: string
71: createdAt: number
72: }
73:
74: export type Secret...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/storage.test.ts</path>
<type>file</type>
<content>1: /**
2: * Storage Adapter Tests
3: * Unit tests for the storage adapter implementation
4: */
5:
6: import { describe, it, expect, beforeEach } from "bun:test"
7: import { MockStorageAdapter, Storage } from "./storage"
8:
9: describe("MockStorageAdapter", () => {
10: let adapter: MockStorageAdapter<any>
11:
12: beforeEach(() => {
13: adapter = new MockStorageAdapter()
14: })
15:
16: it("should put and get values", async () => {
17: const testData = { id: "test", secret: "secret123", sessionID: "session123" }
18:
19: await adapter.put("test-key", testData)
20: const result = await adapter.get("test-key")
21:
22: expect(result).toEqual(testData)
23: })
24:
25: it("should return null for non-existent keys", async () => {
26: const result = await adapter.get("non-existent-key")
27: expect(result).toBeNull()
28: })
29:
30: it("should delete values", async () => {
31: const testData = { id: "test", secret: "secret123" }
32:
33: await adapter.put("test-key", testData)
34: await adapter.delete("test-key")
35: const result = await adapter.get("test-key")
36:
37: expect(result).toBeNull()
38: })
39:
40: it("should check if values exist", async () => {
41: const testData = { id: "test" }
42:
43: expect(await adapter.exists("test-key")).toBeFalse()
44:
45: await adapter.put("test-key", testData)
46: expect(await adapter.exists("test-key")).toBeTrue()
47: })
48:
49: it("should list values with prefix", async () => {
50: const data1 = { id: "test1" }
51: const data2 = { id: "test2" }
52: const data3 = { id: "other" }
53:
54: await adapter.put("credentials/test1", data1)
55: await adapter.put("credentials/test2", data2)
56: await adapter.put("sessions/other", data3)
57:
58: const result = await adapter.list({ p...No files foundFound 60 matches
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/index.test.ts:
Line 124: const { response, data: share } = await createShare(sessionID, env)
Line 137: const { response: syncResponse, data: syncResult } = await syncShare(share.id, env, {
Line 167: const { data: share } = await createShare("session-a", env)
Line 169: await syncShare(share.id, env, {
Line 174: const { data: shareB } = await createShare("session-b", env)
Line 176: await syncShare(shareB.id, env, {
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/src/api.test.ts:
Line 100: async function createShare(sessionID: string, env: TestEnv) {
Line 113: async function syncShare(
Line 175: const { response, data } = await createShare("session-abc123", env)
Line 183: const { data } = await createShare("test-session-id", env)
Line 190: const { data } = await createShare("1234567890abcdefghijklmnop", env)
Line 197: const { data: share1 } = await createShare("same-session-id", env1)
Line 198: const { data: share2 } = await createShare("same-session-id", env2)
Line 211: const { data: share } = await createShare("sync-test", env)
Line 214: const { response, data } = await syncShare(share.id, env, {
Line 225: const { data: share } = await createShare("sync-test", env)
Line 228: const { response, data } = await syncShare(share.id, env, {
Line 238: const { response, data } = await syncShare("nonexist", env, {
Line 248: const { data: share } = await createShare("msg-test", env)
Line 252: await syncShare(share.id, env, {
Line 257: await syncShare(share.id, env, {
Line 273: const { data: share } = await createShare("msg-update", env)
Line 276: await syncShare(share.id, env, {
Line 282: await syncShare(share.id, env, {
Line 296: const { data: share } = await createShare("part-test", env)
Line 300: awa.../home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/wildcard.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/timeout.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/network.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/lock.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/lazy.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/iife.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/glob.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/format.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/util/filesystem.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/write.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/webfetch.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/truncation.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/skill.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/registry.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/read.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/question.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/grep.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/external-directory.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/edit.test.ts
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/tool/b...Found 55 matches
/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/test/storage/json-migration.test.ts:
Line 12: import { SessionShareTable } from "../../src/share/share.sql"
Line 60: await fs.mkdir(path.join(storageDir, "session_share"), { recursive: true })
Line 213: share: { url: "https://example.com/share" },
Line 227: expect(sessions[0].share_url).toBe("https://example.com/share")
Line 581: test("migrates session shares", async () => {
Line 590: // Create session share file (named by sessionID)
Line 592: path.join(storageDir, "session_share", "ses_test456def.json"),
Line 594: id: "share_123",
Line 596: url: "https://share.example.com/ses_test456def",
Line 602: expect(stats?.shares).toBe(1)
Line 605: const shares = db.select().from(SessionShareTable).all()
Line 606: expect(shares.length).toBe(1)
Line 607: expect(shares[0].session_id).toBe("ses_test456def")
Line 608: expect(shares[0].id).toBe("share_123")
Line 609: expect(shares[0].secret).toBe("supersecretkey")
Line 610: expect(shares[0].url).toBe("https://share.example.com/ses_test456def")
Line 624: expect(stats.shares).toBe(0)
Line 678: test("skips orphaned todos, permissions, and shares", async () => {
Line 706: path.join(storageDir, "session_share", "ses_test456def.json"),
Line 707: JSON.stringify({ id: "share_ok", secret: "secret", url: "https://ok.example.com" }),
Line 710: path.join(storageDir, "session_share", "ses_missing.json"),
Line 711: JSON.stringify({ id: "share_missing", secret: "secret", url: "https://missing.example.com" }),
Line 718: expect(stats.shares).toBe(1)
Line 814: path.join(storageDir, "session_share", "ses_test456def.json"),
Line 815: JSON.stringify({ id: "share_ok", secret: "secret", url: "https://ok.example.com" }),
Line 818: path.join(storageDir, "session_share", "ses_missing.json"),
Lin...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/storage/db.ts</path>
<type>file</type>
<content>1: import { Database as BunDatabase } from "bun:sqlite"
2: import { drizzle, type SQLiteBunDatabase } from "drizzle-orm/bun-sqlite"
3: import { migrate } from "drizzle-orm/bun-sqlite/migrator"
4: import { type SQLiteTransaction } from "drizzle-orm/sqlite-core"
5: export * from "drizzle-orm"
6: import { Context } from "../util/context"
7: import { lazy } from "../util/lazy"
8: import { Global } from "../global"
9: import { Log } from "../util/log"
10: import { NamedError } from "@opencode-ai/util/error"
11: import z from "zod"
12: import path from "path"
13: import { readFileSync, readdirSync, existsSync } from "fs"
14: import * as schema from "./schema"
15:
16: declare const OPENCODE_MIGRATIONS: { sql: string; timestamp: number }[] | undefined
17:
18: export const NotFoundError = NamedError.create(
19: "NotFoundError",
20: z.object({
21: message: z.string(),
22: }),
23: )
24:
25: const log = Log.create({ service: "db" })
26:
27: export namespace Database {
28: export const Path = path.join(Global.Path.data, "opencode.db")
29: type Schema = typeof schema
30: export type Transaction = SQLiteTransaction<"sync", void, Schema>
31:
32: type Client = SQLiteBunDatabase<Schema>
33:
34: type Journal = { sql: string; timestamp: number }[]
35:
36: function time(tag: string) {
37: const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(tag)
38: if (!match) return 0
39: return Date.UTC(
40: Number(match[1]),
41: Number(match[2]) - 1,
42: Number(match[3]),
43: Number(match[4]),
44: Number(match[5]),
45: Number(match[6]),
46: )
47: }
48:
49: function migrations(dir: string): Journal {
50: const dirs = readdirSync(dir, { withFileTypes: true })
51: .filter((entry) => entry.isDirectory())
52: .map((entry) => entry.name)
53:
54: const sql = ...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/src/storage/json-migration.ts</path>
<type>file</type>
<content>1: import { Database } from "bun:sqlite"
2: import { drizzle } from "drizzle-orm/bun-sqlite"
3: import { Global } from "../global"
4: import { Log } from "../util/log"
5: import { ProjectTable } from "../project/project.sql"
6: import { SessionTable, MessageTable, PartTable, TodoTable, PermissionTable } from "../session/session.sql"
7: import { SessionShareTable } from "../share/share.sql"
8: import path from "path"
9: import { existsSync } from "fs"
10: import { Filesystem } from "../util/filesystem"
11: import { Glob } from "../util/glob"
12:
13: export namespace JsonMigration {
14: const log = Log.create({ service: "json-migration" })
15:
16: export type Progress = {
17: current: number
18: total: number
19: label: string
20: }
21:
22: type Options = {
23: progress?: (event: Progress) => void
24: }
25:
26: export async function run(sqlite: Database, options?: Options) {
27: const storageDir = path.join(Global.Path.data, "storage")
28:
29: if (!existsSync(storageDir)) {
30: log.info("storage directory does not exist, skipping migration")
31: return {
32: projects: 0,
33: sessions: 0,
34: messages: 0,
35: parts: 0,
36: todos: 0,
37: permissions: 0,
38: shares: 0,
39: errors: [] as string[],
40: }
41: }
42:
43: log.info("starting json to sqlite migration", { storageDir })
44: const start = performance.now()
45:
46: const db = drizzle({ client: sqlite })
47:
48: // Optimize SQLite for bulk inserts
49: sqlite.exec("PRAGMA journal_mode = WAL")
50: sqlite.exec("PRAGMA synchronous = OFF")
51: sqlite.exec("PRAGMA cache_size = 10000")
52: sqlite.exec("PRAGMA temp_store = MEMORY")
53: const stats = {
54: projects: 0,
55: sessions: 0,
56: messages: 0,
...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/package.json</path>
<type>file</type>
<content>1: {
2: "$schema": "https://json.schemastore.org/package.json",
3: "name": "opencode",
4: "description": "AI-powered development tool",
5: "private": true,
6: "type": "module",
7: "packageManager": "bun@1.3.9",
8: "scripts": {
9: "dev": "bun run --cwd packages/opencode --conditions=browser src/index.ts",
10: "dev:desktop": "bun --cwd packages/desktop tauri dev",
11: "dev:web": "bun --cwd packages/app dev",
12: "typecheck": "bun turbo typecheck --filter='!@opencode-ai/app' --filter='!@opencode-ai/desktop' --filter='!@opencode-ai/ui' --filter='!@opencode-ai/console-*' --filter='!@opencode-ai/enterprise' --filter='!@opencode-ai/slack'",
13: "prepare": "husky",
14: "random": "echo 'Random script'",
15: "hello": "echo 'Hello World!'",
16: "test": "echo 'do not run tests from root' && exit 1"
17: },
18: "workspaces": {
19: "packages": [
20: "packages/*",
21: "packages/console/*",
22: "packages/sdk/js",
23: "packages/slack"
24: ],
25: "catalog": {
26: "@types/bun": "1.3.9",
27: "@octokit/rest": "22.0.0",
28: "@hono/zod-validator": "0.4.2",
29: "ulid": "3.0.1",
30: "@kobalte/core": "0.13.11",
31: "@types/luxon": "3.7.1",
32: "@types/node": "22.13.9",
33: "@types/semver": "7.7.1",
34: "@tsconfig/node22": "22.0.2",
35: "@tsconfig/bun": "1.0.9",
36: "@cloudflare/workers-types": "4.20251008.0",
37: "@openauthjs/openauth": "0.0.0-20250322224806",
38: "@pierre/diffs": "1.1.0-beta.13",
39: "@solid-primitives/storage": "4.3.3",
40: "@tailwindcss/vite": "4.1.11",
41: "diff": "8.0.2",
42: "dompurify": "3.3.1",
43: "drizzle-kit": "1.0.0-beta.12-a5629fb",
44: "drizzle-orm": "1.0.0-beta.12-a5629fb",
45: "ai": "5.0.124",
46: "hono": "4.10.7",
47: "hono-openapi": "1....<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/opencode/package.json</path>
<type>file</type>
<content>1: {
2: "$schema": "https://json.schemastore.org/package.json",
3: "version": "1.2.10",
4: "name": "opencode",
5: "type": "module",
6: "license": "MIT",
7: "private": true,
8: "scripts": {
9: "typecheck": "tsgo --noEmit",
10: "test": "bun test --timeout 30000",
11: "build": "bun run script/build.ts",
12: "dev": "bun run --conditions=browser ./src/index.ts",
13: "random": "echo 'Random script updated at $(date)' && echo 'Change queued successfully' && echo 'Another change made' && echo 'Yet another change' && echo 'One more change' && echo 'Final change' && echo 'Another final change' && echo 'Yet another final change'",
14: "clean": "echo 'Cleaning up...' && rm -rf node_modules dist",
15: "lint": "echo 'Running lint checks...' && bun test --coverage",
16: "format": "echo 'Formatting code...' && bun run --prettier --write src/**/*.ts",
17: "docs": "echo 'Generating documentation...' && find src -name '*.ts' -exec echo 'Processing: {}' \\;",
18: "deploy": "echo 'Deploying application...' && bun run build && echo 'Deployment completed successfully'",
19: "db": "bun drizzle-kit"
20: },
21: "bin": {
22: "opencode": "./bin/opencode"
23: },
24: "randomField": "this-is-a-random-value-12345",
25: "exports": {
26: "./*": "./src/*.ts"
27: },
28: "devDependencies": {
29: "@babel/core": "7.28.4",
30: "@octokit/webhooks-types": "7.6.1",
31: "@opencode-ai/script": "workspace:*",
32: "@parcel/watcher-darwin-arm64": "2.5.1",
33: "@parcel/watcher-darwin-x64": "2.5.1",
34: "@parcel/watcher-linux-arm64-glibc": "2.5.1",
35: "@parcel/watcher-linux-arm64-musl": "2.5.1",
36: "@parcel/watcher-linux-x64-glibc": "2.5.1",
37: "@parcel/watcher-linux-x64-musl": "2.5.1",
38: "@parcel/watcher-win32-x64": "2.5.1",
39: "@standard-schema/spec": "1.0.0",...<path>/home/jm/data/code/opencode-trees/fr-capnweb-persistence/packages/cloudsession/package.json</path>
<type>file</type>
<content>1: {
2: "$schema": "https://json.schemastore.org/package.json",
3: "name": "@opencode-ai/cloudsession",
4: "version": "1.0.207",
5: "private": true,
6: "type": "module",
7: "module": "index.ts",
8: "scripts": {
9: "generate-types": "wrangler types",
10: "typecheck": "wrangler types && tsc --noEmit",
11: "test": "bun test src/**/*.test.ts",
12: "test:api": "bun test src/api.test.ts",
13: "test:storage": "bun test src/storage.test.ts",
14: "dev": "wrangler dev --env dev",
15: "deploy": "wrangler deploy --keep-vars"
16: },
17: "devDependencies": {
18: "@tsconfig/bun": "1.0.9",
19: "@types/bun": "latest",
20: "@types/node": "catalog:",
21: "typescript": "5.9.3",
22: "wrangler": "4.63.0"
23: },
24: "dependencies": {
25: "@cloudflare/types": "7.0.0",
26: "@hono/zod-validator": "catalog:",
27: "@opencode-ai/sdk": "workspace:*",
28: "capnweb": "0.4.0",
29: "hono": "catalog:",
30: "marked": "17.0.1",
31: "uuid": "13.0.0",
32: "zod": "catalog:"
33: }
34: }
35:
(End of file - total 35 lines)
</content>Great direction. Here is a concrete prototype plan focused on making capnweb transport durable, replayable, and capability-aware.
Prototype Shape
packages/opencode/src/share/share-next.ts and packages/cloudsession/src/rpc.ts, while keeping current REST + syncShare() behavior for fallback compatibility.Implementation Plan
packages/opencode/src/share/rpc-contract.ts and packages/cloudsession/src/rpc-contract.ts with op-envelope types: op_id, batch_id, seq, depends_on, expected_cursor, capability.redeemShare(...) and appendOps(...); keep existing syncShare(...) for backwards compatibility.packages/opencode/src/share/share.sql.ts (and export in packages/opencode/src/storage/schema.ts), then migration.packages/opencode/src/share/share-next.ts with DB-backed enqueue/flush/retry (store deterministic batch metadata so retries resend same grouped order).pending, in_flight, acked, failed, attempts, next_retry_at, last_error).packages/cloudsession/src/rpc.ts, process appendOps with dedupe by op_id and monotonic cursor ack.cursor, applied, duplicates, rejected.packages/cloudsession/src/types.ts (for prototype: bounded applied-op window + cursor).redeemShare returns current cursor + usable capability context for reconnect.packages/opencode/src/share/share-next.ts, load pending outbox and resume flush.Tests To Prove Each Discussed Feature
packages/cloudsession/src/rpc.persistence.test.ts:redeemShare returns stable identity and latest cursor.batch_id/op_id resent -> no duplicate message/part/model/diff writes.appendOps.packages/opencode/test/share/share-next-persistence.test.ts:syncShare path still works via packages/cloudsession/src/api.test.ts.appendOps and syncShare lead to equivalent final session shape for same payload.Known Limits (Prototype)
RpcPromise objects themselves; it persists call intents and ack state (the correct durable unit).share/ + index/) are not truly transactional; for strict serializability, phase 2 can route all mutations through one Durable Object per share.Suggested execution order
appendOpsIf you want, next I can turn this into a step-by-step implementation checklist with exact schema fields and test case names ready to code.
Perfect — here is an orchestrator-ready implementation plan with explicit validation gates per step.
Execution Plan
packages/opencode/src/share/rpc-contract.ts and packages/cloudsession/src/rpc-contract.ts with durable op envelope types: op_id, batch_id, seq, depends_on, expected_cursor, capability_epoch, plus ack type (cursor, applied, duplicates, rejected).ShareRpc: redeemShare(...), appendOps(...), revokeCapability(...) (prototype can keep revoke as epoch bump).bun --cwd packages/cloudsession tsc --noEmit and bun --cwd packages/opencode run typecheck both pass.packages/cloudsession/src/types.ts metadata with prototype RPC state: cursor, capabilityEpoch, and a bounded dedupe ledger (applied_recent ring/list of op IDs)./api/share*) by defaulting missing fields during read.bun --cwd packages/cloudsession test --preload ./src/preload.ts src/api.test.ts src/index.test.ts.redeemShare and capability epoch checks in RPC serverpackages/cloudsession/src/rpc.ts:redeemShare(shareID, secret) -> returns cursor, capabilityEpoch, and basic share metadata.capability_epoch.createShare and syncShare unchanged.packages/cloudsession/src/rpc.persistence.test.ts:appendOps with cursor advancementappendOps(shareID, secret, capabilityEpoch, ops) in packages/cloudsession/src/rpc.ts.op_id already seen -> mark duplicate;depends_on) -> reject op;cursor/applied/duplicates/rejected.rpc.persistence.test.ts cases:packages/opencode/src/share/share.sql.ts with:cursor, capability_epoch, last acked batch).packages/opencode/src/storage/schema.ts.packages/opencode: bun run db generate --name share_outbox_prototype.bun --cwd packages/opencode test test/storage/json-migration.test.ts.packages/opencode/src/share/share-next.ts (or a new helper module under same folder) to enqueue, reserve, ack, retry, and recover pending ops.batch_id + seq so replay preserves original pipeline order.packages/opencode/test/share/share-outbox.test.ts:packages/opencode/src/share/share-next.ts with:redeemShare then appendOps;packages/opencode/test/share/share-replay.test.ts:packages/cloudsession/src/rpc.capability.test.ts.bun --cwd packages/cloudsession test --preload ./src/preload.ts src/**/*.test.tsbun --cwd packages/cloudsession tsc --noEmitbun --cwd packages/opencode test --preload ./test/preload.ts test/share/*.test.tsbun --cwd packages/opencode run typecheckFeature-to-Test Mapping (What this proves)
redeemShare cursor continuity tests.batch_id/seq replay tests.Orchestrator Dependency Graph
Recommended default choices for prototype
RpcPromise state.One design choice to confirm before implementation: do you want prototype dedupe to be bounded window (faster) or full permanent op-id log (stronger, more storage)? I recommend bounded window for v1; full log changes storage growth and compaction strategy.