oh-my-opencode-dashboard 0.0.4 → 0.1.0

package/src/server/api.test.ts

@@ -1,24 +1,106 @@
+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 mkProjectRoot(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "omo-dashboard-project-"))
+}
+
+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: [],
+    mainSessionTasks: [],
+    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 projectRoot = mkProjectRoot()
+    const store = createStore()
+    const api = createApi({ store, storageRoot, projectRoot })
 
     const res = await api.request("/health")
     expect(res.status).toBe(200)
@@ -26,22 +108,10 @@ 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 projectRoot = mkProjectRoot()
+    const store = createStore()
+    const api = createApi({ store, storageRoot, projectRoot })
 
     const res = await api.request("/dashboard")
     expect(res.status).toBe(200)
@@ -54,26 +124,78 @@ 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 projectRoot = mkProjectRoot()
+    const store = createStore()
+    const api = createApi({ store, storageRoot, projectRoot })
+
+    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 projectRoot = mkProjectRoot()
+    const store = createStore()
+    const api = createApi({ store, storageRoot, projectRoot })
+
+    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()
+    const projectRoot = mkProjectRoot()
+    writeMessageMeta({ storageRoot, sessionId: "ses_empty", messageId: "msg_1", created: 1000 })
+    const store = createStore()
+    const api = createApi({ store, storageRoot, projectRoot })
+
+    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()
+    const projectRoot = mkProjectRoot()
+    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, projectRoot })
+
+    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)
+  })
+
+  // /sessions was intentionally removed along with the manual session picker.
 })

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; projectRoot: 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

@@ -76,9 +76,49 @@ describe("buildDashboardPayload", () => {
       expect(payload.mainSession.currentTool).toBe("delegate_task")
       expect(payload.mainSession.agent).toBe("sisyphus")
       expect(payload.mainSession.currentModel).toBeNull()
+      expect(payload.mainSession.sessionId).toBe(sessionId)
       
       expect(payload.raw).not.toHaveProperty("prompt")
       expect(payload.raw).not.toHaveProperty("input")
+
+      expect(payload).toHaveProperty("mainSessionTasks")
+      expect((payload as any).mainSessionTasks).toEqual([
+        {
+          id: "main-session",
+          description: "Main session",
+          subline: sessionId,
+          agent: "sisyphus",
+          lastModel: null,
+          status: "running",
+          toolCalls: 1,
+          lastTool: "delegate_task",
+          timeline: "1970-01-01T00:00:01Z: 1s",
+          sessionId,
+        },
+      ])
+
+      expect(payload.raw).toHaveProperty("mainSessionTasks.0.lastTool", "delegate_task")
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
+
+  it("includes mainSessionTasks in raw payload when no sessions exist", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+
+    try {
+      const payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 2000,
+      })
+
+      expect(payload).toHaveProperty("mainSessionTasks")
+      expect((payload as any).mainSessionTasks).toEqual([])
+      expect(payload.raw).toHaveProperty("mainSessionTasks")
     } finally {
       fs.rmSync(storageRoot, { recursive: true, force: true })
       fs.rmSync(projectRoot, { recursive: true, force: true })
@@ -149,6 +189,7 @@ describe("buildDashboardPayload", () => {
       expect(payload).toHaveProperty("timeSeries")
       expect(payload.raw).toHaveProperty("timeSeries")
       expect(payload.mainSession.currentModel).toBeNull()
+      expect(payload.mainSession.sessionId).toBeNull()
 
       const sensitiveKeys = ["prompt", "input", "output", "error", "state"]
 

package/src/server/dashboard.ts

@@ -4,6 +4,7 @@ import { readBoulderState, readPlanProgress, readPlanSteps, type PlanStep } from
 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"
 
 export type DashboardPayload = {
   mainSession: {
@@ -12,6 +13,7 @@ export type DashboardPayload = {
     currentTool: string
     lastUpdatedLabel: string
     session: string
+    sessionId: string | null
     statusPill: string
   }
   planProgress: {
@@ -31,6 +33,19 @@ export type DashboardPayload = {
     toolCalls: number
     lastTool: string
     timeline: string
+    sessionId: string | null
+  }>
+  mainSessionTasks: Array<{
+    id: string
+    description: string
+    subline?: string
+    agent: string
+    lastModel: string | null
+    status: string
+    toolCalls: number
+    lastTool: string
+    timeline: string
+    sessionId: string | null
   }>
   timeSeries: TimeSeriesPayload
   raw: unknown
@@ -91,6 +106,33 @@ function mainStatusPill(status: string): string {
   return "unknown"
 }
 
+function formatIsoNoMs(ts: number): string {
+  const iso = new Date(ts).toISOString()
+  return iso.replace(/\.\d{3}Z$/, "Z")
+}
+
+function formatElapsed(ms: number): string {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1000))
+  const seconds = totalSeconds % 60
+  const totalMinutes = Math.floor(totalSeconds / 60)
+  const minutes = totalMinutes % 60
+  const totalHours = Math.floor(totalMinutes / 60)
+  const hours = totalHours % 24
+  const days = Math.floor(totalHours / 24)
+
+  if (days > 0) return hours > 0 ? `${days}d${hours}h` : `${days}d`
+  if (totalHours > 0) return minutes > 0 ? `${totalHours}h${minutes}m` : `${totalHours}h`
+  if (totalMinutes > 0) return seconds > 0 ? `${totalMinutes}m${seconds}s` : `${totalMinutes}m`
+  return `${seconds}s`
+}
+
+function formatTimeline(startAt: number | null, endAtMs: number): string {
+  if (typeof startAt !== "number") return ""
+  const start = formatIsoNoMs(startAt)
+  const elapsed = formatElapsed(endAtMs - startAt)
+  return `${start}: ${elapsed}`
+}
+
 export function buildDashboardPayload(opts: {
   projectRoot: string
   storage: OpenCodeStorageRoots
@@ -135,6 +177,41 @@ export function buildDashboardPayload(opts: {
   const mainCurrentModel = "currentModel" in main
     ? (main as MainSessionView).currentModel
     : null
+
+  const mainSessionTasks = (() => {
+    if (!sessionId) return []
+
+    const mainStatus = main.status
+    const status = mainStatus === "running_tool" || mainStatus === "thinking" || mainStatus === "busy"
+      ? "running"
+      : mainStatus === "idle"
+        ? "idle"
+        : "unknown"
+
+    const { toolCalls } = deriveToolCalls({
+      storage: opts.storage,
+      sessionId,
+    })
+
+    const startAt = sessionMeta?.time?.created ?? null
+    const endAtMs = status === "running" ? nowMs : (main.lastUpdated ?? nowMs)
+
+    return [
+      {
+        id: "main-session",
+        description: "Main session",
+        subline: sessionId,
+        agent: main.agent,
+        lastModel: mainCurrentModel,
+        status,
+        toolCalls: toolCalls.length,
+        lastTool: toolCalls[0]?.tool ?? "-",
+        timeline: formatTimeline(startAt, endAtMs),
+        sessionId,
+      },
+    ]
+  })()
+
   const payload: DashboardPayload = {
     mainSession: {
       agent: main.agent,
@@ -142,6 +219,7 @@ export function buildDashboardPayload(opts: {
       currentTool: main.currentTool ?? "-",
       lastUpdatedLabel: formatIso(main.lastUpdated),
       session: main.sessionLabel,
+      sessionId: sessionId ?? null,
       statusPill: mainStatusPill(main.status),
     },
     planProgress: {
@@ -161,7 +239,9 @@ export function buildDashboardPayload(opts: {
       toolCalls: t.toolCalls ?? 0,
       lastTool: t.lastTool ?? "-",
       timeline: typeof t.timeline === "string" ? t.timeline : "",
+      sessionId: t.sessionId ?? null,
     })),
+    mainSessionTasks,
     timeSeries,
     raw: null,
   }
@@ -170,6 +250,7 @@ export function buildDashboardPayload(opts: {
     mainSession: payload.mainSession,
     planProgress: payload.planProgress,
     backgroundTasks: payload.backgroundTasks,
+    mainSessionTasks: payload.mainSessionTasks,
     timeSeries: payload.timeSeries,
   }
   return payload

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, projectRoot: resolvedProjectPath }))
 
 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, projectRoot: project }))
 
 const distRoot = join(import.meta.dir, '../../dist')