oh-my-opencode-dashboard 0.0.1 → 0.0.2

package/src/ingest/timeseries.ts

@@ -0,0 +1,289 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import type { OpenCodeStorageRoots, StoredMessageMeta } from "./session"
+import { getMessageDir } from "./session"
+import { readAllSessionMetas } from "./background-tasks"
+
+export type TimeSeriesTone = "muted" | "teal" | "red" | "green"
+
+export type TimeSeriesSeries = {
+  id: string
+  label: string
+  tone: TimeSeriesTone
+  values: number[]
+}
+
+export type TimeSeriesPayload = {
+  windowMs: number
+  bucketMs: number
+  buckets: number
+  anchorMs: number
+  serverNowMs: number
+  series: TimeSeriesSeries[]
+}
+
+type CanonicalAgent = "sisyphus" | "prometheus" | "atlas" | "other"
+
+const SERIES_ORDER: Array<Pick<TimeSeriesSeries, "id" | "label" | "tone">> = [
+  { id: "overall-main", label: "Overall", tone: "muted" },
+  { id: "agent:sisyphus", label: "Sisyphus", tone: "teal" },
+  { id: "agent:prometheus", label: "Prometheus", tone: "red" },
+  { id: "agent:atlas", label: "Atlas", tone: "green" },
+  { id: "background-total", label: "Background tasks (total)", tone: "muted" },
+]
+
+function zeroBuckets(size: number): number[] {
+  return Array.from({ length: size }, () => 0)
+}
+
+function listJsonFiles(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir).filter((f) => f.endsWith(".json"))
+  } catch {
+    return []
+  }
+}
+
+function readJsonFile<T>(filePath: string): T | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf8")
+    return JSON.parse(content) as T
+  } catch {
+    return null
+  }
+}
+
+function readRecentMessageMetas(messageDir: string, maxMessages: number): StoredMessageMeta[] {
+  if (!messageDir || !fs.existsSync(messageDir)) return []
+  const ranked = listJsonFiles(messageDir)
+    .map((f) => ({
+      f,
+      mtime: (() => {
+        try {
+          return fs.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))
+    if (meta && typeof meta.id === "string") metas.push(meta)
+  }
+  return metas
+}
+
+function countToolParts(partStorage: string, messageId: string): number {
+  const partDir = path.join(partStorage, messageId)
+  if (!fs.existsSync(partDir)) return 0
+
+  let count = 0
+  const files = listJsonFiles(partDir).sort()
+  for (const file of files) {
+    const part = readJsonFile<{ type?: string }>(path.join(partDir, file))
+    if (part && part.type === "tool") count += 1
+  }
+  return count
+}
+
+function canonicalizeAgent(agent: unknown): CanonicalAgent {
+  if (typeof agent !== "string") return "other"
+  const trimmed = agent.trim()
+  if (!trimmed) return "other"
+  const lowered = trimmed.toLowerCase()
+  if (lowered.startsWith("sisyphus-junior")) return "sisyphus"
+  if (lowered.startsWith("sisyphus")) return "sisyphus"
+  if (lowered.startsWith("prometheus")) return "prometheus"
+  if (lowered.startsWith("atlas")) return "atlas"
+  return "other"
+}
+
+function addToBucket(values: number[], bucketIndex: number, count: number): void {
+  if (bucketIndex < 0 || bucketIndex >= values.length) return
+  values[bucketIndex] += count
+}
+
+function getCreated(meta: StoredMessageMeta): number {
+  const created = meta.time?.created
+  return typeof created === "number" ? created : -Infinity
+}
+
+function bucketMessageTools(opts: {
+  storage: OpenCodeStorageRoots
+  messageDir: string
+  startMs: number
+  anchorMs: number
+  bucketMs: number
+  overall: number[]
+  perAgent?: Record<Exclude<CanonicalAgent, "other">, number[]>
+}): void {
+  const metas = readRecentMessageMetas(opts.messageDir, 200)
+  const ordered = [...metas].sort((a, b) => {
+    const at = getCreated(a)
+    const bt = getCreated(b)
+    if (bt !== at) return bt - at
+    return String(a.id).localeCompare(String(b.id))
+  })
+
+  for (const meta of ordered) {
+    const created = getCreated(meta)
+    if (created < opts.startMs) break
+    if (created >= opts.anchorMs) continue
+
+    const bucketIndex = Math.floor((created - opts.startMs) / opts.bucketMs)
+    const toolCount = countToolParts(opts.storage.part, meta.id)
+    if (toolCount <= 0) continue
+
+    addToBucket(opts.overall, bucketIndex, toolCount)
+    const perAgent = opts.perAgent
+    if (perAgent) {
+      const agent = canonicalizeAgent(meta.agent)
+      if (agent === "sisyphus" || agent === "prometheus" || agent === "atlas") {
+        addToBucket(perAgent[agent], bucketIndex, toolCount)
+      }
+    }
+  }
+}
+
+function bucketBackgroundTools(opts: {
+  storage: OpenCodeStorageRoots
+  sessionIds: string[]
+  startMs: number
+  anchorMs: number
+  bucketMs: number
+  output: number[]
+}): void {
+  for (const sessionId of opts.sessionIds) {
+    const messageDir = getMessageDir(opts.storage.message, sessionId)
+    const metas = readRecentMessageMetas(messageDir, 200)
+    const ordered = [...metas].sort((a, b) => {
+      const at = getCreated(a)
+      const bt = getCreated(b)
+      if (bt !== at) return bt - at
+      return String(a.id).localeCompare(String(b.id))
+    })
+
+    for (const meta of ordered) {
+      const created = getCreated(meta)
+      if (created < opts.startMs) break
+      if (created >= opts.anchorMs) continue
+
+      const bucketIndex = Math.floor((created - opts.startMs) / opts.bucketMs)
+      const toolCount = countToolParts(opts.storage.part, meta.id)
+      if (toolCount <= 0) continue
+      addToBucket(opts.output, bucketIndex, toolCount)
+    }
+  }
+}
+
+function bucketSessionAgents(opts: {
+  storage: OpenCodeStorageRoots
+  sessionIds: string[]
+  startMs: number
+  anchorMs: number
+  bucketMs: number
+  overall: number[]
+  perAgent: Record<Exclude<CanonicalAgent, "other">, number[]>
+}): void {
+  for (const sessionId of opts.sessionIds) {
+    const messageDir = getMessageDir(opts.storage.message, sessionId)
+    if (!messageDir) continue
+    bucketMessageTools({
+      storage: opts.storage,
+      messageDir,
+      startMs: opts.startMs,
+      anchorMs: opts.anchorMs,
+      bucketMs: opts.bucketMs,
+      overall: opts.overall,
+      // Background sessions are owned by Sisyphus; don't smear activity into Prometheus/Atlas.
+      perAgent: undefined,
+    })
+  }
+}
+
+export function deriveTimeSeriesActivity(opts: {
+  storage: OpenCodeStorageRoots
+  mainSessionId: string | null
+  nowMs?: number
+  windowMs?: number
+  bucketMs?: number
+}): TimeSeriesPayload {
+  const windowMs = opts.windowMs ?? 300_000
+  const bucketMs = opts.bucketMs ?? 2_000
+  const buckets = Math.floor(windowMs / bucketMs)
+  const nowMs = opts.nowMs ?? Date.now()
+  const anchorMs = Math.floor(nowMs / bucketMs) * bucketMs
+  const startMs = anchorMs - windowMs
+
+  const overall = zeroBuckets(buckets)
+  const sisyphus = zeroBuckets(buckets)
+  const prometheus = zeroBuckets(buckets)
+  const atlas = zeroBuckets(buckets)
+  const background = zeroBuckets(buckets)
+
+  const mainSessionId = opts.mainSessionId
+  if (mainSessionId) {
+    const messageDir = getMessageDir(opts.storage.message, mainSessionId)
+    if (messageDir) {
+      bucketMessageTools({
+        storage: opts.storage,
+        messageDir,
+        startMs,
+        anchorMs,
+        bucketMs,
+        overall,
+        perAgent: { sisyphus, prometheus, atlas },
+      })
+    }
+
+    const childSessions = readAllSessionMetas(opts.storage.session)
+      .filter((meta) => meta.parentID === mainSessionId)
+      .sort((a, b) => {
+        const at = a.time?.updated ?? 0
+        const bt = b.time?.updated ?? 0
+        if (bt !== at) return bt - at
+        return String(a.id).localeCompare(String(b.id))
+      })
+      .slice(0, 25)
+      .map((meta) => meta.id)
+
+    if (childSessions.length > 0) {
+      bucketBackgroundTools({
+        storage: opts.storage,
+        sessionIds: childSessions,
+        startMs,
+        anchorMs,
+        bucketMs,
+        output: background,
+      })
+      bucketSessionAgents({
+        storage: opts.storage,
+        sessionIds: childSessions,
+        startMs,
+        anchorMs,
+        bucketMs,
+        overall,
+        perAgent: { sisyphus, prometheus, atlas },
+      })
+    }
+  }
+
+  return {
+    windowMs,
+    bucketMs,
+    buckets,
+    anchorMs,
+    serverNowMs: nowMs,
+    series: [
+      { ...SERIES_ORDER[0], values: overall },
+      { ...SERIES_ORDER[1], values: sisyphus },
+      { ...SERIES_ORDER[2], values: prometheus },
+      { ...SERIES_ORDER[3], values: atlas },
+      { ...SERIES_ORDER[4], values: background },
+    ],
+  }
+}

package/src/server/api.test.ts

@@ -8,6 +8,14 @@ describe('API Routes', () => {
         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,
       }),
     })
@@ -23,6 +31,14 @@ describe('API Routes', () => {
         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 },
       }),
     })
@@ -35,6 +51,7 @@ describe('API Routes', () => {
     expect(data).toHaveProperty("mainSession")
     expect(data).toHaveProperty("planProgress")
     expect(data).toHaveProperty("backgroundTasks")
+    expect(data).toHaveProperty("timeSeries")
     expect(data).toHaveProperty("raw")
     
     const sensitiveKeys = ["prompt", "input", "output", "error", "state"]

package/src/server/dashboard.test.ts

@@ -132,4 +132,47 @@ describe("buildDashboardPayload", () => {
       fs.rmSync(projectRoot, { recursive: true, force: true })
     }
   })
+
+  it("includes timeSeries and sanitized 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("timeSeries")
+      expect(payload.raw).toHaveProperty("timeSeries")
+
+      const sensitiveKeys = ["prompt", "input", "output", "error", "state"]
+
+      const hasSensitiveKeys = (value: unknown): boolean => {
+        if (typeof value !== "object" || value === null) {
+          return false
+        }
+
+        for (const key of Object.keys(value)) {
+          if (sensitiveKeys.includes(key)) {
+            return true
+          }
+          const nextValue = (value as Record<string, unknown>)[key]
+          if (typeof nextValue === "object" && nextValue !== null) {
+            if (hasSensitiveKeys(nextValue)) {
+              return true
+            }
+          }
+        }
+        return false
+      }
+
+      expect(hasSensitiveKeys(payload.raw)).toBe(false)
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
 })

package/src/server/dashboard.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs"
 import * as path from "node:path"
-import { readBoulderState, readPlanProgress } from "../ingest/boulder"
+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"
 
 export type DashboardPayload = {
@@ -18,6 +19,7 @@ export type DashboardPayload = {
     total: number
     path: string
     statusPill: string
+    steps: PlanStep[]
   }
   backgroundTasks: Array<{
     id: string
@@ -28,6 +30,7 @@ export type DashboardPayload = {
     lastTool: string
     timeline: string
   }>
+  timeSeries: TimeSeriesPayload
   raw: unknown
 }
 
@@ -68,6 +71,7 @@ export function buildDashboardPayload(opts: {
   const planName = boulder?.plan_name ?? "(no active plan)"
   const planPath = boulder?.active_plan ?? ""
   const plan = boulder ? readPlanProgress(opts.projectRoot, boulder.active_plan) : { total: 0, completed: 0, isComplete: false, missing: true }
+  const planSteps = boulder ? readPlanSteps(opts.projectRoot, boulder.active_plan) : { missing: true, steps: [] as PlanStep[] }
 
   const sessionId = pickActiveSessionId({
     projectRoot: opts.projectRoot,
@@ -92,6 +96,11 @@ export function buildDashboardPayload(opts: {
     : { agent: "unknown", currentTool: null, lastUpdated: null, sessionLabel: "(no session)", status: "unknown" as const }
 
   const tasks = sessionId ? deriveBackgroundTasks({ storage: opts.storage, mainSessionId: sessionId, nowMs }) : []
+  const timeSeries = deriveTimeSeriesActivity({
+    storage: opts.storage,
+    mainSessionId: sessionId ?? null,
+    nowMs,
+  })
 
   const payload: DashboardPayload = {
     mainSession: {
@@ -107,6 +116,7 @@ export function buildDashboardPayload(opts: {
       total: plan.total,
       path: planPath,
       statusPill: planStatusPill(plan),
+      steps: planSteps.missing ? [] : planSteps.steps,
     },
     backgroundTasks: tasks.map((t) => ({
       id: t.id,
@@ -117,6 +127,7 @@ export function buildDashboardPayload(opts: {
       lastTool: t.lastTool ?? "-",
       timeline: typeof t.timeline === "string" ? t.timeline : "",
     })),
+    timeSeries,
     raw: null,
   }
 
@@ -124,6 +135,7 @@ export function buildDashboardPayload(opts: {
     mainSession: payload.mainSession,
     planProgress: payload.planProgress,
     backgroundTasks: payload.backgroundTasks,
+    timeSeries: payload.timeSeries,
   }
   return payload
 }

package/src/sound.test.ts

@@ -5,6 +5,7 @@ describe("playDing", () => {
 
   afterEach(() => {
     ;(globalThis as unknown as { window?: unknown }).window = prevWindow
+    return import("./sound").then((m) => m.__resetAudioForTests())
   })
 
   it("plays two tones for waiting", async () => {
@@ -52,4 +53,50 @@ describe("playDing", () => {
 
     expect(oscillators).toHaveLength(2)
   })
+
+  it("plays three tones for question", async () => {
+    const oscillators: Array<{ start: ReturnType<typeof vi.fn> }> = []
+
+    class FakeAudioContext {
+      public state: AudioContextState = "suspended"
+      public currentTime = 1
+      public destination = null as unknown as AudioDestinationNode
+
+      resume = vi.fn(async () => {
+        this.state = "running"
+      })
+
+      createOscillator(): OscillatorNode {
+        const osc = {
+          type: "sine" as OscillatorType,
+          frequency: { setValueAtTime: vi.fn() },
+          connect: vi.fn(),
+          start: vi.fn(),
+          stop: vi.fn(),
+        }
+        oscillators.push({ start: osc.start })
+        return osc as unknown as OscillatorNode
+      }
+
+      createGain(): GainNode {
+        const g = {
+          gain: {
+            setValueAtTime: vi.fn(),
+            linearRampToValueAtTime: vi.fn(),
+          },
+          connect: vi.fn(),
+        }
+        return g as unknown as GainNode
+      }
+    }
+
+    ;(globalThis as unknown as { window?: unknown }).window = {
+      AudioContext: FakeAudioContext,
+    } as unknown as Window & typeof globalThis
+
+    const { playDing } = await import("./sound")
+    await playDing("question")
+
+    expect(oscillators).toHaveLength(3)
+  })
 })

package/src/sound.ts

@@ -1,7 +1,11 @@
-export type DingKind = "waiting" | "task" | "all"
+export type DingKind = "waiting" | "task" | "all" | "question"
 
 let ctx: AudioContext | null = null
 
+export function __resetAudioForTests(): void {
+  ctx = null
+}
+
 function getCtx(): AudioContext | null {
   if (typeof window === "undefined") return null
   const AnyAudioContext = (window.AudioContext ?? (window as any).webkitAudioContext) as
@@ -82,6 +86,13 @@ export async function playDing(kind: DingKind): Promise<void> {
     return
   }
 
+  if (kind === "question") {
+    playTone({ at: t0, freq: 988, dur: 0.07, gain: baseGain })
+    playTone({ at: t0 + 0.09, freq: 740, dur: 0.11, gain: baseGain })
+    playTone({ at: t0 + 0.22, freq: 880, dur: 0.08, gain: baseGain })
+    return
+  }
+
   // all
   playTone({ at: t0, freq: 523.25, dur: 0.10, gain: baseGain })
   playTone({ at: t0 + 0.12, freq: 659.25, dur: 0.10, gain: baseGain })