oh-my-opencode-dashboard 0.0.3 → 0.0.5

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" },
-        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" },
-        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.test.ts

@@ -75,6 +75,7 @@ describe("buildDashboardPayload", () => {
       expect(payload.mainSession.statusPill).toBe("running tool")
       expect(payload.mainSession.currentTool).toBe("delegate_task")
       expect(payload.mainSession.agent).toBe("sisyphus")
+      expect(payload.mainSession.currentModel).toBeNull()
       
       expect(payload.raw).not.toHaveProperty("prompt")
       expect(payload.raw).not.toHaveProperty("input")
@@ -147,6 +148,7 @@ describe("buildDashboardPayload", () => {
 
       expect(payload).toHaveProperty("timeSeries")
       expect(payload.raw).toHaveProperty("timeSeries")
+      expect(payload.mainSession.currentModel).toBeNull()
 
       const sensitiveKeys = ["prompt", "input", "output", "error", "state"]
 
@@ -175,4 +177,141 @@ describe("buildDashboardPayload", () => {
       fs.rmSync(projectRoot, { recursive: true, force: true })
     }
   })
+
+  it("includes latest model strings for main and background sessions", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+    const sessionId = "ses_with_models"
+    const backgroundSessionId = "ses_bg_1"
+    const messageId = "msg_1"
+    const projectID = "proj_1"
+
+    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"
+      )
+      fs.writeFileSync(
+        path.join(sessionMetaDir, `${backgroundSessionId}.json`),
+        JSON.stringify({
+          id: backgroundSessionId,
+          projectID,
+          directory: projectRoot,
+          parentID: sessionId,
+          title: "Background: model task",
+          time: { created: 1000, updated: 1100 },
+        }),
+        "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",
+          agent: "sisyphus",
+          time: { created: 1000 },
+        }),
+        "utf8"
+      )
+
+      const partDir = path.join(storage.part, messageId)
+      fs.mkdirSync(partDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(partDir, "part_1.json"),
+        JSON.stringify({
+          id: "part_1",
+          sessionID: sessionId,
+          messageID: messageId,
+          type: "tool",
+          callID: "call_1",
+          tool: "delegate_task",
+          state: {
+            status: "completed",
+            input: {
+              run_in_background: true,
+              description: "model task",
+              subagent_type: "explore",
+            },
+          },
+        }),
+        "utf8"
+      )
+
+      const backgroundMessageDir = path.join(storage.message, backgroundSessionId)
+      fs.mkdirSync(backgroundMessageDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(backgroundMessageDir, "msg_bg_1.json"),
+        JSON.stringify({
+          id: "msg_bg_1",
+          sessionID: backgroundSessionId,
+          role: "assistant",
+          providerID: "openai",
+          modelID: "gpt-4o",
+          time: { created: 1100 },
+        }),
+        "utf8"
+      )
+
+      const payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 2000,
+      })
+
+      expect(payload.mainSession.currentModel).toBeNull()
+      expect(payload.backgroundTasks).toHaveLength(1)
+      expect(payload.backgroundTasks[0]?.lastModel).toBe("openai/gpt-4o")
+      expect(payload.raw).toHaveProperty("backgroundTasks.0.lastModel", "openai/gpt-4o")
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
+
+  it("does not include elapsed time in status pill when status is unknown", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+    const sessionId = "ses_unknown"
+    const projectID = "proj_1"
+
+    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 payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 65_000,
+      })
+
+      expect(payload.mainSession.statusPill).toBe("unknown")
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
 })

package/src/server/dashboard.ts

@@ -3,9 +3,41 @@ import * as path from "node:path"
 import { readBoulderState, readPlanProgress, readPlanSteps, type PlanStep } from "../ingest/boulder"
 import { deriveBackgroundTasks } from "../ingest/background-tasks"
 import { deriveTimeSeriesActivity, type TimeSeriesPayload } from "../ingest/timeseries"
-import { getMainSessionView, getStorageRoots, pickActiveSessionId, readMainSessionMetas, type OpenCodeStorageRoots, type SessionMetadata } from "../ingest/session"
+import { getMainSessionView, getStorageRoots, pickActiveSessionId, readMainSessionMetas, type MainSessionView, type OpenCodeStorageRoots, type SessionMetadata } from "../ingest/session"
 
 export type DashboardPayload = {
+  mainSession: {
+    agent: string
+    currentModel: string | null
+    currentTool: string
+    lastUpdatedLabel: string
+    session: string
+    statusPill: string
+  }
+  planProgress: {
+    name: string
+    completed: number
+    total: number
+    path: string
+    statusPill: string
+    steps: PlanStep[]
+  }
+  backgroundTasks: Array<{
+    id: string
+    description: string
+    agent: string
+    lastModel: string | null
+    status: string
+    toolCalls: number
+    lastTool: string
+    timeline: string
+    sessionId: string | null
+  }>
+  timeSeries: TimeSeriesPayload
+  raw: unknown
+}
+
+export type LegacyDashboardPayload = {
   mainSession: {
     agent: string
     currentTool: string
@@ -35,7 +67,7 @@ export type DashboardPayload = {
 }
 
 export type DashboardStore = {
-  getSnapshot: () => DashboardPayload
+  getSnapshot: () => DashboardPayload | LegacyDashboardPayload
 }
 
 function formatIso(ts: number | null): string {
@@ -101,10 +133,13 @@ export function buildDashboardPayload(opts: {
     mainSessionId: sessionId ?? null,
     nowMs,
   })
-
+  const mainCurrentModel = "currentModel" in main
+    ? (main as MainSessionView).currentModel
+    : null
   const payload: DashboardPayload = {
     mainSession: {
       agent: main.agent,
+      currentModel: mainCurrentModel,
       currentTool: main.currentTool ?? "-",
       lastUpdatedLabel: formatIso(main.lastUpdated),
       session: main.sessionLabel,
@@ -122,10 +157,12 @@ export function buildDashboardPayload(opts: {
       id: t.id,
       description: t.description,
       agent: t.agent,
+      lastModel: t.lastModel ?? null,
       status: t.status,
       toolCalls: t.toolCalls ?? 0,
       lastTool: t.lastTool ?? "-",
       timeline: typeof t.timeline === "string" ? t.timeline : "",
+      sessionId: t.sessionId ?? null,
     })),
     timeSeries,
     raw: null,