oh-my-opencode-dashboard 0.0.3 → 0.0.5

package/src/ingest/background-tasks.ts

@@ -2,6 +2,9 @@ import * as fs from "node:fs"
 import * as path from "node:path"
 import type { OpenCodeStorageRoots, SessionMetadata, StoredMessageMeta, StoredToolPart } from "./session"
 import { getMessageDir } from "./session"
+import { pickLatestModelString } from "./model"
+
+type FsLike = Pick<typeof fs, "readFileSync" | "readdirSync" | "existsSync" | "statSync"> 
 
 export type BackgroundTaskRow = {
   id: string
@@ -10,6 +13,7 @@ export type BackgroundTaskRow = {
   status: "queued" | "running" | "completed" | "error" | "unknown"
   toolCalls: number | null
   lastTool: string | null
+  lastModel: string | null
   timeline: string
   sessionId: string | null
 }
@@ -24,31 +28,31 @@ function clampString(value: unknown, maxLen: number): string | null {
   return s.length <= maxLen ? s : s.slice(0, maxLen)
 }
 
-function readJsonFile<T>(filePath: string): T | null {
+function readJsonFile<T>(filePath: string, fsLike: FsLike): T | null {
   try {
-    const content = fs.readFileSync(filePath, "utf8")
+    const content = fsLike.readFileSync(filePath, "utf8")
     return JSON.parse(content) as T
   } catch {
     return null
   }
 }
 
-function listJsonFiles(dir: string): string[] {
+function listJsonFiles(dir: string, fsLike: FsLike): string[] {
   try {
-    return fs.readdirSync(dir).filter((f) => f.endsWith(".json"))
+    return fsLike.readdirSync(dir).filter((f) => f.endsWith(".json"))
   } catch {
     return []
   }
 }
 
-function readToolPartsForMessage(storage: OpenCodeStorageRoots, messageID: string): StoredToolPart[] {
+function readToolPartsForMessage(storage: OpenCodeStorageRoots, messageID: string, fsLike: FsLike): StoredToolPart[] {
   const partDir = path.join(storage.part, messageID)
-  if (!fs.existsSync(partDir)) return []
+  if (!fsLike.existsSync(partDir)) return []
 
-  const files = listJsonFiles(partDir).sort()
+  const files = listJsonFiles(partDir, fsLike).sort()
   const parts: StoredToolPart[] = []
   for (const f of files) {
-    const p = readJsonFile<StoredToolPart>(path.join(partDir, f))
+    const p = readJsonFile<StoredToolPart>(path.join(partDir, f), fsLike)
     if (p && p.type === "tool" && typeof p.tool === "string" && p.state && typeof p.state === "object") {
       parts.push(p)
     }
@@ -56,14 +60,14 @@ function readToolPartsForMessage(storage: OpenCodeStorageRoots, messageID: strin
   return parts
 }
 
-function readRecentMessageMetas(messageDir: string, maxMessages: number): StoredMessageMeta[] {
-  if (!messageDir || !fs.existsSync(messageDir)) return []
-  const files = listJsonFiles(messageDir)
+function readRecentMessageMetas(messageDir: string, maxMessages: number, fsLike: FsLike): StoredMessageMeta[] {
+  if (!messageDir || !fsLike.existsSync(messageDir)) return []
+  const files = listJsonFiles(messageDir, fsLike)
     .map((f) => ({
       f,
       mtime: (() => {
         try {
-          return fs.statSync(path.join(messageDir, f)).mtimeMs
+          return fsLike.statSync(path.join(messageDir, f)).mtimeMs
         } catch {
           return 0
         }
@@ -74,22 +78,22 @@ function readRecentMessageMetas(messageDir: string, maxMessages: number): Stored
 
   const metas: StoredMessageMeta[] = []
   for (const item of files) {
-    const meta = readJsonFile<StoredMessageMeta>(path.join(messageDir, item.f))
+    const meta = readJsonFile<StoredMessageMeta>(path.join(messageDir, item.f), fsLike)
     if (meta && typeof meta.id === "string") metas.push(meta)
   }
   return metas
 }
 
-export function readAllSessionMetas(sessionStorage: string): SessionMetadata[] {
-  if (!fs.existsSync(sessionStorage)) return []
+export function readAllSessionMetas(sessionStorage: string, fsLike: FsLike = fs): SessionMetadata[] {
+  if (!fsLike.existsSync(sessionStorage)) return []
   const metas: SessionMetadata[] = []
   try {
-    const projectDirs = fs.readdirSync(sessionStorage, { withFileTypes: true })
+    const projectDirs = fsLike.readdirSync(sessionStorage, { withFileTypes: true })
     for (const d of projectDirs) {
       if (!d.isDirectory()) continue
       const projectPath = path.join(sessionStorage, d.name)
-      for (const file of listJsonFiles(projectPath)) {
-        const meta = readJsonFile<SessionMetadata>(path.join(projectPath, file))
+      for (const file of listJsonFiles(projectPath, fsLike)) {
+        const meta = readJsonFile<SessionMetadata>(path.join(projectPath, file), fsLike)
         if (meta && typeof meta.id === "string") metas.push(meta)
       }
     }
@@ -152,9 +156,11 @@ function findTaskSessionId(opts: {
   return candidates[0]?.id ?? null
 }
 
-function deriveBackgroundSessionStats(storage: OpenCodeStorageRoots, sessionId: string): { toolCalls: number; lastTool: string | null; lastUpdateAt: number | null } {
-  const messageDir = getMessageDir(storage.message, sessionId)
-  const metas = readRecentMessageMetas(messageDir, 200)
+function deriveBackgroundSessionStats(
+  storage: OpenCodeStorageRoots,
+  metas: StoredMessageMeta[],
+  fsLike: FsLike
+): { toolCalls: number; lastTool: string | null; lastUpdateAt: number | null } {
   let toolCalls = 0
   let lastTool: string | null = null
   let lastUpdateAt: number | null = null
@@ -170,7 +176,7 @@ function deriveBackgroundSessionStats(storage: OpenCodeStorageRoots, sessionId:
   for (const meta of ordered) {
     const created = meta.time?.created
     if (typeof created === "number") lastUpdateAt = created
-    const parts = readToolPartsForMessage(storage, meta.id)
+    const parts = readToolPartsForMessage(storage, meta.id, fsLike)
     for (const p of parts) {
       toolCalls += 1
       lastTool = p.tool
@@ -211,11 +217,42 @@ export function deriveBackgroundTasks(opts: {
   storage: OpenCodeStorageRoots
   mainSessionId: string
   nowMs?: number
+  fs?: FsLike
 }): BackgroundTaskRow[] {
+  const fsLike: FsLike = opts.fs ?? fs
   const nowMs = opts.nowMs ?? Date.now()
   const messageDir = getMessageDir(opts.storage.message, opts.mainSessionId)
-  const metas = readRecentMessageMetas(messageDir, 200)
-  const allSessionMetas = readAllSessionMetas(opts.storage.session)
+  const metas = readRecentMessageMetas(messageDir, 200, fsLike)
+  const allSessionMetas = readAllSessionMetas(opts.storage.session, fsLike)
+  const backgroundMessageCache = new Map<string, StoredMessageMeta[]>()
+  const backgroundStatsCache = new Map<string, { toolCalls: number; lastTool: string | null; lastUpdateAt: number | null }>()
+  const backgroundModelCache = new Map<string, string | null>()
+
+  const readBackgroundMetas = (sessionId: string): StoredMessageMeta[] => {
+    const cached = backgroundMessageCache.get(sessionId)
+    if (cached) return cached
+    const backgroundMessageDir = getMessageDir(opts.storage.message, sessionId)
+    const recent = readRecentMessageMetas(backgroundMessageDir, 200, fsLike)
+    backgroundMessageCache.set(sessionId, recent)
+    return recent
+  }
+
+  const readBackgroundStats = (sessionId: string) => {
+    const cached = backgroundStatsCache.get(sessionId)
+    if (cached) return cached
+    const recent = readBackgroundMetas(sessionId)
+    const stats = deriveBackgroundSessionStats(opts.storage, recent, fsLike)
+    backgroundStatsCache.set(sessionId, stats)
+    return stats
+  }
+
+  const readBackgroundModel = (sessionId: string): string | null => {
+    if (backgroundModelCache.has(sessionId)) return backgroundModelCache.get(sessionId) ?? null
+    const recent = readBackgroundMetas(sessionId)
+    const model = pickLatestModelString(recent as unknown[])
+    backgroundModelCache.set(sessionId, model)
+    return model
+  }
 
   const rows: BackgroundTaskRow[] = []
 
@@ -225,7 +262,7 @@ export function deriveBackgroundTasks(opts: {
     const startedAt = meta.time?.created ?? null
     if (typeof startedAt !== "number") continue
 
-    const parts = readToolPartsForMessage(opts.storage, meta.id)
+    const parts = readToolPartsForMessage(opts.storage, meta.id, fsLike)
     for (const part of parts) {
       if (part.tool !== "delegate_task") continue
       if (!part.state || typeof part.state !== "object") continue
@@ -258,7 +295,7 @@ export function deriveBackgroundTasks(opts: {
         if (typeof resume === "string" && resume.trim() !== "") {
           // Check if resumed session exists (has readable messages dir)
           const resumeMessageDir = getMessageDir(opts.storage.message, resume.trim())
-          if (fs.existsSync(resumeMessageDir) && fs.readdirSync(resumeMessageDir).length > 0) {
+          if (fsLike.existsSync(resumeMessageDir) && fsLike.readdirSync(resumeMessageDir).length > 0) {
             backgroundSessionId = resume.trim()
           }
         }
@@ -283,8 +320,9 @@ export function deriveBackgroundTasks(opts: {
       }
 
       const stats = backgroundSessionId
-        ? deriveBackgroundSessionStats(opts.storage, backgroundSessionId)
+        ? readBackgroundStats(backgroundSessionId)
         : { toolCalls: 0, lastTool: null, lastUpdateAt: startedAt }
+      const lastModel = backgroundSessionId ? readBackgroundModel(backgroundSessionId) : null
 
       // Best-effort status: if background session exists and has any tool calls, treat as running unless idle.
       let status: BackgroundTaskRow["status"] = "unknown"
@@ -305,7 +343,8 @@ export function deriveBackgroundTasks(opts: {
         status,
         toolCalls: backgroundSessionId ? stats.toolCalls : null,
         lastTool: stats.lastTool,
-        timeline: formatTimeline(startedAt, timelineEndMs),
+        lastModel,
+        timeline: status === "unknown" ? "" : formatTimeline(startedAt, timelineEndMs),
         sessionId: backgroundSessionId,
       })
     }

package/src/ingest/model.ts

@@ -0,0 +1,79 @@
+type ModelParts = {
+  providerID?: string
+  modelID?: string
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null
+}
+
+function readString(value: unknown): string | null {
+  if (typeof value !== "string") return null
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+
+function readModelParts(value: Record<string, unknown>): ModelParts {
+  const providerID =
+    readString(value.providerID) ??
+    readString(value.providerId) ??
+    readString(value.provider_id)
+  const modelID =
+    readString(value.modelID) ??
+    readString(value.modelId) ??
+    readString(value.model_id)
+
+  return { providerID: providerID ?? undefined, modelID: modelID ?? undefined }
+}
+
+export function extractModelString(meta: unknown): string | null {
+  if (!isRecord(meta)) return null
+
+  const direct = readModelParts(meta)
+  if (direct.providerID && direct.modelID) return `${direct.providerID}/${direct.modelID}`
+
+  const nested = meta.model
+  if (isRecord(nested)) {
+    const nestedParts = readModelParts(nested)
+    if (nestedParts.providerID && nestedParts.modelID) {
+      return `${nestedParts.providerID}/${nestedParts.modelID}`
+    }
+  }
+
+  return null
+}
+
+type ModelCandidate = {
+  created: number
+  id: string
+  role: string | null
+  model: string
+}
+
+export function pickLatestModelString(metas: Array<unknown>): string | null {
+  const candidates: ModelCandidate[] = []
+
+  for (const meta of metas) {
+    if (!isRecord(meta)) continue
+    const model = extractModelString(meta)
+    if (!model) continue
+
+    const created = typeof meta.time === "object" && meta.time !== null && typeof (meta.time as { created?: unknown }).created === "number"
+      ? (meta.time as { created: number }).created
+      : 0
+    const id = readString(meta.id) ?? ""
+    const role = readString(meta.role)
+
+    candidates.push({ created, id, role, model })
+  }
+
+  if (candidates.length === 0) return null
+
+  candidates.sort((a, b) => {
+    if (b.created !== a.created) return b.created - a.created
+    return b.id.localeCompare(a.id)
+  })
+
+  const assistant = candidates.find((candidate) => candidate.role === "assistant")
+  return assistant?.model ?? candidates[0]?.model ?? null
+}

package/src/ingest/session.test.ts

@@ -8,6 +8,7 @@ import {
   pickActiveSessionId,
   readMainSessionMetas,
 } from "./session"
+import { extractModelString, pickLatestModelString } from "./model"
 
 function mkStorageRoot(): string {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "omo-storage-"))
@@ -217,4 +218,122 @@ describe("getMainSessionView", () => {
 
     expect(view.status).toBe("thinking")
   })
+
+  it("returns null currentModel when no model metadata exists", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = "/tmp/project"
+    const sessionId = "ses_1"
+
+    const messageDir = path.join(storage.message, sessionId)
+    fs.mkdirSync(messageDir, { recursive: true })
+
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(messageDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: sessionId,
+        role: "assistant",
+        agent: "sisyphus",
+        time: { created: 1000 },
+      }),
+      "utf8"
+    )
+
+    // #given no model metadata in messages
+    // #when deriving main session view
+    const view = getMainSessionView({
+      projectRoot,
+      sessionId,
+      storage,
+      sessionMeta: null,
+      nowMs: 50_000,
+    })
+
+    // #then currentModel is null
+    expect(view.currentModel).toBeNull()
+  })
+})
+
+describe("extractModelString", () => {
+  it("supports assistant flat and user nested shapes", () => {
+    // #given assistant flat model
+    const assistantMeta = {
+      role: "assistant",
+      providerID: "openai",
+      modelID: "gpt-5.2",
+    }
+
+    // #when extracting model string
+    const assistantModel = extractModelString(assistantMeta)
+
+    // #then uses provider/model format
+    expect(assistantModel).toBe("openai/gpt-5.2")
+
+    // #given user nested model
+    const userMeta = {
+      role: "user",
+      model: { providerID: "anthropic", modelID: "claude-opus-4.5" },
+    }
+
+    // #when extracting model string
+    const userModel = extractModelString(userMeta)
+
+    // #then uses provider/model format
+    expect(userModel).toBe("anthropic/claude-opus-4.5")
+  })
+})
+
+describe("pickLatestModelString", () => {
+  it("prefers latest assistant model over newer user model", () => {
+    const metas = [
+      {
+        id: "msg_1",
+        role: "assistant",
+        time: { created: 1000 },
+        providerID: "openai",
+        modelID: "gpt-5.2",
+      },
+      {
+        id: "msg_2",
+        role: "user",
+        time: { created: 2000 },
+        model: { providerID: "anthropic", modelID: "claude-opus-4.5" },
+      },
+    ]
+
+    // #given assistant with model exists but user is newer
+    // #when picking latest model string
+    const picked = pickLatestModelString(metas)
+
+    // #then assistant model is preferred
+    expect(picked).toBe("openai/gpt-5.2")
+  })
+
+  it("uses deterministic ordering by created then id", () => {
+    const metas = [
+      {
+        id: "msg_a",
+        role: "assistant",
+        time: { created: 3000 },
+        providerID: "openai",
+        modelID: "gpt-5.2",
+      },
+      {
+        id: "msg_b",
+        role: "assistant",
+        time: { created: 3000 },
+        providerID: "openai",
+        modelID: "gpt-5.2-turbo",
+      },
+    ]
+
+    // #given same created time, higher id wins
+    // #when picking latest model string
+    const picked = pickLatestModelString(metas)
+
+    // #then picks model from msg_b
+    expect(picked).toBe("openai/gpt-5.2-turbo")
+  })
 })

package/src/ingest/session.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs"
 import * as path from "node:path"
+import { pickLatestModelString } from "./model"
 import { getOpenCodeStorageDir, realpathSafe } from "./paths"
 
 export type SessionMetadata = {
@@ -32,6 +33,7 @@ export type StoredToolPart = {
 export type MainSessionView = {
   agent: string
   currentTool: string | null
+  currentModel: string | null
   lastUpdated: number | null
   sessionLabel: string
   status: "busy" | "idle" | "unknown" | "running_tool" | "thinking"
@@ -253,6 +255,7 @@ export function getMainSessionView(opts: {
   // Scan recent messages for any in-flight tool parts
   let activeTool: { tool: string; status: string } | null = null
   const recentMetas = readRecentMessageMetas(messageDir, 200)
+  const currentModel = pickLatestModelString(recentMetas)
   
   // Iterate newest → oldest, early-exit on first tool part with pending/running status
   for (const meta of recentMetas) {
@@ -276,6 +279,7 @@ export function getMainSessionView(opts: {
   return {
     agent,
     currentTool: activeTool?.tool ?? null,
+    currentModel,
     lastUpdated,
     sessionLabel,
     status,

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)
+  })
+})