oh-my-opencode-dashboard 0.1.4 → 0.1.5

package/src/ingest/token-usage.test.ts

@@ -0,0 +1,154 @@
+import * as fs from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
+import { describe, expect, it } from "vitest"
+import { deriveTokenUsage } from "./token-usage"
+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: {
+  messageDir: string
+  messageId: string
+  meta: Record<string, unknown>
+}): void {
+  fs.mkdirSync(opts.messageDir, { recursive: true })
+  fs.writeFileSync(
+    path.join(opts.messageDir, `${opts.messageId}.json`),
+    JSON.stringify({ id: opts.messageId, sessionID: "", role: "assistant", ...opts.meta }),
+    "utf8"
+  )
+}
+
+describe("deriveTokenUsage token usage", () => {
+  it("aggregates token usage across main + background sessions", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const mainSessionId = "ses_main"
+    const backgroundSessionId = "ses_bg"
+
+    writeMessageMeta({
+      messageDir: path.join(storage.message, mainSessionId),
+      messageId: "msg_main",
+      meta: {
+        sessionID: mainSessionId,
+        role: "assistant",
+        providerID: "openai",
+        modelID: "gpt-5.2",
+        tokens: { input: 2, output: 1, reasoning: 1, cache: { read: 0, write: 0 } },
+      },
+    })
+
+    writeMessageMeta({
+      messageDir: path.join(storage.message, backgroundSessionId),
+      messageId: "msg_bg",
+      meta: {
+        sessionID: backgroundSessionId,
+        role: "assistant",
+        providerID: "openai",
+        modelID: "gpt-5.2",
+        tokens: { input: 3, output: 0, reasoning: 0, cache: { read: 1, write: 0 } },
+      },
+    })
+
+    // #when
+    const result = deriveTokenUsage({
+      storage,
+      mainSessionId,
+      backgroundSessionIds: [backgroundSessionId],
+    })
+
+    // #then
+    expect(result.rows.length).toBe(1)
+    expect(result.rows[0]).toEqual({
+      model: "openai/gpt-5.2",
+      input: 5,
+      output: 1,
+      reasoning: 1,
+      cacheRead: 1,
+      cacheWrite: 0,
+      total: 8,
+    })
+    expect(result.totals).toEqual({
+      input: 5,
+      output: 1,
+      reasoning: 1,
+      cacheRead: 1,
+      cacheWrite: 0,
+      total: 8,
+    })
+  })
+
+  it("returns empty payload when message directories are missing", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+
+    // #when
+    const result = deriveTokenUsage({
+      storage,
+      mainSessionId: "ses_missing",
+      backgroundSessionIds: ["ses_other"],
+    })
+
+    // #then
+    expect(result.rows).toEqual([])
+    expect(result.totals).toEqual({
+      input: 0,
+      output: 0,
+      reasoning: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      total: 0,
+    })
+  })
+
+  it("dedupes message ids across sessions and ignores empty ids", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const mainSessionId = "ses_main"
+    const backgroundSessionId = "ses_bg"
+
+    writeMessageMeta({
+      messageDir: path.join(storage.message, mainSessionId),
+      messageId: "msg_dupe",
+      meta: {
+        sessionID: mainSessionId,
+        role: "assistant",
+        providerID: "openai",
+        modelID: "gpt-5.2",
+        tokens: { input: 4, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+      },
+    })
+
+    writeMessageMeta({
+      messageDir: path.join(storage.message, backgroundSessionId),
+      messageId: "msg_dupe",
+      meta: {
+        sessionID: backgroundSessionId,
+        role: "assistant",
+        providerID: "openai",
+        modelID: "gpt-5.2",
+        tokens: { input: 9, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+      },
+    })
+
+    // #when
+    const result = deriveTokenUsage({
+      storage,
+      mainSessionId,
+      backgroundSessionIds: [backgroundSessionId, "", "  ", null],
+    })
+
+    // #then
+    expect(result.totals.input).toBe(4)
+  })
+})

package/src/ingest/token-usage.ts

@@ -0,0 +1,66 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import type { OpenCodeStorageRoots } from "./session"
+import { getMessageDir } from "./session"
+import { aggregateTokenUsage } from "./token-usage-core"
+
+function listJsonFiles(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir).filter((f) => f.endsWith(".json"))
+  } catch {
+    return []
+  }
+}
+
+function readJsonFile(filePath: string): unknown | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf8")
+    return JSON.parse(content) as unknown
+  } catch {
+    return null
+  }
+}
+
+function normalizeSessionId(value: unknown): string | null {
+  if (typeof value !== "string") return null
+  const trimmed = value.trim()
+  return trimmed ? trimmed : null
+}
+
+function readSessionMetas(messageDir: string): unknown[] {
+  if (!messageDir) return []
+  const files = listJsonFiles(messageDir)
+  const metas: unknown[] = []
+  for (const file of files) {
+    const meta = readJsonFile(path.join(messageDir, file))
+    if (meta) metas.push(meta)
+  }
+  return metas
+}
+
+export function deriveTokenUsage(opts: {
+  storage: OpenCodeStorageRoots
+  mainSessionId: string | null
+  backgroundSessionIds?: Array<string | null | undefined>
+}): ReturnType<typeof aggregateTokenUsage> {
+  const sessionIds: string[] = []
+  const seen = new Set<string>()
+  const push = (value: unknown): void => {
+    const id = normalizeSessionId(value)
+    if (!id || seen.has(id)) return
+    seen.add(id)
+    sessionIds.push(id)
+  }
+
+  push(opts.mainSessionId)
+  for (const id of opts.backgroundSessionIds ?? []) push(id)
+
+  const metas: unknown[] = []
+  for (const sessionId of sessionIds) {
+    const messageDir = getMessageDir(opts.storage.message, sessionId)
+    if (!messageDir) continue
+    metas.push(...readSessionMetas(messageDir))
+  }
+
+  return aggregateTokenUsage(metas)
+}

package/src/server/dashboard.test.ts

@@ -355,4 +355,105 @@ describe("buildDashboardPayload", () => {
       fs.rmSync(projectRoot, { recursive: true, force: true })
     }
   })
+
+  it("includes tokenUsage totals and rows for main session", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+    const sessionId = "ses_token_usage"
+    const messageId = "msg_token_1"
+    const projectID = "proj_1"
+    const providerID = "openai"
+    const modelID = "gpt-4o"
+    const expectedMessageTokens = {
+      input: 12,
+      output: 34,
+      reasoning: 5,
+      cache: {
+        read: 2,
+        write: 3,
+      },
+    }
+    const expectedTotals = {
+      input: 12,
+      output: 34,
+      reasoning: 5,
+      cacheRead: 2,
+      cacheWrite: 3,
+      total: 56,
+    }
+
+    try {
+      const sessionMetaDir = path.join(storage.session, projectID)
+      fs.mkdirSync(sessionMetaDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(sessionMetaDir, `${sessionId}.json`),
+        JSON.stringify({
+          id: sessionId,
+          projectID,
+          directory: projectRoot,
+          time: { created: 1000, updated: 1000 },
+        }),
+        "utf8"
+      )
+
+      const messageDir = path.join(storage.message, sessionId)
+      fs.mkdirSync(messageDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(messageDir, `${messageId}.json`),
+        JSON.stringify({
+          id: messageId,
+          sessionID: sessionId,
+          role: "assistant",
+          providerID,
+          modelID,
+          tokens: expectedMessageTokens,
+          time: { created: 1200 },
+        }),
+        "utf8"
+      )
+
+      type TokenUsageTotals = typeof expectedTotals
+      type TokenUsageRow = {
+        model: string
+        input: number
+        output: number
+        reasoning: number
+        cacheRead: number
+        cacheWrite: number
+        total: number
+      }
+      type DashboardPayloadWithTokenUsage = ReturnType<typeof buildDashboardPayload> & {
+        tokenUsage: {
+          totals: TokenUsageTotals
+          rows: TokenUsageRow[]
+        }
+      }
+
+      const payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 2000,
+      }) as DashboardPayloadWithTokenUsage
+
+      expect(payload).toHaveProperty("tokenUsage")
+      expect(payload.tokenUsage.totals).toEqual(expectedTotals)
+      expect(payload.tokenUsage.rows).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            model: `${providerID}/${modelID}`,
+            input: expectedTotals.input,
+            output: expectedTotals.output,
+            reasoning: expectedTotals.reasoning,
+            cacheRead: expectedTotals.cacheRead,
+            cacheWrite: expectedTotals.cacheWrite,
+            total: expectedTotals.total,
+          }),
+        ])
+      )
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
 })

package/src/server/dashboard.ts

@@ -5,6 +5,7 @@ import { deriveBackgroundTasks } from "../ingest/background-tasks"
 import { deriveTimeSeriesActivity, type TimeSeriesPayload } from "../ingest/timeseries"
 import { getMainSessionView, getStorageRoots, pickActiveSessionId, readMainSessionMetas, type MainSessionView, type OpenCodeStorageRoots, type SessionMetadata } from "../ingest/session"
 import { deriveToolCalls } from "../ingest/tool-calls"
+import { deriveTokenUsage } from "../ingest/token-usage"
 
 export type DashboardPayload = {
   mainSession: {
@@ -48,6 +49,7 @@ export type DashboardPayload = {
     sessionId: string | null
   }>
   timeSeries: TimeSeriesPayload
+  tokenUsage?: ReturnType<typeof deriveTokenUsage>
   raw: unknown
 }
 
@@ -212,6 +214,12 @@ export function buildDashboardPayload(opts: {
     ]
   })()
 
+  const tokenUsage = deriveTokenUsage({
+    storage: opts.storage,
+    mainSessionId: sessionId ?? null,
+    backgroundSessionIds: tasks.map((task) => task.sessionId ?? null),
+  })
+
   const payload: DashboardPayload = {
     mainSession: {
       agent: main.agent,
@@ -243,6 +251,7 @@ export function buildDashboardPayload(opts: {
     })),
     mainSessionTasks,
     timeSeries,
+    tokenUsage,
     raw: null,
   }