oh-my-opencode-dashboard 0.0.1

package/src/server/dashboard.test.ts

@@ -0,0 +1,135 @@
+import * as fs from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
+import { describe, expect, it } from "vitest"
+import { buildDashboardPayload } from "./dashboard"
+import { getStorageRoots } from "../ingest/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
+}
+
+describe("buildDashboardPayload", () => {
+  it("surfaces 'running tool' status when session has in-flight tool", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+    const sessionId = "ses_running_tool"
+    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"
+      )
+
+      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: "running", input: {} },
+        }),
+        "utf8"
+      )
+
+      const payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 2000,
+      })
+
+      expect(payload.mainSession.statusPill).toBe("running tool")
+      expect(payload.mainSession.currentTool).toBe("delegate_task")
+      expect(payload.mainSession.agent).toBe("sisyphus")
+      
+      expect(payload.raw).not.toHaveProperty("prompt")
+      expect(payload.raw).not.toHaveProperty("input")
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
+
+  it("surfaces 'thinking' status when latest assistant message is not completed", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+    const sessionId = "ses_thinking"
+    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"
+      )
+
+      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 payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 50_000,
+      })
+
+      expect(payload.mainSession.statusPill).toBe("thinking")
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
+})

package/src/server/dashboard.ts

@@ -0,0 +1,191 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { readBoulderState, readPlanProgress } from "../ingest/boulder"
+import { deriveBackgroundTasks } from "../ingest/background-tasks"
+import { getMainSessionView, getStorageRoots, pickActiveSessionId, readMainSessionMetas, type OpenCodeStorageRoots, type SessionMetadata } from "../ingest/session"
+
+export type DashboardPayload = {
+  mainSession: {
+    agent: string
+    currentTool: string
+    lastUpdatedLabel: string
+    session: string
+    statusPill: string
+  }
+  planProgress: {
+    name: string
+    completed: number
+    total: number
+    path: string
+    statusPill: string
+  }
+  backgroundTasks: Array<{
+    id: string
+    description: string
+    agent: string
+    status: string
+    toolCalls: number
+    lastTool: string
+    timeline: string
+  }>
+  raw: unknown
+}
+
+export type DashboardStore = {
+  getSnapshot: () => DashboardPayload
+}
+
+function formatIso(ts: number | null): string {
+  if (!ts) return "never"
+  try {
+    return new Date(ts).toISOString()
+  } catch {
+    return "never"
+  }
+}
+
+function planStatusPill(progress: { missing: boolean; isComplete: boolean }): string {
+  if (progress.missing) return "not started"
+  return progress.isComplete ? "complete" : "in progress"
+}
+
+function mainStatusPill(status: string): string {
+  if (status === "running_tool") return "running tool"
+  if (status === "thinking") return "thinking"
+  if (status === "busy") return "busy"
+  if (status === "idle") return "idle"
+  return "unknown"
+}
+
+export function buildDashboardPayload(opts: {
+  projectRoot: string
+  storage: OpenCodeStorageRoots
+  nowMs?: number
+}): DashboardPayload {
+  const nowMs = opts.nowMs ?? Date.now()
+
+  const boulder = readBoulderState(opts.projectRoot)
+  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 sessionId = pickActiveSessionId({
+    projectRoot: opts.projectRoot,
+    storage: opts.storage,
+    boulderSessionIds: boulder?.session_ids,
+  })
+
+  let sessionMeta: SessionMetadata | null = null
+  if (sessionId) {
+    const metas = readMainSessionMetas(opts.storage.session, opts.projectRoot)
+    sessionMeta = metas.find((m) => m.id === sessionId) ?? null
+  }
+
+  const main = sessionId
+    ? getMainSessionView({
+        projectRoot: opts.projectRoot,
+        sessionId,
+        storage: opts.storage,
+        sessionMeta,
+        nowMs,
+      })
+    : { agent: "unknown", currentTool: null, lastUpdated: null, sessionLabel: "(no session)", status: "unknown" as const }
+
+  const tasks = sessionId ? deriveBackgroundTasks({ storage: opts.storage, mainSessionId: sessionId, nowMs }) : []
+
+  const payload: DashboardPayload = {
+    mainSession: {
+      agent: main.agent,
+      currentTool: main.currentTool ?? "-",
+      lastUpdatedLabel: formatIso(main.lastUpdated),
+      session: main.sessionLabel,
+      statusPill: mainStatusPill(main.status),
+    },
+    planProgress: {
+      name: planName,
+      completed: plan.completed,
+      total: plan.total,
+      path: planPath,
+      statusPill: planStatusPill(plan),
+    },
+    backgroundTasks: tasks.map((t) => ({
+      id: t.id,
+      description: t.description,
+      agent: t.agent,
+      status: t.status,
+      toolCalls: t.toolCalls ?? 0,
+      lastTool: t.lastTool ?? "-",
+      timeline: typeof t.timeline === "string" ? t.timeline : "",
+    })),
+    raw: null,
+  }
+
+  payload.raw = {
+    mainSession: payload.mainSession,
+    planProgress: payload.planProgress,
+    backgroundTasks: payload.backgroundTasks,
+  }
+  return payload
+}
+
+function watchIfExists(target: string, onChange: () => void): fs.FSWatcher | null {
+  try {
+    if (!fs.existsSync(target)) return null
+    return fs.watch(target, { persistent: false }, () => onChange())
+  } catch {
+    return null
+  }
+}
+
+export function createDashboardStore(opts: {
+  projectRoot: string
+  storageRoot: string
+  pollIntervalMs?: number
+  watch?: boolean
+}): DashboardStore {
+  const storage = getStorageRoots(opts.storageRoot)
+  const pollIntervalMs = opts.pollIntervalMs ?? 2000
+  const watch = opts.watch !== false
+
+  let lastComputedAt = 0
+  let dirty = true
+  let cached: DashboardPayload | null = null
+
+  const watchers: fs.FSWatcher[] = []
+  const markDirty = () => {
+    dirty = true
+  }
+
+  if (watch) {
+    watchers.push(...[
+      watchIfExists(path.join(opts.projectRoot, ".sisyphus", "boulder.json"), markDirty),
+      watchIfExists(path.join(opts.projectRoot, ".sisyphus", "plans"), markDirty),
+      watchIfExists(storage.session, markDirty),
+      watchIfExists(storage.message, markDirty),
+      watchIfExists(storage.part, markDirty),
+    ].filter(Boolean) as fs.FSWatcher[])
+
+    // Best-effort: close watchers on process exit.
+    process.on("exit", () => {
+      for (const w of watchers) {
+        try {
+          w.close()
+        } catch {
+          // ignore
+        }
+      }
+    })
+  }
+
+  return {
+    getSnapshot() {
+      const now = Date.now()
+      if (!cached || dirty || now - lastComputedAt > pollIntervalMs) {
+        cached = buildDashboardPayload({ projectRoot: opts.projectRoot, storage })
+        lastComputedAt = now
+        dirty = false
+      }
+      return cached
+    },
+  }
+}

package/src/server/dev.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+import { Hono } from "hono"
+import { createApi } from "./api"
+import { createDashboardStore } from "./dashboard"
+import { getOpenCodeStorageDir } from "../ingest/paths"
+
+const args = process.argv.slice(2)
+let projectPath: string | undefined;
+let port = 51234;
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === '--project' && i + 1 < args.length) {
+    projectPath = args[i + 1];
+    i++;
+  } else if (arg === '--port' && i + 1 < args.length) {
+    const portValue = parseInt(args[i + 1], 10);
+    if (!isNaN(portValue)) {
+      port = portValue;
+    }
+    i++;
+  }
+}
+
+const resolvedProjectPath = projectPath ?? process.cwd()
+
+const app = new Hono()
+
+const store = createDashboardStore({
+  projectRoot: resolvedProjectPath,
+  storageRoot: getOpenCodeStorageDir(),
+  watch: true,
+  pollIntervalMs: 2000,
+})
+
+app.route("/api", createApi(store))
+
+Bun.serve({
+  fetch: app.fetch,
+  hostname: '127.0.0.1',
+  port,
+})
+
+console.log(`Server running at http://127.0.0.1:${port}`)

package/src/server/start.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+import { Hono } from 'hono'
+import { join } from 'node:path'
+import { parseArgs } from 'util'
+import { createApi } from "./api"
+import { createDashboardStore } from "./dashboard"
+import { getOpenCodeStorageDir } from "../ingest/paths"
+
+const { values } = parseArgs({
+  args: Bun.argv,
+  options: {
+    project: { type: 'string' },
+    port: { type: 'string' },
+  },
+  allowPositionals: true,
+})
+
+const project = values.project ?? process.cwd()
+
+const port = parseInt(values.port || '51234')
+
+const app = new Hono()
+
+const store = createDashboardStore({
+  projectRoot: project,
+  storageRoot: getOpenCodeStorageDir(),
+  watch: true,
+  pollIntervalMs: 2000,
+})
+
+app.route('/api', createApi(store))
+
+const distRoot = join(import.meta.dir, '../../dist')
+
+// SPA fallback middleware
+app.use('*', async (c, next) => {
+  const path = c.req.path
+  
+  // Skip API routes - let them pass through
+  if (path.startsWith('/api/')) {
+    return await next()
+  }
+  
+  // For non-API routes without extensions, serve index.html
+  if (!path.includes('.')) {
+    const indexFile = Bun.file(join(distRoot, 'index.html'))
+    if (await indexFile.exists()) {
+      return c.html(await indexFile.text())
+    }
+    return c.notFound()
+  }
+  
+  // For static files with extensions, try to serve them
+  const relativePath = path.startsWith('/') ? path.slice(1) : path
+  const file = Bun.file(join(distRoot, relativePath))
+  if (await file.exists()) {
+    const ext = path.split('.').pop() || ''
+    const contentType = getContentType(ext)
+    return new Response(file, {
+      headers: { 'Content-Type': contentType }
+    })
+  }
+  
+  return c.notFound()
+})
+
+function getContentType(ext: string): string {
+  const types: Record<string, string> = {
+    'html': 'text/html',
+    'js': 'application/javascript',
+    'css': 'text/css',
+    'json': 'application/json',
+    'png': 'image/png',
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'gif': 'image/gif',
+    'svg': 'image/svg+xml',
+    'ico': 'image/x-icon',
+    'woff': 'font/woff',
+    'woff2': 'font/woff2',
+    'ttf': 'font/ttf',
+    'eot': 'application/vnd.ms-fontobject',
+  }
+  return types[ext] || 'text/plain'
+}
+
+Bun.serve({
+  fetch: app.fetch,
+  hostname: '127.0.0.1',
+  port,
+})
+
+console.log(`Server running on http://127.0.0.1:${port}`)

package/src/sound.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+
+describe("playDing", () => {
+  const prevWindow = (globalThis as unknown as { window?: unknown }).window
+
+  afterEach(() => {
+    ;(globalThis as unknown as { window?: unknown }).window = prevWindow
+  })
+
+  it("plays two tones for waiting", 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("waiting")
+
+    expect(oscillators).toHaveLength(2)
+  })
+})

package/src/sound.ts

@@ -0,0 +1,89 @@
+export type DingKind = "waiting" | "task" | "all"
+
+let ctx: AudioContext | null = null
+
+function getCtx(): AudioContext | null {
+  if (typeof window === "undefined") return null
+  const AnyAudioContext = (window.AudioContext ?? (window as any).webkitAudioContext) as
+    | (new () => AudioContext)
+    | undefined
+  if (!AnyAudioContext) return null
+
+  if (!ctx) {
+    ctx = new AnyAudioContext()
+  }
+
+  return ctx
+}
+
+export async function unlockAudio(): Promise<boolean> {
+  const c = getCtx()
+  if (!c) return false
+  try {
+    if (c.state !== "running") {
+      await c.resume()
+    }
+    return c.state === "running"
+  } catch {
+    return false
+  }
+}
+
+function playTone(opts: {
+  at: number
+  freq: number
+  dur: number
+  gain: number
+}): void {
+  const c = getCtx()
+  if (!c) return
+  if (c.state !== "running") return
+
+  const osc = c.createOscillator()
+  const g = c.createGain()
+
+  osc.type = "sine"
+  osc.frequency.setValueAtTime(opts.freq, opts.at)
+
+  const attack = Math.min(0.01, opts.dur / 4)
+  const release = Math.min(0.08, opts.dur / 2)
+
+  g.gain.setValueAtTime(0, opts.at)
+  g.gain.linearRampToValueAtTime(opts.gain, opts.at + attack)
+  g.gain.setValueAtTime(opts.gain, opts.at + Math.max(attack, opts.dur - release))
+  g.gain.linearRampToValueAtTime(0, opts.at + opts.dur)
+
+  osc.connect(g)
+  g.connect(c.destination)
+
+  osc.start(opts.at)
+  osc.stop(opts.at + opts.dur + 0.01)
+}
+
+export async function playDing(kind: DingKind): Promise<void> {
+  const ok = await unlockAudio()
+  if (!ok) return
+
+  const c = getCtx()
+  if (!c) return
+
+  const t0 = c.currentTime + 0.01
+  const baseGain = 0.06
+
+  if (kind === "waiting") {
+    playTone({ at: t0, freq: 784, dur: 0.08, gain: baseGain })
+    playTone({ at: t0 + 0.10, freq: 659, dur: 0.10, gain: baseGain })
+    return
+  }
+
+  if (kind === "task") {
+    playTone({ at: t0, freq: 659, dur: 0.08, gain: baseGain })
+    playTone({ at: t0 + 0.10, freq: 880, dur: 0.10, 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 })
+  playTone({ at: t0 + 0.24, freq: 783.99, dur: 0.14, gain: baseGain })
+}