| import { randomBytes } from "node:crypto"; |
| import type { |
| BoardOp, |
| BoardSnapshot, |
| BoardWidgetMaterializedPutParams, |
| } from "../../packages/gateway-protocol/src/index.js"; |
| import { withOpenClawAgentDatabaseReadOnly } from "../state/openclaw-agent-db-readonly.js"; |
| import { |
| openOpenClawAgentDatabase, |
| runOpenClawAgentWriteTransaction, |
| type OpenClawAgentDatabase, |
| } from "../state/openclaw-agent-db.js"; |
| import { BoardValidationError } from "./board-layout.js"; |
| import { |
| cloneBoardSnapshot, |
| normalizeBoardWidgetPutParams, |
| type BoardSessionTarget, |
| type BoardStore, |
| type BoardWriteOptions, |
| type BoardWidgetDocument, |
| type BoardSnapshotWithHtmlViewMetadata, |
| type BoardWidgetMcpAppDocument, |
| } from "./board-store.js"; |
| import { rowToBoardWidgetDocument } from "./sqlite-board-codec.js"; |
| import { |
| ensureBoardSchema, |
| hasBoardSession, |
| readBoardSessionKeys, |
| readBoardSnapshotWithHtmlViewMetadata, |
| readBoardWidgetRow, |
| applyBoardOpsToDatabase, |
| putBoardWidgetInDatabase, |
| grantBoardWidgetInDatabase, |
| } from "./sqlite-board-store.kernel.js"; |
|
|
| type SqliteBoardStoreOptions = { |
| resolveSession: (target: BoardSessionTarget) => { |
| agentId: string; |
| path?: string; |
| sessionKey: string; |
| }; |
| env?: NodeJS.ProcessEnv; |
| }; |
|
|
| export async function listBoardSessionKeysReadOnly(params: { |
| agentId: string; |
| path: string; |
| env?: NodeJS.ProcessEnv; |
| }): Promise<ReadonlySet<string>> { |
| const result = withOpenClawAgentDatabaseReadOnly(readBoardSessionKeys, params); |
| return new Set(result.found ? result.value : []); |
| } |
|
|
| function emptyBoardSnapshot(sessionKey: string): BoardSnapshot { |
| return { sessionKey, revision: 0, tabs: [], widgets: [] }; |
| } |
|
|
| export class SqliteBoardStore implements BoardStore { |
| constructor(private readonly options: SqliteBoardStoreOptions) {} |
|
|
| private resolve(target: BoardSessionTarget): { |
| agentId: string; |
| path?: string; |
| sessionKey: string; |
| } { |
| return this.options.resolveSession(target); |
| } |
|
|
| private requireExistingSession(resolved: { |
| agentId: string; |
| path?: string; |
| sessionKey: string; |
| }): void { |
| const result = withOpenClawAgentDatabaseReadOnly( |
| (database) => hasBoardSession(database, resolved.sessionKey), |
| { |
| agentId: resolved.agentId, |
| ...(resolved.path ? { path: resolved.path } : {}), |
| env: this.options.env, |
| }, |
| ); |
| if (!result.found || !result.value) { |
| throw new BoardValidationError( |
| "not_found", |
| `board session not found: ${resolved.sessionKey}`, |
| ); |
| } |
| } |
|
|
| private prepareWrite(target: BoardSessionTarget): { |
| database: OpenClawAgentDatabase; |
| resolved: { agentId: string; path?: string; sessionKey: string }; |
| } { |
| const resolved = this.resolve(target); |
| this.requireExistingSession(resolved); |
| const database = openOpenClawAgentDatabase({ |
| agentId: resolved.agentId, |
| ...(resolved.path ? { path: resolved.path } : {}), |
| env: this.options.env, |
| }); |
| ensureBoardSchema(database); |
| return { database, resolved }; |
| } |
|
|
| async getSnapshot(target: BoardSessionTarget): Promise<BoardSnapshot> { |
| return this.readSnapshotWithHtmlViewMetadata(target).snapshot; |
| } |
|
|
| async getSnapshotWithHtmlViewMetadata( |
| target: BoardSessionTarget, |
| ): Promise<BoardSnapshotWithHtmlViewMetadata> { |
| return this.readSnapshotWithHtmlViewMetadata(target); |
| } |
|
|
| async useSnapshot<T>( |
| target: BoardSessionTarget, |
| consume: (snapshot: BoardSnapshot) => T, |
| ): Promise<Awaited<T>> { |
| return await consume(this.readSnapshotWithHtmlViewMetadata(target).snapshot); |
| } |
|
|
| async useWidgetDocument<T>( |
| target: BoardSessionTarget, |
| name: string, |
| consume: (document: BoardWidgetDocument | undefined) => T, |
| ): Promise<Awaited<T>> { |
| return await consume(this.readWidgetDocument(target, name)); |
| } |
|
|
| private readSnapshotWithHtmlViewMetadata( |
| target: BoardSessionTarget, |
| ): BoardSnapshotWithHtmlViewMetadata { |
| const resolved = this.resolve(target); |
| const result = withOpenClawAgentDatabaseReadOnly( |
| (database) => readBoardSnapshotWithHtmlViewMetadata(database, resolved.sessionKey), |
| { |
| agentId: resolved.agentId, |
| ...(resolved.path ? { path: resolved.path } : {}), |
| env: this.options.env, |
| }, |
| ); |
| const stored = result.found ? result.value : undefined; |
| return { |
| snapshot: cloneBoardSnapshot(stored?.snapshot ?? emptyBoardSnapshot(resolved.sessionKey)), |
| htmlViewMetadata: stored?.htmlViewMetadata ?? new Map(), |
| }; |
| } |
|
|
| async applyOps( |
| target: BoardSessionTarget, |
| ops: readonly BoardOp[], |
| options?: BoardWriteOptions, |
| ): Promise<BoardSnapshot> { |
| if (ops.length === 0) { |
| return this.getSnapshot(target); |
| } |
| options?.assertCurrent?.(); |
| const { database, resolved } = this.prepareWrite(target); |
| return runOpenClawAgentWriteTransaction( |
| (transactionDatabase) => { |
| options?.assertCurrent?.(); |
| return applyBoardOpsToDatabase(transactionDatabase, resolved.sessionKey, ops); |
| }, |
| { agentId: resolved.agentId, path: database.path, env: this.options.env }, |
| { operationLabel: "board.apply-ops" }, |
| ); |
| } |
|
|
| async putWidget(params: BoardWidgetMaterializedPutParams, options?: BoardWriteOptions) { |
| options?.assertCurrent?.(); |
| const { database, resolved } = this.prepareWrite(params); |
| const canonicalInput = normalizeBoardWidgetPutParams(params, resolved.sessionKey); |
| const viewGeneration = randomBytes(16).toString("hex"); |
| return runOpenClawAgentWriteTransaction( |
| (transactionDatabase) => { |
| options?.assertCurrent?.(); |
| return putBoardWidgetInDatabase( |
| transactionDatabase, |
| resolved.sessionKey, |
| canonicalInput, |
| viewGeneration, |
| ); |
| }, |
| { agentId: resolved.agentId, path: database.path, env: this.options.env }, |
| { operationLabel: "board.put-widget" }, |
| ); |
| } |
|
|
| async grant( |
| target: BoardSessionTarget, |
| name: string, |
| decision: "granted" | "rejected", |
| revision: number, |
| instanceId?: string, |
| options?: BoardWriteOptions, |
| ): Promise<BoardSnapshot> { |
| options?.assertCurrent?.(); |
| const { database, resolved } = this.prepareWrite(target); |
| return runOpenClawAgentWriteTransaction( |
| (transactionDatabase) => { |
| options?.assertCurrent?.(); |
| return grantBoardWidgetInDatabase( |
| transactionDatabase, |
| resolved.sessionKey, |
| name, |
| decision, |
| revision, |
| instanceId, |
| ); |
| }, |
| { agentId: resolved.agentId, path: database.path, env: this.options.env }, |
| { operationLabel: "board.grant-widget" }, |
| ); |
| } |
|
|
| private readWidgetDocument( |
| target: BoardSessionTarget, |
| name: string, |
| contentKind?: "mcp-app", |
| ): BoardWidgetDocument | undefined { |
| const resolved = this.resolve(target); |
| const result = withOpenClawAgentDatabaseReadOnly( |
| (database) => readBoardWidgetRow(database, resolved.sessionKey, name), |
| { |
| agentId: resolved.agentId, |
| ...(resolved.path ? { path: resolved.path } : {}), |
| env: this.options.env, |
| }, |
| ); |
| const row = result.found ? result.value : undefined; |
| return row && (!contentKind || row.content_kind === contentKind) |
| ? rowToBoardWidgetDocument(row) |
| : undefined; |
| } |
|
|
| async readWidgetMcpApp( |
| target: BoardSessionTarget, |
| name: string, |
| ): Promise<BoardWidgetMcpAppDocument | undefined> { |
| const document = this.readWidgetDocument(target, name, "mcp-app"); |
| return document && "descriptor" in document ? document : undefined; |
| } |
| } |
|
|
