oh-my-opencode-dashboard 0.0.3 → 0.0.5

package/src/app-payload.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect } from "vitest"
+import { toDashboardPayload } from "./App"
+
+describe('toDashboardPayload', () => {
+  it('should preserve planProgress.steps from server JSON', () => {
+    // #given: server JSON with planProgress.steps
+    const serverJson = {
+      mainSession: {
+        agent: "sisyphus",
+        currentTool: "dashboard_start",
+        currentModel: "anthropic/claude-opus-4-5",
+        lastUpdatedLabel: "just now",
+        session: "test-session",
+        statusPill: "busy",
+      },
+      planProgress: {
+        name: "test-plan",
+        completed: 2,
+        total: 4,
+        path: "/tmp/test-plan.md",
+        statusPill: "in progress",
+        steps: [
+          { checked: true, text: "First completed task" },
+          { checked: true, text: "Second completed task" },
+          { checked: false, text: "Third pending task" },
+          { checked: false, text: "Fourth pending task" },
+        ],
+      },
+      backgroundTasks: [],
+      timeSeries: {
+        windowMs: 300000,
+        buckets: 150,
+        bucketMs: 2000,
+        anchorMs: 1640995200000,
+        serverNowMs: 1640995500000,
+        series: [
+          {
+            id: "overall-main",
+            label: "Overall",
+            tone: "muted",
+            values: new Array(150).fill(0),
+          },
+        ],
+      },
+    }
+
+    // #when: converting to dashboard payload
+    const payload = toDashboardPayload(serverJson)
+
+    // #then: planProgress.steps should be preserved with correct structure
+    expect(payload.planProgress.steps).toBeDefined()
+    expect(payload.planProgress.steps).toEqual([
+      { checked: true, text: "First completed task" },
+      { checked: true, text: "Second completed task" },
+      { checked: false, text: "Third pending task" },
+      { checked: false, text: "Fourth pending task" },
+    ])
+  })
+
+  it('should handle missing or malformed planProgress.steps defensively', () => {
+    // #given: server JSON with malformed planProgress.steps
+    const serverJson = {
+      mainSession: {
+        agent: "sisyphus",
+        currentTool: "dashboard_start",
+        currentModel: "anthropic/claude-opus-4-5",
+        lastUpdatedLabel: "just now",
+        session: "test-session",
+        statusPill: "busy",
+      },
+      planProgress: {
+        name: "test-plan",
+        completed: 0,
+        total: 0,
+        path: "/tmp/test-plan.md",
+        statusPill: "not started",
+        steps: [
+          { checked: true, text: "Valid step" },
+          { checked: false }, // missing text
+          { text: "Missing checked" }, // missing checked
+          "invalid string", // wrong type
+          null, // null value
+          { checked: "not-boolean", text: "Invalid checked type" }, // wrong checked type
+        ],
+      },
+      backgroundTasks: [],
+      timeSeries: {
+        windowMs: 300000,
+        buckets: 150,
+        bucketMs: 2000,
+        anchorMs: 1640995200000,
+        serverNowMs: 1640995500000,
+        series: [
+          {
+            id: "overall-main",
+            label: "Overall",
+            tone: "muted",
+            values: new Array(150).fill(0),
+          },
+        ],
+      },
+    }
+
+    // #when: converting to dashboard payload
+    const payload = toDashboardPayload(serverJson)
+
+    // #then: should only include valid steps, ignore malformed ones
+    expect(payload.planProgress.steps).toEqual([
+      { checked: true, text: "Valid step" },
+      { checked: false, text: "Missing checked" }, // default checked to false
+      { checked: false, text: "Invalid checked type" }, // default checked to false for invalid boolean
+    ])
+  })
+
+  it('should handle non-array planProgress.steps', () => {
+    // #given: server JSON with non-array planProgress.steps
+    const serverJson = {
+      mainSession: {
+        agent: "sisyphus",
+        currentTool: "dashboard_start",
+        currentModel: "anthropic/claude-opus-4-5",
+        lastUpdatedLabel: "just now",
+        session: "test-session",
+        statusPill: "busy",
+      },
+      planProgress: {
+        name: "test-plan",
+        completed: 0,
+        total: 0,
+        path: "/tmp/test-plan.md",
+        statusPill: "not started",
+        steps: "not an array",
+      },
+      backgroundTasks: [],
+      timeSeries: {
+        windowMs: 300000,
+        buckets: 150,
+        bucketMs: 2000,
+        anchorMs: 1640995200000,
+        serverNowMs: 1640995500000,
+        series: [
+          {
+            id: "overall-main",
+            label: "Overall",
+            tone: "muted",
+            values: new Array(150).fill(0),
+          },
+        ],
+      },
+    }
+
+    // #when: converting to dashboard payload
+    const payload = toDashboardPayload(serverJson)
+
+    // #then: should handle non-array steps gracefully
+    expect(payload.planProgress.steps).toEqual([])
+  })
+})

package/src/background-task-timeline.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest"
+import { formatBackgroundTaskTimelineCell } from "./App"
+
+describe('formatBackgroundTaskTimelineCell', () => {
+  it('should render "-" for queued regardless of timeline', () => {
+    // #given: queued status
+    const status = "queued"
+
+    // #when/#then
+    expect(formatBackgroundTaskTimelineCell(status, "")).toBe("-")
+    expect(formatBackgroundTaskTimelineCell(status, "2026-01-01T00:00:00Z: 2m")).toBe("-")
+  })
+
+  it('should render blank for unknown regardless of timeline', () => {
+    // #given: unknown status
+    const status = "unknown"
+
+    // #when/#then
+    expect(formatBackgroundTaskTimelineCell(status, "")).toBe("")
+    expect(formatBackgroundTaskTimelineCell(status, "2026-01-01T00:00:00Z: 2m")).toBe("")
+  })
+
+  it('should render timeline when present, otherwise "-" for other statuses', () => {
+    // #given: a non-queued, non-unknown status
+    const status = "running"
+
+    // #when/#then
+    expect(formatBackgroundTaskTimelineCell(status, "2026-01-01T00:00:00Z: 2m")).toBe("2026-01-01T00:00:00Z: 2m")
+    expect(formatBackgroundTaskTimelineCell(status, "")).toBe("-")
+    expect(formatBackgroundTaskTimelineCell(status, "   ")).toBe("-")
+  })
+})

package/src/background-task-toolcalls-policy.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect } from "vitest"
+import { computeToolCallsFetchPlan, toggleIdInSet } from "./App"
+
+describe('computeToolCallsFetchPlan', () => {
+  it('should not fetch when sessionId is missing', () => {
+    // #given: no sessionId
+    const params = {
+      sessionId: null,
+      status: "running",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(false)
+    expect(result.force).toBe(false)
+  })
+
+  it('should not fetch when not expanded', () => {
+    // #given: expanded is false
+    const params = {
+      sessionId: "session-123",
+      status: "done",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: false
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(false)
+    expect(result.force).toBe(false)
+  })
+
+  it('should force fetch when status is "running" and expanded', () => {
+    // #given: running status
+    const params = {
+      sessionId: "session-123",
+      status: "running",
+      cachedState: "ok" as const,
+      cachedDataOk: true,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(true)
+    expect(result.force).toBe(true)
+  })
+
+  it('should not fetch when non-running status and cached data is ok', () => {
+    // #given: done status with good cache
+    const params = {
+      sessionId: "session-123",
+      status: "done",
+      cachedState: "ok" as const,
+      cachedDataOk: true,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(false)
+    expect(result.force).toBe(false)
+  })
+
+  it('should not fetch when already loading', () => {
+    // #given: loading state
+    const params = {
+      sessionId: "session-123",
+      status: "done",
+      cachedState: "loading" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(false)
+    expect(result.force).toBe(false)
+  })
+
+  it('should fetch when non-running, not cached, not loading, and expanded', () => {
+    // #given: done status with no cache
+    const params = {
+      sessionId: "session-123",
+      status: "done",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(true)
+    expect(result.force).toBe(false)
+  })
+
+  it('should handle case-insensitive status values', () => {
+    // #given: RUNNING in uppercase
+    const params = {
+      sessionId: "session-123",
+      status: "RUNNING",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(true)
+    expect(result.force).toBe(true)
+  })
+
+  it('should handle whitespace in status values', () => {
+    // #given: running with whitespace
+    const params = {
+      sessionId: "session-123",
+      status: "  running  ",
+      cachedState: "idle" as const,
+      cachedDataOk: false,
+      isExpanded: true
+    }
+
+    // #when
+    const result = computeToolCallsFetchPlan(params)
+
+    // #then
+    expect(result.shouldFetch).toBe(true)
+    expect(result.force).toBe(true)
+  })
+})
+
+describe('toggleIdInSet', () => {
+  it('should add id when not present in set', () => {
+    // #given: empty set
+    const currentSet = new Set<string>()
+
+    // #when
+    const result = toggleIdInSet("task-1", currentSet)
+
+    // #then
+    expect(result.has("task-1")).toBe(true)
+    expect(result.size).toBe(1)
+  })
+
+  it('should remove id when already present in set', () => {
+    // #given: set with id already present
+    const currentSet = new Set(["task-1", "task-2"])
+
+    // #when
+    const result = toggleIdInSet("task-1", currentSet)
+
+    // #then
+    expect(result.has("task-1")).toBe(false)
+    expect(result.has("task-2")).toBe(true)
+    expect(result.size).toBe(1)
+  })
+
+  it('should not modify original set', () => {
+    // #given: original set
+    const originalSet = new Set(["task-1"])
+
+    // #when
+    const result = toggleIdInSet("task-2", originalSet)
+
+    // #then
+    expect(originalSet.has("task-1")).toBe(true)
+    expect(originalSet.has("task-2")).toBe(false)
+    expect(originalSet.size).toBe(1)
+    expect(result.has("task-1")).toBe(true)
+    expect(result.has("task-2")).toBe(true)
+    expect(result.size).toBe(2)
+  })
+})

package/src/ingest/background-tasks.test.ts

@@ -1,7 +1,7 @@
-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 * as fs from "node:fs"
+import { describe, expect, it, vi } from "vitest"
 import { deriveBackgroundTasks } from "./background-tasks"
 import { getStorageRoots } from "./session"
 
@@ -602,6 +602,7 @@ describe("deriveBackgroundTasks", () => {
     expect(rows[0].toolCalls).toBe(0) // No tool calls in fallback session
     expect(rows[0].lastTool).toBe(null)
     expect(rows[0].status).toBe("unknown") // Should be unknown since session exists but no tool calls
+    expect(rows[0].timeline).toBe("") // Unknown status should emit no timeline
   })
 
   it("links sync delegate_task rows to Background sessions when forced-to-background but waited", () => {
@@ -704,4 +705,305 @@ describe("deriveBackgroundTasks", () => {
     expect((rows[0] as unknown as Record<string, unknown>).input).toBeUndefined()
     expect((rows[0] as unknown as Record<string, unknown>).state).toBeUndefined()
   })
+
+  it("derives lastModel from background session assistant metas", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const mainSessionId = "ses_main"
+
+    const msgDir = path.join(storage.message, mainSessionId)
+    fs.mkdirSync(msgDir, { recursive: true })
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(msgDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: mainSessionId,
+        role: "assistant",
+        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: mainSessionId,
+        messageID,
+        type: "tool",
+        callID: "call_1",
+        tool: "delegate_task",
+        state: {
+          status: "completed",
+          input: {
+            run_in_background: true,
+            description: "Model scan",
+            subagent_type: "explore",
+          },
+        },
+      }),
+      "utf8"
+    )
+
+    const projectID = "proj"
+    const sessDir = path.join(storage.session, projectID)
+    fs.mkdirSync(sessDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(sessDir, "ses_child.json"),
+      JSON.stringify({
+        id: "ses_child",
+        projectID,
+        directory: "/tmp/project",
+        title: "Background: Model scan",
+        parentID: mainSessionId,
+        time: { created: 1500, updated: 1500 },
+      }),
+      "utf8"
+    )
+
+    const childMsgDir = path.join(storage.message, "ses_child")
+    fs.mkdirSync(childMsgDir, { recursive: true })
+    const childMsgId = "msg_child"
+    fs.writeFileSync(
+      path.join(childMsgDir, `${childMsgId}.json`),
+      JSON.stringify({
+        id: childMsgId,
+        sessionID: "ses_child",
+        role: "assistant",
+        time: { created: 2000 },
+        providerID: "openai",
+        modelID: "gpt-5.2",
+      }),
+      "utf8"
+    )
+
+    // #when
+    const rows = deriveBackgroundTasks({ storage, mainSessionId })
+
+    // #then
+    expect(rows.length).toBe(1)
+    expect(rows[0].lastModel).toBe("openai/gpt-5.2")
+  })
+
+  it("orders lastModel by time.created over file mtime", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const mainSessionId = "ses_main"
+
+    const msgDir = path.join(storage.message, mainSessionId)
+    fs.mkdirSync(msgDir, { recursive: true })
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(msgDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: mainSessionId,
+        role: "assistant",
+        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: mainSessionId,
+        messageID,
+        type: "tool",
+        callID: "call_1",
+        tool: "delegate_task",
+        state: {
+          status: "completed",
+          input: {
+            run_in_background: true,
+            description: "Ordering scan",
+            subagent_type: "explore",
+          },
+        },
+      }),
+      "utf8"
+    )
+
+    const projectID = "proj"
+    const sessDir = path.join(storage.session, projectID)
+    fs.mkdirSync(sessDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(sessDir, "ses_child.json"),
+      JSON.stringify({
+        id: "ses_child",
+        projectID,
+        directory: "/tmp/project",
+        title: "Background: Ordering scan",
+        parentID: mainSessionId,
+        time: { created: 1500, updated: 1500 },
+      }),
+      "utf8"
+    )
+
+    const childMsgDir = path.join(storage.message, "ses_child")
+    fs.mkdirSync(childMsgDir, { recursive: true })
+    const olderMsgId = "msg_older"
+    const newerMsgId = "msg_newer"
+
+    fs.writeFileSync(
+      path.join(childMsgDir, `${newerMsgId}.json`),
+      JSON.stringify({
+        id: newerMsgId,
+        sessionID: "ses_child",
+        role: "assistant",
+        time: { created: 3000 },
+        providerID: "openai",
+        modelID: "gpt-newer",
+      }),
+      "utf8"
+    )
+    fs.writeFileSync(
+      path.join(childMsgDir, `${olderMsgId}.json`),
+      JSON.stringify({
+        id: olderMsgId,
+        sessionID: "ses_child",
+        role: "assistant",
+        time: { created: 1000 },
+        providerID: "openai",
+        modelID: "gpt-older",
+      }),
+      "utf8"
+    )
+
+    // #when
+    const rows = deriveBackgroundTasks({ storage, mainSessionId })
+
+    // #then
+    expect(rows.length).toBe(1)
+    expect(rows[0].lastModel).toBe("openai/gpt-newer")
+  })
+
+  it("memoizes background session reads for shared sessionId", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const mainSessionId = "ses_main"
+    
+    // Clear any previous mock state
+    vi.clearAllMocks()
+
+    const msgDir = path.join(storage.message, mainSessionId)
+    fs.mkdirSync(msgDir, { recursive: true })
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(msgDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: mainSessionId,
+        role: "assistant",
+        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: mainSessionId,
+        messageID,
+        type: "tool",
+        callID: "call_1",
+        tool: "delegate_task",
+        state: {
+          status: "completed",
+          input: {
+            run_in_background: true,
+            description: "Memo scan",
+            subagent_type: "explore",
+          },
+        },
+      }),
+      "utf8"
+    )
+    fs.writeFileSync(
+      path.join(partDir, "part_2.json"),
+      JSON.stringify({
+        id: "part_2",
+        sessionID: mainSessionId,
+        messageID,
+        type: "tool",
+        callID: "call_2",
+        tool: "delegate_task",
+        state: {
+          status: "completed",
+          input: {
+            run_in_background: true,
+            description: "Memo scan",
+            subagent_type: "explore",
+          },
+        },
+      }),
+      "utf8"
+    )
+
+    const projectID = "proj"
+    const sessDir = path.join(storage.session, projectID)
+    fs.mkdirSync(sessDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(sessDir, "ses_child.json"),
+      JSON.stringify({
+        id: "ses_child",
+        projectID,
+        directory: "/tmp/project",
+        title: "Background: Memo scan",
+        parentID: mainSessionId,
+        time: { created: 1500, updated: 1500 },
+      }),
+      "utf8"
+    )
+
+    const childMsgDir = path.join(storage.message, "ses_child")
+    fs.mkdirSync(childMsgDir, { recursive: true })
+    const childMsgId = "msg_child"
+    fs.writeFileSync(
+      path.join(childMsgDir, `${childMsgId}.json`),
+      JSON.stringify({
+        id: childMsgId,
+        sessionID: "ses_child",
+        role: "assistant",
+        time: { created: 2000 },
+        providerID: "openai",
+        modelID: "gpt-5.2",
+      }),
+      "utf8"
+    )
+
+    // Create typed wrapper that records calls and delegates to fs.readdirSync
+    const readdirCalls: Array<[fs.PathLike]> = []
+    const readdirSync = ((path: fs.PathLike, options?: any): any => {
+      if (typeof options === 'object' && options.withFileTypes) {
+        return fs.readdirSync(path, options)
+      }
+      readdirCalls.push([path])
+      return fs.readdirSync(path, 'utf8')
+    }) as typeof fs.readdirSync
+    
+    const fsLike = {
+      readFileSync: fs.readFileSync,
+      readdirSync,
+      existsSync: fs.existsSync,
+      statSync: fs.statSync,
+    }
+
+    // #when
+    const rows = deriveBackgroundTasks({ storage, mainSessionId, fs: fsLike })
+
+    // #then
+    const backgroundReads = readdirCalls.filter((call) => call[0] === childMsgDir)
+    expect(rows.length).toBe(2)
+    expect(backgroundReads.length).toBe(1)
+  })
 })