oh-my-opencode-dashboard 0.0.1

package/src/ingest/session.test.ts

@@ -0,0 +1,220 @@
+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 {
+  getMainSessionView,
+  getStorageRoots,
+  pickActiveSessionId,
+  readMainSessionMetas,
+} 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
+}
+
+describe("pickActiveSessionId", () => {
+  it("prefers last boulder session_id that exists", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = "/tmp/project"
+
+    fs.mkdirSync(path.join(storage.message, "ses_ok"), { recursive: true })
+
+    const picked = pickActiveSessionId({
+      projectRoot,
+      storage,
+      boulderSessionIds: ["ses_missing", "ses_ok"],
+    })
+    expect(picked).toBe("ses_ok")
+  })
+
+  it("falls back to newest main session metadata for directory", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = "/tmp/project/"
+    const projectID = "proj_1"
+    fs.mkdirSync(path.join(storage.session, projectID), { recursive: true })
+
+    fs.writeFileSync(
+      path.join(storage.session, projectID, "ses_1.json"),
+      JSON.stringify({
+        id: "ses_1",
+        projectID,
+        directory: "/tmp/project",
+        time: { created: 1, updated: 10 },
+      }),
+      "utf8"
+    )
+    fs.writeFileSync(
+      path.join(storage.session, projectID, "ses_2.json"),
+      JSON.stringify({
+        id: "ses_2",
+        projectID,
+        directory: "/tmp/project",
+        time: { created: 2, updated: 20 },
+      }),
+      "utf8"
+    )
+
+    const picked = pickActiveSessionId({ projectRoot, storage })
+    expect(picked).toBe("ses_2")
+  })
+})
+
+describe("getMainSessionView", () => {
+  it("derives current tool and busy state from latest tool part", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = "/tmp/project"
+    const sessionId = "ses_1"
+
+    const messageDir = path.join(storage.message, sessionId)
+    fs.mkdirSync(messageDir, { recursive: true })
+
+    const messageID = "msg_1"
+    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,
+        type: "tool",
+        callID: "call_1",
+        tool: "delegate_task",
+        state: { status: "running", input: {} },
+      }),
+      "utf8"
+    )
+
+    const metas = readMainSessionMetas(storage.session, projectRoot)
+    const view = getMainSessionView({
+      projectRoot,
+      sessionId,
+      storage,
+      sessionMeta: metas[0] ?? null,
+      nowMs: 2000,
+    })
+
+    expect(view.agent).toBe("sisyphus")
+    expect(view.currentTool).toBe("delegate_task")
+    expect(view.status).toBe("running_tool")
+  })
+
+  it("reproduces bug: newest meta is user, tool still running", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = "/tmp/project"
+    const sessionId = "ses_1"
+
+    const messageDir = path.join(storage.message, sessionId)
+    fs.mkdirSync(messageDir, { recursive: true })
+
+    // Create an older assistant message with a running tool part
+    const assistantMessageID = "msg_1"
+    fs.writeFileSync(
+      path.join(messageDir, `${assistantMessageID}.json`),
+      JSON.stringify({
+        id: assistantMessageID,
+        sessionID: sessionId,
+        role: "assistant",
+        agent: "sisyphus",
+        time: { created: 1000 },
+      }),
+      "utf8"
+    )
+
+    const assistantPartDir = path.join(storage.part, assistantMessageID)
+    fs.mkdirSync(assistantPartDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(assistantPartDir, "part_1.json"),
+      JSON.stringify({
+        id: "part_1",
+        sessionID: sessionId,
+        messageID: assistantMessageID,
+        type: "tool",
+        callID: "call_1",
+        tool: "grep",
+        state: { status: "running", input: { query: "test" } },
+      }),
+      "utf8"
+    )
+
+    // Create a newer user message (this becomes the "newest meta")
+    const userMessageID = "msg_2"
+    fs.writeFileSync(
+      path.join(messageDir, `${userMessageID}.json`),
+      JSON.stringify({
+        id: userMessageID,
+        sessionID: sessionId,
+        role: "user",
+        time: { created: 2000 },
+      }),
+      "utf8"
+    )
+
+    const metas = readMainSessionMetas(storage.session, projectRoot)
+    const view = getMainSessionView({
+      projectRoot,
+      sessionId,
+      storage,
+      sessionMeta: metas[0] ?? null,
+      nowMs: 50000, // Force idle branch: nowMs - newestMeta.time.created > 15_000
+    })
+
+    // Should detect running tool and return running_tool status
+    expect(view.status).toBe("running_tool")
+    expect(view.currentTool).toBe("grep")
+  })
+
+  it("derives thinking state when latest assistant message is not completed", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = "/tmp/project"
+    const sessionId = "ses_1"
+
+    const messageDir = path.join(storage.message, sessionId)
+    fs.mkdirSync(messageDir, { recursive: true })
+
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(messageDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: sessionId,
+        role: "assistant",
+        agent: "sisyphus",
+        time: { created: 1000 },
+      }),
+      "utf8"
+    )
+
+    const view = getMainSessionView({
+      projectRoot,
+      sessionId,
+      storage,
+      sessionMeta: null,
+      nowMs: 50_000,
+    })
+
+    expect(view.status).toBe("thinking")
+  })
+})

package/src/ingest/session.ts

@@ -0,0 +1,283 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { getOpenCodeStorageDir, realpathSafe } from "./paths"
+
+export type SessionMetadata = {
+  id: string
+  projectID: string
+  directory: string
+  title?: string
+  parentID?: string
+  time: { created: number; updated: number }
+}
+
+export type StoredMessageMeta = {
+  id: string
+  sessionID: string
+  role: "user" | "assistant"
+  time?: { created: number; completed?: number }
+  agent?: string
+}
+
+export type StoredToolPart = {
+  id: string
+  sessionID: string
+  messageID: string
+  type: "tool"
+  callID: string
+  tool: string
+  state: { status: "pending" | "running" | "completed" | "error"; input: Record<string, unknown> }
+}
+
+export type MainSessionView = {
+  agent: string
+  currentTool: string | null
+  lastUpdated: number | null
+  sessionLabel: string
+  status: "busy" | "idle" | "unknown" | "running_tool" | "thinking"
+}
+
+export type OpenCodeStorageRoots = {
+  session: string
+  message: string
+  part: string
+}
+
+export function getStorageRoots(storageRoot: string): OpenCodeStorageRoots {
+  return {
+    session: path.join(storageRoot, "session"),
+    message: path.join(storageRoot, "message"),
+    part: path.join(storageRoot, "part"),
+  }
+}
+
+export function defaultStorageRoots(): OpenCodeStorageRoots {
+  return getStorageRoots(getOpenCodeStorageDir())
+}
+
+export function getMessageDir(messageStorage: string, sessionID: string): string {
+  const directPath = path.join(messageStorage, sessionID)
+  if (fs.existsSync(directPath)) return directPath
+
+  try {
+    for (const dir of fs.readdirSync(messageStorage)) {
+      const sessionPath = path.join(messageStorage, dir, sessionID)
+      if (fs.existsSync(sessionPath)) return sessionPath
+    }
+  } catch {
+    return ""
+  }
+
+  return ""
+}
+
+export function sessionExists(messageStorage: string, sessionID: string): boolean {
+  return getMessageDir(messageStorage, sessionID) !== ""
+}
+
+export function readMainSessionMetas(
+  sessionStorage: string,
+  directoryFilter?: string
+): SessionMetadata[] {
+  if (!fs.existsSync(sessionStorage)) return []
+
+  const directoryNeedle = typeof directoryFilter === "string" && directoryFilter.length > 0
+    ? ((): string => {
+        const abs = path.resolve(directoryFilter)
+        const real = realpathSafe(abs) ?? abs
+        return path.normalize(real)
+      })()
+    : null
+
+  const metas: SessionMetadata[] = []
+  try {
+    const projectDirs = fs.readdirSync(sessionStorage, { withFileTypes: true })
+    for (const dirent of projectDirs) {
+      if (!dirent.isDirectory()) continue
+      const projectPath = path.join(sessionStorage, dirent.name)
+      for (const file of fs.readdirSync(projectPath)) {
+        if (!file.endsWith(".json")) continue
+        try {
+          const content = fs.readFileSync(path.join(projectPath, file), "utf8")
+          const meta = JSON.parse(content) as SessionMetadata
+          if (meta.parentID) continue
+
+          if (directoryNeedle) {
+            const metaAbs = path.resolve(meta.directory)
+            const metaReal = realpathSafe(metaAbs) ?? metaAbs
+            const metaDir = path.normalize(metaReal)
+            if (metaDir !== directoryNeedle) continue
+          }
+
+          metas.push(meta)
+        } catch {
+          continue
+        }
+      }
+    }
+  } catch {
+    return []
+  }
+
+  return metas.sort((a, b) => b.time.updated - a.time.updated)
+}
+
+export function pickActiveSessionId(opts: {
+  projectRoot: string
+  storage: OpenCodeStorageRoots
+  boulderSessionIds?: string[]
+}): string | null {
+  const ids = opts.boulderSessionIds ?? []
+  for (let i = ids.length - 1; i >= 0; i--) {
+    const id = ids[i]
+    if (sessionExists(opts.storage.message, id)) return id
+  }
+
+  const metas = readMainSessionMetas(opts.storage.session, opts.projectRoot)
+  return metas[0]?.id ?? null
+}
+
+function readMostRecentMessageMeta(messageDir: string, maxMessages: number): StoredMessageMeta | null {
+  if (!messageDir || !fs.existsSync(messageDir)) return null
+
+  const files = fs.readdirSync(messageDir).filter((f) => f.endsWith(".json"))
+  const ranked = files
+    .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)
+
+  // Deterministic: parse meta.time.created and pick the newest.
+  let best: { created: number; id: string; meta: StoredMessageMeta } | null = null
+  for (const item of ranked) {
+    try {
+      const content = fs.readFileSync(path.join(messageDir, item.f), "utf8")
+      const meta = JSON.parse(content) as StoredMessageMeta
+      const created = meta.time?.created ?? 0
+      const id = String(meta.id ?? "")
+      if (!best || created > best.created || (created === best.created && id > best.id)) {
+        best = { created, id, meta }
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return best?.meta ?? null
+}
+
+function readRecentMessageMetas(messageDir: string, maxMessages: number): StoredMessageMeta[] {
+  if (!messageDir || !fs.existsSync(messageDir)) return []
+
+  const files = fs.readdirSync(messageDir).filter((f) => f.endsWith(".json"))
+  const ranked = files
+    .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: { created: number; id: string; meta: StoredMessageMeta }[] = []
+  for (const item of ranked) {
+    try {
+      const content = fs.readFileSync(path.join(messageDir, item.f), "utf8")
+      const meta = JSON.parse(content) as StoredMessageMeta
+      const created = meta.time?.created ?? 0
+      const id = String(meta.id ?? "")
+      metas.push({ created, id, meta })
+    } catch {
+      continue
+    }
+  }
+
+  return metas
+    .sort((a, b) => {
+      if (b.created !== a.created) return b.created - a.created
+      return b.id.localeCompare(a.id)
+    })
+    .map(item => item.meta)
+}
+
+function readLastToolPart(partStorage: string, messageID: string): { tool: string; status: string } | null {
+  const partDir = path.join(partStorage, messageID)
+  if (!fs.existsSync(partDir)) return null
+
+  const files = fs.readdirSync(partDir).filter((f) => f.endsWith(".json")).sort()
+  for (let i = files.length - 1; i >= 0; i--) {
+    const file = files[i]
+    try {
+      const content = fs.readFileSync(path.join(partDir, file), "utf8")
+      const part = JSON.parse(content) as Partial<StoredToolPart>
+      if (part.type === "tool" && typeof part.tool === "string") {
+        const status = (part as StoredToolPart).state?.status
+        return { tool: part.tool, status: typeof status === "string" ? status : "unknown" }
+      }
+    } catch {
+      continue
+    }
+  }
+  return null
+}
+
+export function getMainSessionView(opts: {
+  projectRoot: string
+  sessionId: string
+  storage: OpenCodeStorageRoots
+  sessionMeta?: SessionMetadata | null
+  nowMs?: number
+}): MainSessionView {
+  const nowMs = opts.nowMs ?? Date.now()
+
+  const messageDir = getMessageDir(opts.storage.message, opts.sessionId)
+  const recent = readMostRecentMessageMeta(messageDir, 200)
+
+  const lastUpdated = recent?.time?.created ?? null
+  const sessionLabel = opts.sessionMeta?.title ?? opts.sessionId
+  const agent = recent?.agent ?? "unknown"
+
+  // Scan recent messages for any in-flight tool parts
+  let activeTool: { tool: string; status: string } | null = null
+  const recentMetas = readRecentMessageMetas(messageDir, 200)
+  
+  // Iterate newest → oldest, early-exit on first tool part with pending/running status
+  for (const meta of recentMetas) {
+    const toolPart = readLastToolPart(opts.storage.part, meta.id)
+    if (toolPart && (toolPart.status === "pending" || toolPart.status === "running")) {
+      activeTool = toolPart
+      break
+    }
+  }
+
+  let status: MainSessionView["status"] = "unknown"
+  if (activeTool?.status === "pending" || activeTool?.status === "running") {
+    status = "running_tool"
+  } else if (recent?.role === "assistant" && typeof recent?.time?.created === "number" && typeof recent?.time?.completed !== "number") {
+    status = "thinking"
+  } else if (typeof lastUpdated === "number") {
+    // Use freshness window fallback exactly as today ONLY when no active tool is found
+    status = nowMs - lastUpdated <= 15_000 ? "busy" : "idle"
+  }
+
+  return {
+    agent,
+    currentTool: activeTool?.tool ?? null,
+    lastUpdated,
+    sessionLabel,
+    status,
+  }
+}

package/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from "react";
+import ReactDOM from "react-dom/client";
+import App from "./App";
+import "./styles.css";
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);

package/src/server/api.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "vitest"
+import { createApi } from "./api"
+
+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: [],
+        raw: null,
+      }),
+    })
+
+    const res = await api.request("/health")
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ ok: true })
+  })
+
+  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: "" }],
+        raw: { ok: true },
+      }),
+    })
+
+    const res = await api.request("/dashboard")
+    expect(res.status).toBe(200)
+    
+    const data = await res.json()
+    
+    expect(data).toHaveProperty("mainSession")
+    expect(data).toHaveProperty("planProgress")
+    expect(data).toHaveProperty("backgroundTasks")
+    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)
+  })
+})

package/src/server/api.ts

@@ -0,0 +1,16 @@
+import { Hono } from "hono"
+import type { DashboardStore } from "./dashboard"
+
+export function createApi(store: DashboardStore): Hono {
+  const api = new Hono()
+
+  api.get("/health", (c) => {
+    return c.json({ ok: true })
+  })
+
+  api.get("/dashboard", (c) => {
+    return c.json(store.getSnapshot())
+  })
+
+  return api
+}

package/src/server/build.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+
+console.log("API build complete (no-op)")
+
+process.exit(0)