oh-my-opencode-dashboard 0.0.4 → 0.1.0

package/src/app-payload.test.ts

@@ -155,4 +155,111 @@ describe('toDashboardPayload', () => {
     // #then: should handle non-array steps gracefully
     expect(payload.planProgress.steps).toEqual([])
   })
-})
+
+  it('should parse mainSession.sessionId from camel or snake keys', () => {
+    // #given: server JSON with main session id in camel and snake case
+    const camelJson = {
+      mainSession: {
+        agent: "sisyphus",
+        currentTool: "dashboard_start",
+        currentModel: "anthropic/claude-opus-4-5",
+        lastUpdatedLabel: "just now",
+        session: "test-session",
+        sessionId: "ses_main",
+        statusPill: "busy",
+      },
+    }
+
+    const snakeJson = {
+      main_session: {
+        agent: "sisyphus",
+        current_tool: "dashboard_start",
+        current_model: "anthropic/claude-opus-4-5",
+        last_updated: "just now",
+        session: "test-session",
+        session_id: "ses_snake",
+        status: "busy",
+      },
+    }
+
+    // #when: converting to dashboard payload
+    const camelPayload = toDashboardPayload(camelJson)
+    const snakePayload = toDashboardPayload(snakeJson)
+
+    // #then: sessionId should be preserved
+    expect(camelPayload.mainSession.sessionId).toBe("ses_main")
+    expect(snakePayload.mainSession.sessionId).toBe("ses_snake")
+  })
+
+  it('should preserve mainSessionTasks from server JSON', () => {
+    // #given: server JSON with mainSessionTasks
+    const serverJson = {
+      mainSession: {
+        agent: "sisyphus",
+        currentTool: "dashboard_start",
+        currentModel: "anthropic/claude-opus-4-5",
+        lastUpdatedLabel: "just now",
+        session: "test-session",
+        sessionId: "ses_main",
+        statusPill: "busy",
+      },
+      planProgress: {
+        name: "test-plan",
+        completed: 0,
+        total: 0,
+        path: "/tmp/test-plan.md",
+        statusPill: "not started",
+        steps: [],
+      },
+      mainSessionTasks: [
+        {
+          id: "main-session",
+          description: "Main session",
+          subline: "ses_main",
+          agent: "sisyphus",
+          lastModel: "anthropic/claude-opus-4-5",
+          sessionId: "ses_main",
+          status: "running",
+          toolCalls: 3,
+          lastTool: "delegate_task",
+          timeline: "2026-01-01T00:00:00Z: 2m",
+        },
+      ],
+      backgroundTasks: [],
+      timeSeries: {
+        windowMs: 300000,
+        buckets: 150,
+        bucketMs: 2000,
+        anchorMs: 1640995200000,
+        serverNowMs: 1640995500000,
+        series: [
+          {
+            id: "overall-main",
+            label: "Overall",
+            tone: "muted",
+            values: new Array(150).fill(0),
+          },
+        ],
+      },
+    }
+
+    // #when
+    const payload = toDashboardPayload(serverJson)
+
+    // #then
+    expect(payload.mainSessionTasks).toEqual([
+      {
+        id: "main-session",
+        description: "Main session",
+        subline: "ses_main",
+        agent: "sisyphus",
+        lastModel: "anthropic/claude-opus-4-5",
+        sessionId: "ses_main",
+        status: "running",
+        toolCalls: 3,
+        lastTool: "delegate_task",
+        timeline: "2026-01-01T00:00:00Z: 2m",
+      },
+    ])
+  })
+})

package/src/background-task-toolcalls-policy.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect } from "vitest"
+import { computeToolCallsFetchPlan, toggleIdInSet } from "./App"
+
+describe('computeToolCallsFetchPlan', () => {
+  it('should not fetch when sessionId is missing', () => {
+    // #given: no sessionId
+    const params = {
+      sessionId: null,
+      status: "running",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(false)
+    expect(result.force).toBe(false)
+  })
+
+  it('should not fetch when not expanded', () => {
+    // #given: expanded is false
+    const params = {
+      sessionId: "session-123",
+      status: "done",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: false
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(false)
+    expect(result.force).toBe(false)
+  })
+
+  it('should force fetch when status is "running" and expanded', () => {
+    // #given: running status
+    const params = {
+      sessionId: "session-123",
+      status: "running",
+      cachedState: "ok" as const,
+      cachedDataOk: true,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(true)
+    expect(result.force).toBe(true)
+  })
+
+  it('should not fetch when non-running status and cached data is ok', () => {
+    // #given: done status with good cache
+    const params = {
+      sessionId: "session-123",
+      status: "done",
+      cachedState: "ok" as const,
+      cachedDataOk: true,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(false)
+    expect(result.force).toBe(false)
+  })
+
+  it('should not fetch when already loading', () => {
+    // #given: loading state
+    const params = {
+      sessionId: "session-123",
+      status: "done",
+      cachedState: "loading" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(false)
+    expect(result.force).toBe(false)
+  })
+
+  it('should fetch when non-running, not cached, not loading, and expanded', () => {
+    // #given: done status with no cache
+    const params = {
+      sessionId: "session-123",
+      status: "done",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(true)
+    expect(result.force).toBe(false)
+  })
+
+  it('should handle case-insensitive status values', () => {
+    // #given: RUNNING in uppercase
+    const params = {
+      sessionId: "session-123",
+      status: "RUNNING",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(true)
+    expect(result.force).toBe(true)
+  })
+
+  it('should handle whitespace in status values', () => {
+    // #given: running with whitespace
+    const params = {
+      sessionId: "session-123",
+      status: "  running  ",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(true)
+    expect(result.force).toBe(true)
+  })
+})
+
+describe('toggleIdInSet', () => {
+  it('should add id when not present in set', () => {
+    // #given: empty set
+    const currentSet = new Set<string>()
+
+    // #when
+    const result = toggleIdInSet("task-1", currentSet)
+
+    // #then
+    expect(result.has("task-1")).toBe(true)
+    expect(result.size).toBe(1)
+  })
+
+  it('should remove id when already present in set', () => {
+    // #given: set with id already present
+    const currentSet = new Set(["task-1", "task-2"])
+
+    // #when
+    const result = toggleIdInSet("task-1", currentSet)
+
+    // #then
+    expect(result.has("task-1")).toBe(false)
+    expect(result.has("task-2")).toBe(true)
+    expect(result.size).toBe(1)
+  })
+
+  it('should not modify original set', () => {
+    // #given: original set
+    const originalSet = new Set(["task-1"])
+
+    // #when
+    const result = toggleIdInSet("task-2", originalSet)
+
+    // #then
+    expect(originalSet.has("task-1")).toBe(true)
+    expect(originalSet.has("task-2")).toBe(false)
+    expect(originalSet.size).toBe(1)
+    expect(result.has("task-1")).toBe(true)
+    expect(result.has("task-2")).toBe(true)
+    expect(result.size).toBe(2)
+  })
+})

package/src/ingest/background-tasks.test.ts

@@ -981,7 +981,16 @@ describe("deriveBackgroundTasks", () => {
       "utf8"
     )
 
-    const readdirSync = vi.fn(fs.readdirSync)
+    // Create typed wrapper that records calls and delegates to fs.readdirSync
+    const readdirCalls: Array<[fs.PathLike]> = []
+    const readdirSync = ((path: fs.PathLike, options?: any): any => {
+      if (typeof options === 'object' && options.withFileTypes) {
+        return fs.readdirSync(path, options)
+      }
+      readdirCalls.push([path])
+      return fs.readdirSync(path, 'utf8')
+    }) as typeof fs.readdirSync
+    
     const fsLike = {
       readFileSync: fs.readFileSync,
       readdirSync,
@@ -993,7 +1002,7 @@ describe("deriveBackgroundTasks", () => {
     const rows = deriveBackgroundTasks({ storage, mainSessionId, fs: fsLike })
 
     // #then
-    const backgroundReads = readdirSync.mock.calls.filter((call) => call[0] === childMsgDir)
+    const backgroundReads = readdirCalls.filter((call) => call[0] === childMsgDir)
     expect(rows.length).toBe(2)
     expect(backgroundReads.length).toBe(1)
   })

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