oh-my-opencode-dashboard 0.0.1

package/src/ingest/background-tasks.ts

@@ -0,0 +1,317 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import type { OpenCodeStorageRoots, SessionMetadata, StoredMessageMeta, StoredToolPart } from "./session"
+import { getMessageDir } from "./session"
+
+export type BackgroundTaskRow = {
+  id: string
+  description: string
+  agent: string
+  status: "queued" | "running" | "completed" | "error" | "unknown"
+  toolCalls: number | null
+  lastTool: string | null
+  timeline: string
+  sessionId: string | null
+}
+
+const DESCRIPTION_MAX = 120
+const AGENT_MAX = 30
+
+function clampString(value: unknown, maxLen: number): string | null {
+  if (typeof value !== "string") return null
+  const s = value.trim()
+  if (!s) return null
+  return s.length <= maxLen ? s : s.slice(0, maxLen)
+}
+
+function readJsonFile<T>(filePath: string): T | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf8")
+    return JSON.parse(content) as T
+  } catch {
+    return null
+  }
+}
+
+function listJsonFiles(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir).filter((f) => f.endsWith(".json"))
+  } catch {
+    return []
+  }
+}
+
+function readToolPartsForMessage(storage: OpenCodeStorageRoots, messageID: string): StoredToolPart[] {
+  const partDir = path.join(storage.part, messageID)
+  if (!fs.existsSync(partDir)) return []
+
+  const files = listJsonFiles(partDir).sort()
+  const parts: StoredToolPart[] = []
+  for (const f of files) {
+    const p = readJsonFile<StoredToolPart>(path.join(partDir, f))
+    if (p && p.type === "tool" && typeof p.tool === "string" && p.state && typeof p.state === "object") {
+      parts.push(p)
+    }
+  }
+  return parts
+}
+
+function readRecentMessageMetas(messageDir: string, maxMessages: number): StoredMessageMeta[] {
+  if (!messageDir || !fs.existsSync(messageDir)) return []
+  const files = 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 files) {
+    const meta = readJsonFile<StoredMessageMeta>(path.join(messageDir, item.f))
+    if (meta && typeof meta.id === "string") metas.push(meta)
+  }
+  return metas
+}
+
+export function readAllSessionMetas(sessionStorage: string): SessionMetadata[] {
+  if (!fs.existsSync(sessionStorage)) return []
+  const metas: SessionMetadata[] = []
+  try {
+    const projectDirs = fs.readdirSync(sessionStorage, { withFileTypes: true })
+    for (const d of projectDirs) {
+      if (!d.isDirectory()) continue
+      const projectPath = path.join(sessionStorage, d.name)
+      for (const file of listJsonFiles(projectPath)) {
+        const meta = readJsonFile<SessionMetadata>(path.join(projectPath, file))
+        if (meta && typeof meta.id === "string") metas.push(meta)
+      }
+    }
+  } catch {
+    return []
+  }
+  return metas
+}
+
+function findBackgroundSessionId(opts: {
+  allSessionMetas: SessionMetadata[]
+  parentSessionId: string
+  description: string
+  startedAt: number
+}): string | null {
+  const title = `Background: ${opts.description}`
+  const windowStart = opts.startedAt
+  const windowEnd = opts.startedAt + 60_000
+
+  const candidates = opts.allSessionMetas.filter(
+    (m) =>
+      m.parentID === opts.parentSessionId &&
+      m.title === title &&
+      m.time?.created >= windowStart &&
+      m.time?.created <= windowEnd
+  )
+  // Deterministic tie-breaking: max by time.created, then lexicographic id
+  candidates.sort((a, b) => {
+    const at = a.time?.created ?? 0
+    const bt = b.time?.created ?? 0
+    if (at !== bt) return bt - at
+    return String(a.id).localeCompare(String(b.id))
+  })
+  return candidates[0]?.id ?? null
+}
+
+function findTaskSessionId(opts: {
+  allSessionMetas: SessionMetadata[]
+  parentSessionId: string
+  description: string
+  startedAt: number
+}): string | null {
+  const title = `Task: ${opts.description}`
+  const windowStart = opts.startedAt
+  const windowEnd = opts.startedAt + 60_000
+
+  const candidates = opts.allSessionMetas.filter(
+    (m) =>
+      m.parentID === opts.parentSessionId &&
+      m.title === title &&
+      m.time?.created >= windowStart &&
+      m.time?.created <= windowEnd
+  )
+  candidates.sort((a, b) => {
+    const at = a.time?.created ?? 0
+    const bt = b.time?.created ?? 0
+    if (at !== bt) return bt - at
+    return String(a.id).localeCompare(String(b.id))
+  })
+  return candidates[0]?.id ?? null
+}
+
+function deriveBackgroundSessionStats(storage: OpenCodeStorageRoots, sessionId: string): { toolCalls: number; lastTool: string | null; lastUpdateAt: number | null } {
+  const messageDir = getMessageDir(storage.message, sessionId)
+  const metas = readRecentMessageMetas(messageDir, 200)
+  let toolCalls = 0
+  let lastTool: string | null = null
+  let lastUpdateAt: number | null = null
+
+  // Deterministic ordering by time.created then id.
+  const ordered = [...metas].sort((a, b) => {
+    const at = a.time?.created ?? 0
+    const bt = b.time?.created ?? 0
+    if (at !== bt) return at - bt
+    return String(a.id).localeCompare(String(b.id))
+  })
+
+  for (const meta of ordered) {
+    const created = meta.time?.created
+    if (typeof created === "number") lastUpdateAt = created
+    const parts = readToolPartsForMessage(storage, meta.id)
+    for (const p of parts) {
+      toolCalls += 1
+      lastTool = p.tool
+    }
+  }
+
+  return { toolCalls, lastTool, lastUpdateAt }
+}
+
+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 deriveBackgroundTasks(opts: {
+  storage: OpenCodeStorageRoots
+  mainSessionId: string
+  nowMs?: number
+}): BackgroundTaskRow[] {
+  const nowMs = opts.nowMs ?? Date.now()
+  const messageDir = getMessageDir(opts.storage.message, opts.mainSessionId)
+  const metas = readRecentMessageMetas(messageDir, 200)
+  const allSessionMetas = readAllSessionMetas(opts.storage.session)
+
+  const rows: BackgroundTaskRow[] = []
+
+  // Iterate newest-first to cap list and keep latest tasks.
+  const ordered = [...metas].sort((a, b) => (b.time?.created ?? 0) - (a.time?.created ?? 0))
+  for (const meta of ordered) {
+    const startedAt = meta.time?.created ?? null
+    if (typeof startedAt !== "number") continue
+
+    const parts = readToolPartsForMessage(opts.storage, meta.id)
+    for (const part of parts) {
+      if (part.tool !== "delegate_task") continue
+      if (!part.state || typeof part.state !== "object") continue
+
+      const input = part.state.input ?? {}
+      if (typeof input !== "object" || input === null) continue
+
+      const runInBackground = (input as Record<string, unknown>).run_in_background
+      if (runInBackground !== true && runInBackground !== false) continue
+
+      const description = clampString((input as Record<string, unknown>).description, DESCRIPTION_MAX)
+      if (!description) continue
+
+      const subagentType = clampString((input as Record<string, unknown>).subagent_type, AGENT_MAX)
+      const category = clampString((input as Record<string, unknown>).category, AGENT_MAX)
+      const agent = subagentType ?? (category ? `sisyphus-junior (${category})` : "unknown")
+
+      let backgroundSessionId: string | null = null
+      
+      if (runInBackground) {
+        backgroundSessionId = findBackgroundSessionId({
+          allSessionMetas,
+          parentSessionId: opts.mainSessionId,
+          description,
+          startedAt,
+        })
+      } else {
+        // For sync tasks, check if resume is specified
+        const resume = (input as Record<string, unknown>).resume
+        if (typeof resume === "string" && resume.trim() !== "") {
+          // Check if resumed session exists (has readable messages dir)
+          const resumeMessageDir = getMessageDir(opts.storage.message, resume.trim())
+          if (fs.existsSync(resumeMessageDir) && fs.readdirSync(resumeMessageDir).length > 0) {
+            backgroundSessionId = resume.trim()
+          }
+        }
+        
+        if (!backgroundSessionId) {
+          backgroundSessionId = findBackgroundSessionId({
+            allSessionMetas,
+            parentSessionId: opts.mainSessionId,
+            description,
+            startedAt,
+          })
+          
+          if (!backgroundSessionId) {
+            backgroundSessionId = findTaskSessionId({
+              allSessionMetas,
+              parentSessionId: opts.mainSessionId,
+              description,
+              startedAt,
+            })
+          }
+        }
+      }
+
+      const stats = backgroundSessionId
+        ? deriveBackgroundSessionStats(opts.storage, backgroundSessionId)
+        : { toolCalls: 0, lastTool: null, lastUpdateAt: startedAt }
+
+      // Best-effort status: if background session exists and has any tool calls, treat as running unless idle.
+      let status: BackgroundTaskRow["status"] = "unknown"
+      if (!backgroundSessionId) {
+        status = "queued"
+      } else if (stats.lastUpdateAt && nowMs - stats.lastUpdateAt <= 15_000) {
+        status = "running"
+      } else if (stats.toolCalls > 0) {
+        status = "completed"
+      }
+
+      const timelineEndMs = status === "completed" ? (stats.lastUpdateAt ?? nowMs) : nowMs
+
+      rows.push({
+        id: part.callID,
+        description,
+        agent,
+        status,
+        toolCalls: backgroundSessionId ? stats.toolCalls : null,
+        lastTool: stats.lastTool,
+        timeline: formatTimeline(startedAt, timelineEndMs),
+        sessionId: backgroundSessionId,
+      })
+    }
+
+    if (rows.length >= 50) break
+  }
+
+  return rows
+}

package/src/ingest/boulder.test.ts

@@ -0,0 +1,77 @@
+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 { readBoulderState, readPlanProgress } from "./boulder"
+
+function mkProjectRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+  fs.mkdirSync(path.join(root, ".sisyphus"), { recursive: true })
+  return root
+}
+
+describe("readBoulderState", () => {
+  it("returns null if boulder.json is missing", () => {
+    const projectRoot = mkProjectRoot()
+    expect(readBoulderState(projectRoot)).toBe(null)
+  })
+
+  it("returns null if boulder.json is invalid JSON", () => {
+    const projectRoot = mkProjectRoot()
+    fs.writeFileSync(path.join(projectRoot, ".sisyphus", "boulder.json"), "{nope", "utf8")
+    expect(readBoulderState(projectRoot)).toBe(null)
+  })
+})
+
+describe("readPlanProgress", () => {
+  it("computes checkbox progress for an existing plan", () => {
+    const projectRoot = mkProjectRoot()
+    const planPath = path.join(projectRoot, ".sisyphus", "plans", "plan.md")
+    fs.mkdirSync(path.dirname(planPath), { recursive: true })
+    fs.writeFileSync(
+      planPath,
+      ["- [ ] Task 1", "- [x] Task 2", "- [X] Task 3"].join("\n"),
+      "utf8"
+    )
+
+    const progress = readPlanProgress(projectRoot, planPath)
+    expect(progress.missing).toBe(false)
+    expect(progress.total).toBe(3)
+    expect(progress.completed).toBe(2)
+    expect(progress.isComplete).toBe(false)
+  })
+
+  it("treats missing plan file as not started", () => {
+    const projectRoot = mkProjectRoot()
+    const planPath = path.join(projectRoot, ".sisyphus", "plans", "missing.md")
+    const progress = readPlanProgress(projectRoot, planPath)
+    expect(progress.missing).toBe(true)
+    expect(progress.total).toBe(0)
+    expect(progress.completed).toBe(0)
+    expect(progress.isComplete).toBe(false)
+  })
+
+  it("treats a plan with zero checkboxes as complete", () => {
+    const projectRoot = mkProjectRoot()
+    const planPath = path.join(projectRoot, ".sisyphus", "plans", "empty.md")
+    fs.mkdirSync(path.dirname(planPath), { recursive: true })
+    fs.writeFileSync(planPath, "# No tasks\nJust text", "utf8")
+
+    const progress = readPlanProgress(projectRoot, planPath)
+    expect(progress.missing).toBe(false)
+    expect(progress.total).toBe(0)
+    expect(progress.completed).toBe(0)
+    expect(progress.isComplete).toBe(true)
+  })
+
+  it("rejects active_plan paths outside projectRoot", () => {
+    const projectRoot = mkProjectRoot()
+    const outside = fs.mkdtempSync(path.join(os.tmpdir(), "omo-outside-"))
+    const outsidePlan = path.join(outside, "plan.md")
+    fs.writeFileSync(outsidePlan, "- [x] outside", "utf8")
+
+    const progress = readPlanProgress(projectRoot, outsidePlan)
+    expect(progress.missing).toBe(true)
+    expect(progress.isComplete).toBe(false)
+  })
+})

package/src/ingest/boulder.ts

@@ -0,0 +1,71 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { assertAllowedPath } from "./paths"
+
+export type BoulderState = {
+  active_plan: string
+  started_at: string
+  session_ids: string[]
+  plan_name: string
+}
+
+export type PlanProgress = {
+  total: number
+  completed: number
+  isComplete: boolean
+  missing: boolean
+}
+
+export function readBoulderState(projectRoot: string): BoulderState | null {
+  const filePath = assertAllowedPath({
+    candidatePath: path.join(projectRoot, ".sisyphus", "boulder.json"),
+    allowedRoots: [projectRoot],
+  })
+
+  if (!fs.existsSync(filePath)) return null
+
+  try {
+    const content = fs.readFileSync(filePath, "utf8")
+    return JSON.parse(content) as BoulderState
+  } catch {
+    return null
+  }
+}
+
+export function getPlanProgressFromMarkdown(content: string): Omit<PlanProgress, "missing"> {
+  const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || []
+  const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || []
+
+  const total = uncheckedMatches.length + checkedMatches.length
+  const completed = checkedMatches.length
+
+  return {
+    total,
+    completed,
+    isComplete: total === 0 || completed === total,
+  }
+}
+
+export function readPlanProgress(projectRoot: string, planPath: string): PlanProgress {
+  let planReal: string
+  try {
+    planReal = assertAllowedPath({
+      candidatePath: planPath,
+      allowedRoots: [projectRoot],
+    })
+  } catch {
+    return { total: 0, completed: 0, isComplete: false, missing: true }
+  }
+
+  if (!fs.existsSync(planReal)) {
+    return { total: 0, completed: 0, isComplete: false, missing: true }
+  }
+
+  try {
+    const content = fs.readFileSync(planReal, "utf8")
+    const progress = getPlanProgressFromMarkdown(content)
+    return { ...progress, missing: false }
+  } catch {
+    return { total: 0, completed: 0, isComplete: false, missing: true }
+  }
+}

package/src/ingest/paths.test.ts

@@ -0,0 +1,82 @@
+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 { assertAllowedPath, getOpenCodeStorageDir } from "./paths"
+
+describe("getOpenCodeStorageDir", () => {
+  it("uses XDG_DATA_HOME when set", () => {
+    const got = getOpenCodeStorageDir({ XDG_DATA_HOME: "/tmp/xdg" }, "/home/test")
+    expect(got).toBe("/tmp/xdg/opencode/storage")
+  })
+
+  it("falls back to ~/.local/share when XDG_DATA_HOME is unset", () => {
+    const got = getOpenCodeStorageDir({}, "/home/test")
+    expect(got).toBe("/home/test/.local/share/opencode/storage")
+  })
+})
+
+describe("assertAllowedPath", () => {
+  it("allows paths inside allowed roots", () => {
+    const base = fs.mkdtempSync(path.join(os.tmpdir(), "omo-dashboard-"))
+    const allowed = path.join(base, "allowed")
+    fs.mkdirSync(allowed, { recursive: true })
+
+    const resolved = assertAllowedPath({
+      candidatePath: path.join(allowed, "file.txt"),
+      allowedRoots: [allowed],
+    })
+
+    expect(resolved).toContain("/allowed/")
+  })
+
+  it("rejects traversal outside allowed root", () => {
+    const base = fs.mkdtempSync(path.join(os.tmpdir(), "omo-dashboard-"))
+    const allowed = path.join(base, "allowed")
+    fs.mkdirSync(allowed, { recursive: true })
+    const outside = path.join(base, "outside.txt")
+
+    expect(() =>
+      assertAllowedPath({
+        candidatePath: outside,
+        allowedRoots: [allowed],
+      })
+    ).toThrow("Access denied")
+  })
+
+  it("rejects symlink escapes", () => {
+    const base = fs.mkdtempSync(path.join(os.tmpdir(), "omo-dashboard-"))
+    const allowed = path.join(base, "allowed")
+    const outsideDir = path.join(base, "outside")
+    fs.mkdirSync(allowed, { recursive: true })
+    fs.mkdirSync(outsideDir, { recursive: true })
+
+    const outsideFile = path.join(outsideDir, "secret.txt")
+    fs.writeFileSync(outsideFile, "nope", "utf8")
+
+    const linkPath = path.join(allowed, "link.txt")
+    fs.symlinkSync(outsideFile, linkPath)
+
+    expect(() =>
+      assertAllowedPath({
+        candidatePath: linkPath,
+        allowedRoots: [allowed],
+      })
+    ).toThrow("Access denied")
+  })
+
+  it("allows a non-existent file path if its nearest existing parent is inside", () => {
+    const base = fs.mkdtempSync(path.join(os.tmpdir(), "omo-dashboard-"))
+    const allowed = path.join(base, "allowed")
+    fs.mkdirSync(allowed, { recursive: true })
+
+    const candidate = path.join(allowed, "missing", "file.txt")
+    const resolved = assertAllowedPath({
+      candidatePath: candidate,
+      allowedRoots: [allowed],
+    })
+
+    expect(resolved).toContain("/allowed/")
+    expect(resolved.endsWith(path.join("missing", "file.txt"))).toBe(true)
+  })
+})

package/src/ingest/paths.ts

@@ -0,0 +1,76 @@
+import * as fs from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
+
+export type Env = Record<string, string | undefined>
+
+export function getDataDir(env: Env = process.env, homedir: string = os.homedir()): string {
+  // Match oh-my-opencode behavior exactly:
+  // XDG_DATA_HOME or ~/.local/share on all platforms.
+  return env.XDG_DATA_HOME ?? path.join(homedir, ".local", "share")
+}
+
+export function getOpenCodeStorageDir(env: Env = process.env, homedir: string = os.homedir()): string {
+  return path.join(getDataDir(env, homedir), "opencode", "storage")
+}
+
+export function realpathSafe(p: string): string | null {
+  try {
+    return fs.realpathSync(p)
+  } catch {
+    return null
+  }
+}
+
+export function isPathInside(rootReal: string, candidateReal: string): boolean {
+  const rel = path.relative(rootReal, candidateReal)
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel))
+}
+
+function resolveCandidateReal(candidateAbs: string): string | null {
+  const existing = realpathSafe(candidateAbs)
+  if (existing) return existing
+
+  // If the target doesn't exist, resolve the nearest existing parent and
+  // re-append the relative suffix.
+  let cur = candidateAbs
+  let prev = ""
+  while (cur !== prev) {
+    if (fs.existsSync(cur)) {
+      const parentReal = realpathSafe(cur)
+      if (!parentReal) return null
+      const suffix = path.relative(cur, candidateAbs)
+      return suffix ? path.join(parentReal, suffix) : parentReal
+    }
+    prev = cur
+    cur = path.dirname(cur)
+  }
+
+  return null
+}
+
+export type AssertAllowedPathOptions = {
+  candidatePath: string
+  allowedRoots: string[]
+  baseDir?: string
+}
+
+export function assertAllowedPath(opts: AssertAllowedPathOptions): string {
+  const baseDir = opts.baseDir ?? process.cwd()
+  const candidateAbs = path.resolve(baseDir, opts.candidatePath)
+
+  const candidateReal = resolveCandidateReal(candidateAbs)
+  if (!candidateReal) {
+    throw new Error("Access denied")
+  }
+
+  for (const root of opts.allowedRoots) {
+    const rootAbs = path.resolve(baseDir, root)
+    const rootReal = resolveCandidateReal(rootAbs) ?? rootAbs
+    if (isPathInside(rootReal, candidateReal)) {
+      return candidateReal
+    }
+  }
+
+  throw new Error("Access denied")
+}