oh-my-opencode-dashboard 0.0.4 → 0.0.5

package/src/ingest/tool-calls.test.ts

@@ -0,0 +1,161 @@
+import * as os from "node:os"
+import * as path from "node:path"
+import * as fs from "node:fs"
+import { describe, expect, it } from "vitest"
+import { deriveToolCalls, MAX_TOOL_CALL_MESSAGES, MAX_TOOL_CALLS } from "./tool-calls"
+import { getStorageRoots } from "./session"
+
+function mkStorageRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "omo-storage-"))
+  fs.mkdirSync(path.join(root, "session"), { recursive: true })
+  fs.mkdirSync(path.join(root, "message"), { recursive: true })
+  fs.mkdirSync(path.join(root, "part"), { recursive: true })
+  return root
+}
+
+function writeMessageMeta(opts: {
+  storageRoot: string
+  sessionId: string
+  messageId: string
+  created?: number
+}): void {
+  const storage = getStorageRoots(opts.storageRoot)
+  const msgDir = path.join(storage.message, opts.sessionId)
+  fs.mkdirSync(msgDir, { recursive: true })
+  const meta: Record<string, unknown> = {
+    id: opts.messageId,
+    sessionID: opts.sessionId,
+    role: "assistant",
+  }
+  if (typeof opts.created === "number") {
+    meta.time = { created: opts.created }
+  }
+  fs.writeFileSync(path.join(msgDir, `${opts.messageId}.json`), JSON.stringify(meta), "utf8")
+}
+
+function writeToolPart(opts: {
+  storageRoot: string
+  sessionId: string
+  messageId: string
+  callId: string
+  tool: string
+  state?: Record<string, unknown>
+}): void {
+  const storage = getStorageRoots(opts.storageRoot)
+  const partDir = path.join(storage.part, opts.messageId)
+  fs.mkdirSync(partDir, { recursive: true })
+  fs.writeFileSync(
+    path.join(partDir, `${opts.callId}.json`),
+    JSON.stringify({
+      id: `part_${opts.callId}`,
+      sessionID: opts.sessionId,
+      messageID: opts.messageId,
+      type: "tool",
+      callID: opts.callId,
+      tool: opts.tool,
+      state: opts.state ?? { status: "completed", input: {} },
+    }),
+    "utf8"
+  )
+}
+
+function hasBannedKeys(value: unknown, banned: Set<string>): boolean {
+  if (!value || typeof value !== "object") return false
+  if (Array.isArray(value)) {
+    return value.some((item) => hasBannedKeys(item, banned))
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (banned.has(key)) return true
+    if (hasBannedKeys(child, banned)) return true
+  }
+  return false
+}
+
+describe("deriveToolCalls", () => {
+  it("orders tool calls deterministically and sorts null timestamps last", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const sessionId = "ses_main"
+
+    writeMessageMeta({ storageRoot, sessionId, messageId: "msg_0", created: 500 })
+    writeToolPart({ storageRoot, sessionId, messageId: "msg_0", callId: "call_a", tool: "read" })
+
+    writeMessageMeta({ storageRoot, sessionId, messageId: "msg_1", created: 1000 })
+    writeToolPart({ storageRoot, sessionId, messageId: "msg_1", callId: "call_a", tool: "bash" })
+
+    writeMessageMeta({ storageRoot, sessionId, messageId: "msg_2", created: 1000 })
+    writeToolPart({ storageRoot, sessionId, messageId: "msg_2", callId: "call_b", tool: "grep" })
+    writeToolPart({ storageRoot, sessionId, messageId: "msg_2", callId: "call_a", tool: "grep" })
+
+    writeMessageMeta({ storageRoot, sessionId, messageId: "msg_3" })
+    writeToolPart({ storageRoot, sessionId, messageId: "msg_3", callId: "call_z", tool: "read" })
+
+    const result = deriveToolCalls({ storage, sessionId })
+    expect(result.toolCalls.map((row) => `${row.messageId}:${row.callId}`)).toEqual([
+      "msg_1:call_a",
+      "msg_2:call_a",
+      "msg_2:call_b",
+      "msg_0:call_a",
+      "msg_3:call_z",
+    ])
+    expect(result.toolCalls[0].createdAtMs).toBe(1000)
+    expect(result.toolCalls[4].createdAtMs).toBe(null)
+    expect(result.truncated).toBe(false)
+  })
+
+  it("caps message scan and tool call output", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const sessionId = "ses_main"
+
+    const totalMessages = MAX_TOOL_CALL_MESSAGES + 5
+    for (let i = 0; i < totalMessages; i += 1) {
+      const suffix = String(i).padStart(3, "0")
+      const messageId = `msg_${suffix}`
+      writeMessageMeta({ storageRoot, sessionId, messageId, created: i })
+      writeToolPart({ storageRoot, sessionId, messageId, callId: `call_${suffix}_a`, tool: "bash" })
+      writeToolPart({ storageRoot, sessionId, messageId, callId: `call_${suffix}_b`, tool: "read" })
+    }
+
+    const result = deriveToolCalls({ storage, sessionId })
+    expect(result.toolCalls.length).toBe(MAX_TOOL_CALLS)
+    expect(result.truncated).toBe(true)
+
+    const messageIds = new Set(result.toolCalls.map((row) => row.messageId))
+    for (let i = 0; i < 5; i += 1) {
+      const suffix = String(i).padStart(3, "0")
+      expect(messageIds.has(`msg_${suffix}`)).toBe(false)
+    }
+    for (let i = totalMessages - 5; i < totalMessages; i += 1) {
+      const suffix = String(i).padStart(3, "0")
+      expect(messageIds.has(`msg_${suffix}`)).toBe(true)
+    }
+  })
+
+  it("redacts tool call payload fields", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const sessionId = "ses_main"
+
+    writeMessageMeta({ storageRoot, sessionId, messageId: "msg_1", created: 1000 })
+    writeToolPart({
+      storageRoot,
+      sessionId,
+      messageId: "msg_1",
+      callId: "call_secret",
+      tool: "bash",
+      state: {
+        status: "completed",
+        input: { prompt: "SECRET", nested: { output: "HIDDEN" } },
+        output: "NOPE",
+        error: "NOPE",
+      },
+    })
+
+    const result = deriveToolCalls({ storage, sessionId })
+    expect(result.toolCalls.length).toBe(1)
+
+    const banned = new Set(["prompt", "input", "output", "error", "state"])
+    expect(hasBannedKeys(result.toolCalls[0], banned)).toBe(false)
+  })
+})

package/src/ingest/tool-calls.ts

@@ -0,0 +1,157 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import type { OpenCodeStorageRoots, StoredMessageMeta } from "./session"
+import { getMessageDir } from "./session"
+import { assertAllowedPath } from "./paths"
+
+type FsLike = Pick<typeof fs, "readFileSync" | "readdirSync" | "existsSync" | "statSync">
+
+export const MAX_TOOL_CALL_MESSAGES = 200
+export const MAX_TOOL_CALLS = 300
+
+export type ToolCallSummary = {
+  sessionId: string
+  messageId: string
+  callId: string
+  tool: string
+  status: "pending" | "running" | "completed" | "error" | "unknown"
+  createdAtMs: number | null
+}
+
+export type ToolCallSummaryResult = {
+  toolCalls: ToolCallSummary[]
+  truncated: boolean
+}
+
+type StoredToolPartMeta = {
+  type?: string
+  callID?: string
+  tool?: string
+  state?: { status?: string }
+}
+
+function readJsonFile<T>(filePath: string, fsLike: FsLike): T | null {
+  try {
+    const content = fsLike.readFileSync(filePath, "utf8")
+    return JSON.parse(content) as T
+  } catch {
+    return null
+  }
+}
+
+function listJsonFiles(dir: string, fsLike: FsLike): string[] {
+  try {
+    return fsLike.readdirSync(dir).filter((f) => f.endsWith(".json"))
+  } catch {
+    return []
+  }
+}
+
+function readRecentMessageMetas(
+  messageDir: string,
+  maxMessages: number,
+  fsLike: FsLike
+): { metas: StoredMessageMeta[]; totalMessages: number } {
+  if (!messageDir || !fsLike.existsSync(messageDir)) return { metas: [], totalMessages: 0 }
+  const files = listJsonFiles(messageDir, fsLike)
+  const ranked = files
+    .map((f) => ({
+      f,
+      mtime: (() => {
+        try {
+          return fsLike.statSync(path.join(messageDir, f)).mtimeMs
+        } catch {
+          return 0
+        }
+      })(),
+    }))
+    .sort((a, b) => b.mtime - a.mtime)
+    .slice(0, maxMessages)
+
+  const metas: StoredMessageMeta[] = []
+  for (const item of ranked) {
+    const meta = readJsonFile<StoredMessageMeta>(path.join(messageDir, item.f), fsLike)
+    if (meta && typeof meta.id === "string") metas.push(meta)
+  }
+  return { metas, totalMessages: files.length }
+}
+
+function readToolPartsForMessage(
+  partStorage: string,
+  messageId: string,
+  fsLike: FsLike,
+  allowedRoots?: string[]
+): StoredToolPartMeta[] {
+  const partDir = path.join(partStorage, messageId)
+  if (allowedRoots && allowedRoots.length > 0) {
+    assertAllowedPath({ candidatePath: partDir, allowedRoots })
+  }
+  if (!fsLike.existsSync(partDir)) return []
+
+  const files = listJsonFiles(partDir, fsLike).sort()
+  const parts: StoredToolPartMeta[] = []
+  for (const file of files) {
+    const part = readJsonFile<StoredToolPartMeta>(path.join(partDir, file), fsLike)
+    if (part && part.type === "tool" && typeof part.tool === "string" && typeof part.callID === "string") {
+      parts.push(part)
+    }
+  }
+  return parts
+}
+
+function readStatus(value: StoredToolPartMeta["state"]): ToolCallSummary["status"] {
+  const status = value?.status
+  if (status === "pending" || status === "running" || status === "completed" || status === "error") {
+    return status
+  }
+  return "unknown"
+}
+
+export function deriveToolCalls(opts: {
+  storage: OpenCodeStorageRoots
+  sessionId: string
+  fs?: FsLike
+  allowedRoots?: string[]
+}): ToolCallSummaryResult {
+  const fsLike: FsLike = opts.fs ?? fs
+  const messageDir = getMessageDir(opts.storage.message, opts.sessionId)
+  if (messageDir && opts.allowedRoots && opts.allowedRoots.length > 0) {
+    assertAllowedPath({ candidatePath: messageDir, allowedRoots: opts.allowedRoots })
+  }
+  const { metas, totalMessages } = readRecentMessageMetas(messageDir, MAX_TOOL_CALL_MESSAGES, fsLike)
+  const truncatedByMessages = totalMessages > MAX_TOOL_CALL_MESSAGES
+
+  const calls: Array<ToolCallSummary & { createdSortKey: number }> = []
+  for (const meta of metas) {
+    const createdAtMs = typeof meta.time?.created === "number" ? meta.time.created : null
+    const createdSortKey = createdAtMs ?? -Infinity
+    const parts = readToolPartsForMessage(opts.storage.part, meta.id, fsLike, opts.allowedRoots)
+    for (const part of parts) {
+      calls.push({
+        sessionId: opts.sessionId,
+        messageId: meta.id,
+        callId: part.callID ?? "",
+        tool: part.tool ?? "",
+        status: readStatus(part.state),
+        createdAtMs,
+        createdSortKey,
+      })
+    }
+  }
+
+  const truncatedByCalls = calls.length > MAX_TOOL_CALLS
+  const toolCalls = calls
+    .sort((a, b) => {
+      if (a.createdSortKey !== b.createdSortKey) return b.createdSortKey - a.createdSortKey
+      const messageCompare = String(a.messageId).localeCompare(String(b.messageId))
+      if (messageCompare !== 0) return messageCompare
+      return String(a.callId).localeCompare(String(b.callId))
+    })
+    .slice(0, MAX_TOOL_CALLS)
+    .map(({ createdSortKey, ...row }) => row)
+
+  return {
+    toolCalls,
+    truncated: truncatedByMessages || truncatedByCalls,
+  }
+}

package/src/server/api.test.ts

@@ -1,24 +1,100 @@
+import * as fs from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
 import { describe, it, expect } from "vitest"
 import { createApi } from "./api"
+import type { DashboardPayload, DashboardStore } from "./dashboard"
+import type { PlanStep } from "../ingest/boulder"
+import type { TimeSeriesPayload } from "../ingest/timeseries"
+
+function mkStorageRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "omo-dashboard-storage-"))
+  fs.mkdirSync(path.join(root, "session"), { recursive: true })
+  fs.mkdirSync(path.join(root, "message"), { recursive: true })
+  fs.mkdirSync(path.join(root, "part"), { recursive: true })
+  return root
+}
+
+function writeMessageMeta(opts: {
+  storageRoot: string
+  sessionId: string
+  messageId: string
+  created?: number
+}): void {
+  const msgDir = path.join(opts.storageRoot, "message", opts.sessionId)
+  fs.mkdirSync(msgDir, { recursive: true })
+  const meta: Record<string, unknown> = {
+    id: opts.messageId,
+    sessionID: opts.sessionId,
+    role: "assistant",
+  }
+  if (typeof opts.created === "number") {
+    meta.time = { created: opts.created }
+  }
+  fs.writeFileSync(path.join(msgDir, `${opts.messageId}.json`), JSON.stringify(meta), "utf8")
+}
+
+function writeToolPart(opts: {
+  storageRoot: string
+  sessionId: string
+  messageId: string
+  callId: string
+  tool: string
+  state?: Record<string, unknown>
+}): void {
+  const partDir = path.join(opts.storageRoot, "part", opts.messageId)
+  fs.mkdirSync(partDir, { recursive: true })
+  fs.writeFileSync(
+    path.join(partDir, `${opts.callId}.json`),
+    JSON.stringify({
+      id: `part_${opts.callId}`,
+      sessionID: opts.sessionId,
+      messageID: opts.messageId,
+      type: "tool",
+      callID: opts.callId,
+      tool: opts.tool,
+      state: opts.state ?? { status: "completed", input: {} },
+    }),
+    "utf8"
+  )
+}
+
+const sensitiveKeys = ["prompt", "input", "output", "error", "state"]
+
+function hasSensitiveKeys(value: unknown): boolean {
+  if (!value || typeof value !== "object") return false
+  if (Array.isArray(value)) {
+    return value.some((item) => hasSensitiveKeys(item))
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (sensitiveKeys.includes(key)) return true
+    if (hasSensitiveKeys(child)) return true
+  }
+  return false
+}
+
+const createStore = (): DashboardStore => ({
+  getSnapshot: (): DashboardPayload => ({
+    mainSession: { agent: "x", currentModel: null, currentTool: "-", lastUpdatedLabel: "never", session: "s", statusPill: "idle" },
+    planProgress: { name: "p", completed: 0, total: 0, path: "", statusPill: "not started", steps: [] as PlanStep[] },
+    backgroundTasks: [],
+    timeSeries: {
+      windowMs: 0,
+      bucketMs: 0,
+      buckets: 0,
+      anchorMs: 0,
+      serverNowMs: 0,
+      series: [{ id: "overall-main", label: "Overall", tone: "muted" as const, values: [] as number[] }],
+    },
+    raw: null,
+  }),
+} satisfies DashboardStore)
 
 describe('API Routes', () => {
   it('should return health check', async () => {
-    const api = createApi({
-      getSnapshot: () => ({
-        mainSession: { agent: "x", currentTool: "-", lastUpdatedLabel: "never", session: "s", statusPill: "idle" },
-        planProgress: { name: "p", completed: 0, total: 0, path: "", statusPill: "not started", steps: [] },
-        backgroundTasks: [],
-        timeSeries: {
-          windowMs: 0,
-          bucketMs: 0,
-          buckets: 0,
-          anchorMs: 0,
-          serverNowMs: 0,
-          series: [{ id: "overall-main", label: "Overall", tone: "muted", values: [] }],
-        },
-        raw: null,
-      }),
-    })
+    const storageRoot = mkStorageRoot()
+    const store = createStore()
+    const api = createApi({ store, storageRoot })
 
     const res = await api.request("/health")
     expect(res.status).toBe(200)
@@ -26,22 +102,9 @@ describe('API Routes', () => {
   })
 
   it('should return dashboard data without sensitive keys', async () => {
-    const api = createApi({
-      getSnapshot: () => ({
-        mainSession: { agent: "x", currentTool: "-", lastUpdatedLabel: "never", session: "s", statusPill: "idle" },
-        planProgress: { name: "p", completed: 0, total: 0, path: "", statusPill: "not started", steps: [] },
-        backgroundTasks: [{ id: "1", description: "d", agent: "a", status: "queued", toolCalls: 0, lastTool: "-", timeline: "" }],
-        timeSeries: {
-          windowMs: 0,
-          bucketMs: 0,
-          buckets: 0,
-          anchorMs: 0,
-          serverNowMs: 0,
-          series: [{ id: "overall-main", label: "Overall", tone: "muted", values: [] }],
-        },
-        raw: { ok: true },
-      }),
-    })
+    const storageRoot = mkStorageRoot()
+    const store = createStore()
+    const api = createApi({ store, storageRoot })
 
     const res = await api.request("/dashboard")
     expect(res.status).toBe(200)
@@ -54,26 +117,72 @@ describe('API Routes', () => {
     expect(data).toHaveProperty("timeSeries")
     expect(data).toHaveProperty("raw")
     
-    const sensitiveKeys = ["prompt", "input", "output", "error", "state"]
-    
-    const checkForSensitiveKeys = (obj: any): boolean => {
-      if (typeof obj !== 'object' || obj === null) {
-        return false;
-      }
-      
-      for (const key of Object.keys(obj)) {
-        if (sensitiveKeys.includes(key)) {
-          return true;
-        }
-        if (typeof obj[key] === 'object' && obj[key] !== null) {
-          if (checkForSensitiveKeys(obj[key])) {
-            return true;
-          }
-        }
-      }
-      return false;
-    };
-    
-    expect(checkForSensitiveKeys(data)).toBe(false)
+    expect(hasSensitiveKeys(data)).toBe(false)
+  })
+
+  it('should reject invalid session IDs', async () => {
+    const storageRoot = mkStorageRoot()
+    const store = createStore()
+    const api = createApi({ store, storageRoot })
+
+    const res = await api.request("/tool-calls/not_valid!")
+    expect(res.status).toBe(400)
+    expect(await res.json()).toEqual({ ok: false, sessionId: "not_valid!", toolCalls: [] })
+  })
+
+  it('should return 404 for missing sessions', async () => {
+    const storageRoot = mkStorageRoot()
+    const store = createStore()
+    const api = createApi({ store, storageRoot })
+
+    const res = await api.request("/tool-calls/ses_missing")
+    expect(res.status).toBe(404)
+    expect(await res.json()).toEqual({ ok: false, sessionId: "ses_missing", toolCalls: [] })
+  })
+
+  it('should return empty tool calls for existing sessions', async () => {
+    const storageRoot = mkStorageRoot()
+    writeMessageMeta({ storageRoot, sessionId: "ses_empty", messageId: "msg_1", created: 1000 })
+    const store = createStore()
+    const api = createApi({ store, storageRoot })
+
+    const res = await api.request("/tool-calls/ses_empty")
+    expect(res.status).toBe(200)
+
+    const data = await res.json()
+    expect(data.ok).toBe(true)
+    expect(data.sessionId).toBe("ses_empty")
+    expect(data.toolCalls).toEqual([])
+    expect(data.caps).toEqual({ maxMessages: 200, maxToolCalls: 300 })
+    expect(data.truncated).toBe(false)
+    expect(hasSensitiveKeys(data)).toBe(false)
+  })
+
+  it('should redact tool call payload fields', async () => {
+    const storageRoot = mkStorageRoot()
+    writeMessageMeta({ storageRoot, sessionId: "ses_redact", messageId: "msg_1", created: 1000 })
+    writeToolPart({
+      storageRoot,
+      sessionId: "ses_redact",
+      messageId: "msg_1",
+      callId: "call_1",
+      tool: "bash",
+      state: {
+        status: "completed",
+        input: { prompt: "SECRET", nested: { output: "HIDDEN" } },
+        output: "NOPE",
+        error: "NOPE",
+      },
+    })
+    const store = createStore()
+    const api = createApi({ store, storageRoot })
+
+    const res = await api.request("/tool-calls/ses_redact")
+    expect(res.status).toBe(200)
+
+    const data = await res.json()
+    expect(data.ok).toBe(true)
+    expect(data.toolCalls.length).toBe(1)
+    expect(hasSensitiveKeys(data)).toBe(false)
   })
 })

package/src/server/api.ts

@@ -1,7 +1,12 @@
 import { Hono } from "hono"
 import type { DashboardStore } from "./dashboard"
+import { assertAllowedPath } from "../ingest/paths"
+import { getMessageDir, getStorageRoots } from "../ingest/session"
+import { deriveToolCalls, MAX_TOOL_CALL_MESSAGES, MAX_TOOL_CALLS } from "../ingest/tool-calls"
 
-export function createApi(store: DashboardStore): Hono {
+const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/
+
+export function createApi(opts: { store: DashboardStore; storageRoot: string }): Hono {
   const api = new Hono()
 
   api.get("/health", (c) => {
@@ -9,7 +14,39 @@ export function createApi(store: DashboardStore): Hono {
   })
 
   api.get("/dashboard", (c) => {
-    return c.json(store.getSnapshot())
+    return c.json(opts.store.getSnapshot())
+  })
+
+  api.get("/tool-calls/:sessionId", (c) => {
+    const sessionId = c.req.param("sessionId")
+    if (!SESSION_ID_PATTERN.test(sessionId)) {
+      return c.json({ ok: false, sessionId, toolCalls: [] }, 400)
+    }
+
+    const storage = getStorageRoots(opts.storageRoot)
+    const messageDir = getMessageDir(storage.message, sessionId)
+    if (!messageDir) {
+      return c.json({ ok: false, sessionId, toolCalls: [] }, 404)
+    }
+
+    assertAllowedPath({ candidatePath: messageDir, allowedRoots: [opts.storageRoot] })
+
+    const { toolCalls, truncated } = deriveToolCalls({
+      storage,
+      sessionId,
+      allowedRoots: [opts.storageRoot],
+    })
+
+    return c.json({
+      ok: true,
+      sessionId,
+      toolCalls,
+      caps: {
+        maxMessages: MAX_TOOL_CALL_MESSAGES,
+        maxToolCalls: MAX_TOOL_CALLS,
+      },
+      truncated,
+    })
   })
 
   return api

package/src/server/dashboard.ts

@@ -31,6 +31,7 @@ export type DashboardPayload = {
     toolCalls: number
     lastTool: string
     timeline: string
+    sessionId: string | null
   }>
   timeSeries: TimeSeriesPayload
   raw: unknown
@@ -161,6 +162,7 @@ export function buildDashboardPayload(opts: {
       toolCalls: t.toolCalls ?? 0,
       lastTool: t.lastTool ?? "-",
       timeline: typeof t.timeline === "string" ? t.timeline : "",
+      sessionId: t.sessionId ?? null,
     })),
     timeSeries,
     raw: null,

package/src/server/dev.ts

@@ -26,14 +26,16 @@ const resolvedProjectPath = projectPath ?? process.cwd()
 
 const app = new Hono()
 
+const storageRoot = getOpenCodeStorageDir()
+
 const store = createDashboardStore({
   projectRoot: resolvedProjectPath,
-  storageRoot: getOpenCodeStorageDir(),
+  storageRoot,
   watch: true,
   pollIntervalMs: 2000,
 })
 
-app.route("/api", createApi(store))
+app.route("/api", createApi({ store, storageRoot }))
 
 Bun.serve({
   fetch: app.fetch,

package/src/server/start.ts

@@ -21,14 +21,16 @@ const port = parseInt(values.port || '51234')
 
 const app = new Hono()
 
+const storageRoot = getOpenCodeStorageDir()
+
 const store = createDashboardStore({
   projectRoot: project,
-  storageRoot: getOpenCodeStorageDir(),
+  storageRoot,
   watch: true,
   pollIntervalMs: 2000,
 })
 
-app.route('/api', createApi(store))
+app.route('/api', createApi({ store, storageRoot }))
 
 const distRoot = join(import.meta.dir, '../../dist')