cleanup based on coding standards, more test coverage

Author: jmagder

packages/app/e2e/actions.ts

@@ -419,3 +419,20 @@ export async function openWorkspaceMenu(page: Page, workspaceSlug: string) {
   await expect(menu).toBeVisible()
   return menu
 }
+
+export async function seedMessage(sdk: Parameters<typeof withSession>[0], sessionID: string) {
+  await sdk.session.promptAsync({
+    sessionID,
+    noReply: true,
+    parts: [{ type: "text", text: "e2e seed" }],
+  })
+  await expect
+    .poll(
+      async () => {
+        const messages = await sdk.session.messages({ sessionID, limit: 1 }).then((r) => r.data ?? [])
+        return messages.length
+      },
+      { timeout: 30_000 },
+    )
+    .toBeGreaterThan(0)
+}

packages/app/e2e/sidebar/session-expansion-persistence.spec.ts

@@ -1,11 +1,9 @@
 import { test, expect } from "../fixtures"
-import { openSidebar, withSession } from "../actions"
+import { openSidebar, withSession, seedMessage } from "../actions"
 import { sessionItemSelector } from "../selectors"
 
 const EXPANDED_SESSIONS_STORAGE_KEY = "opencode.global.dat:expanded-sessions"
 
-type Sdk = Parameters<typeof withSession>[0]
-
 async function getExpandedSessionsFromStorage(page: import("@playwright/test").Page) {
   const raw = await page.evaluate((key) => localStorage.getItem(key), EXPANDED_SESSIONS_STORAGE_KEY)
   if (!raw) return {}
@@ -16,23 +14,6 @@ async function getExpandedSessionsFromStorage(page: import("@playwright/test").P
   }
 }
 
-async function seedMessage(sdk: Sdk, sessionID: string) {
-  await sdk.session.promptAsync({
-    sessionID,
-    noReply: true,
-    parts: [{ type: "text", text: "e2e seed" }],
-  })
-  await expect
-    .poll(
-      async () => {
-        const messages = await sdk.session.messages({ sessionID, limit: 1 }).then((r) => r.data ?? [])
-        return messages.length
-      },
-      { timeout: 30_000 },
-    )
-    .toBeGreaterThan(0)
-}
-
 test("expanding a session with children persists state to localStorage", async ({ page, sdk, gotoSession }) => {
   await withSession(sdk, "parent session for expansion test", async (parent) => {
     const child = await sdk.session.create({ title: "child session", parentID: parent.id }).then((r) => r.data)

packages/app/e2e/sidebar/sidebar.spec.ts

@@ -1,5 +1,5 @@
 import { test, expect } from "../fixtures"
-import { openSidebar, toggleSidebar, withSession } from "../actions"
+import { openSidebar, toggleSidebar, withSession, seedMessage } from "../actions"
 import { sessionItemSelector } from "../selectors"
 
 test("sidebar can be collapsed and expanded", async ({ page, gotoSession }) => {
@@ -109,23 +109,6 @@ test("root session has no back arrow or subagent indicator", async ({ page, sdk,
   })
 })
 
-async function seedMessage(sdk: Parameters<typeof withSession>[0], sessionID: string) {
-  await sdk.session.promptAsync({
-    sessionID,
-    noReply: true,
-    parts: [{ type: "text", text: "e2e seed" }],
-  })
-  await expect
-    .poll(
-      async () => {
-        const messages = await sdk.session.messages({ sessionID, limit: 1 }).then((r) => r.data ?? [])
-        return messages.length
-      },
-      { timeout: 30_000 },
-    )
-    .toBeGreaterThan(0)
-}
-
 test("subagent session shows back arrow and subagent indicator, and navigates to parent", async ({
   page,
   sdk,
@@ -208,3 +191,96 @@ test("navigating to parent session shows background only on parent", async ({ pa
     }
   })
 })
+
+test("deeply nested sessions can be expanded and collapsed at each level", async ({ page, sdk, gotoSession }) => {
+  await withSession(sdk, "grandparent session", async (grandparent) => {
+    const parent = await sdk.session.create({ title: "parent session", parentID: grandparent.id }).then((r) => r.data)
+    if (!parent?.id) throw new Error("Failed to create parent session")
+
+    const child = await sdk.session.create({ title: "child session", parentID: parent.id }).then((r) => r.data)
+    if (!child?.id) throw new Error("Failed to create child session")
+
+    const grandchild = await sdk.session.create({ title: "grandchild session", parentID: child.id }).then((r) => r.data)
+    if (!grandchild?.id) throw new Error("Failed to create grandchild session")
+
+    try {
+      await gotoSession(grandparent.id)
+      await openSidebar(page)
+
+      const grandparentItem = page.locator(sessionItemSelector(grandparent.id))
+      const parentItem = page.locator(sessionItemSelector(parent.id))
+      const childItem = page.locator(sessionItemSelector(child.id))
+      const grandchildItem = page.locator(sessionItemSelector(grandchild.id))
+
+      await expect(grandparentItem).toBeVisible()
+      await expect(parentItem).not.toBeVisible()
+
+      const grandparentChevron = grandparentItem.locator('[data-slot="collapsible-trigger"]').first()
+      await grandparentChevron.click()
+      await expect(parentItem).toBeVisible()
+      await expect(childItem).not.toBeVisible()
+
+      const parentChevron = parentItem.locator('[data-slot="collapsible-trigger"]').first()
+      await parentChevron.click()
+      await expect(childItem).toBeVisible()
+      await expect(grandchildItem).not.toBeVisible()
+
+      const childChevron = childItem.locator('[data-slot="collapsible-trigger"]').first()
+      await childChevron.click()
+      await expect(grandchildItem).toBeVisible()
+
+      await childChevron.click()
+      await expect(grandchildItem).not.toBeVisible()
+
+      await parentChevron.click()
+      await expect(childItem).not.toBeVisible()
+      await expect(grandchildItem).not.toBeVisible()
+
+      await grandparentChevron.click()
+      await expect(parentItem).not.toBeVisible()
+    } finally {
+      await sdk.session.delete({ sessionID: grandchild.id }).catch(() => undefined)
+      await sdk.session.delete({ sessionID: child.id }).catch(() => undefined)
+      await sdk.session.delete({ sessionID: parent.id }).catch(() => undefined)
+    }
+  })
+})
+
+test("parent with archived child has no chevron", async ({ page, sdk, gotoSession }) => {
+  await withSession(sdk, "parent session", async (parent) => {
+    const child = await sdk.session.create({ title: "child session", parentID: parent.id }).then((r) => r.data)
+    if (!child?.id) throw new Error("Failed to create child session")
+
+    try {
+      await seedMessage(sdk, child.id)
+      await gotoSession(parent.id)
+      await openSidebar(page)
+
+      const parentItem = page.locator(sessionItemSelector(parent.id))
+      const childItem = page.locator(sessionItemSelector(child.id))
+      const chevron = parentItem.locator('[data-slot="collapsible-trigger"]')
+
+      await expect(chevron).toBeVisible()
+
+      await chevron.click()
+      await expect(childItem).toBeVisible()
+
+      await sdk.session.update({ sessionID: child.id, time: { archived: Date.now() } })
+
+      await page.reload()
+      await openSidebar(page)
+
+      await expect(parentItem).toBeVisible()
+      await expect(chevron).not.toBeVisible()
+
+      await gotoSession(child.id)
+      await expect(page).toHaveURL(new RegExp(`/session/${child.id}`))
+
+      const navigateParent = page.getByTestId("navigate-parent-button")
+      await expect(navigateParent).toBeVisible()
+    } finally {
+      await sdk.session.update({ sessionID: child.id, time: { archived: undefined } }).catch(() => undefined)
+      await sdk.session.delete({ sessionID: child.id }).catch(() => undefined)
+    }
+  })
+})

packages/app/src/context/global-sync.test.ts

@@ -1,11 +1,23 @@
 import { describe, expect, test } from "bun:test"
+import type { Session } from "@opencode-ai/sdk/v2/client"
 import {
   canDisposeDirectory,
   estimateRootSessionTotal,
   loadRootSessionsWithFallback,
   pickDirectoriesToEvict,
 } from "./global-sync"
 
+const mockSession = (id: string, overrides?: Partial<Session>): Session => ({
+  id,
+  slug: "",
+  projectID: "",
+  title: "",
+  version: "",
+  directory: "/test",
+  time: { created: Date.now(), updated: Date.now() },
+  ...overrides,
+})
+
 describe("pickDirectoriesToEvict", () => {
   test("keeps pinned stores and evicts idle stores", () => {
     const now = 5_000
@@ -131,3 +143,74 @@ describe("canDisposeDirectory", () => {
     ).toBe(true)
   })
 })
+
+describe("session deduplication logic", () => {
+  test("deduplicates sessions by id", () => {
+    const sessions: Session[] = [
+      mockSession("a"),
+      mockSession("b"),
+      mockSession("a"),
+      mockSession("c"),
+      mockSession("b"),
+    ]
+
+    const seen = new Set<string>()
+    const deduplicated = sessions.filter((s) => {
+      if (!s.id) return false
+      if (seen.has(s.id)) return false
+      seen.add(s.id)
+      return true
+    })
+
+    expect(deduplicated).toHaveLength(3)
+    expect(deduplicated.map((s) => s.id)).toEqual(["a", "b", "c"])
+  })
+
+  test("combines non-archived and child sessions with deduplication", () => {
+    const fetched: Session[] = [mockSession("root-1"), mockSession("root-2"), mockSession("root-1")]
+    const existingChildren: Session[] = [
+      mockSession("child-1", { parentID: "root-1" }),
+      mockSession("child-2", { parentID: "root-1" }),
+      mockSession("child-1", { parentID: "root-1" }),
+    ]
+
+    const nonArchived = fetched.filter((s) => !s.time?.archived)
+    const childSessions = existingChildren.filter((s) => !!s.parentID)
+
+    const seen = new Set<string>()
+    const deduplicated = [...nonArchived, ...childSessions].filter((s) => {
+      if (!s.id) return false
+      if (seen.has(s.id)) return false
+      seen.add(s.id)
+      return true
+    })
+
+    expect(deduplicated).toHaveLength(4)
+    const ids = deduplicated.map((s) => s.id)
+    expect(ids).toContain("root-1")
+    expect(ids).toContain("root-2")
+    expect(ids).toContain("child-1")
+    expect(ids).toContain("child-2")
+  })
+
+  test("filters out archived sessions before deduplication", () => {
+    const sessions: Session[] = [
+      mockSession("active-1"),
+      mockSession("archived-1", { time: { created: Date.now(), updated: Date.now(), archived: Date.now() } }),
+      mockSession("active-2"),
+      mockSession("archived-1", { time: { created: Date.now(), updated: Date.now(), archived: Date.now() } }),
+    ]
+
+    const nonArchived = sessions.filter((s) => !s.time?.archived)
+    const seen = new Set<string>()
+    const deduplicated = nonArchived.filter((s) => {
+      if (!s.id) return false
+      if (seen.has(s.id)) return false
+      seen.add(s.id)
+      return true
+    })
+
+    expect(deduplicated).toHaveLength(2)
+    expect(deduplicated.map((s) => s.id)).toEqual(["active-1", "active-2"])
+  })
+})

packages/app/src/pages/layout/helpers.test.ts

@@ -1,6 +1,25 @@
 import { describe, expect, test } from "bun:test"
 import { collectOpenProjectDeepLinks, drainPendingDeepLinks, parseDeepLink } from "./deep-links"
-import { displayName, errorMessage, getDraggableId, syncWorkspaceOrder, workspaceKey } from "./helpers"
+import {
+  displayName,
+  errorMessage,
+  getChildSessions,
+  getDraggableId,
+  syncWorkspaceOrder,
+  workspaceKey,
+} from "./helpers"
+import type { Session } from "@opencode-ai/sdk/v2/client"
+
+const mockSession = (id: string, overrides?: Partial<Session>): Session => ({
+  id,
+  slug: "",
+  projectID: "",
+  title: "",
+  version: "",
+  directory: "/test",
+  time: { created: Date.now(), updated: Date.now() },
+  ...overrides,
+})
 
 describe("layout deep links", () => {
   test("parses open-project deep links", () => {
@@ -90,3 +109,61 @@ describe("layout workspace helpers", () => {
     expect(errorMessage("unknown", "fallback")).toBe("fallback")
   })
 })
+
+describe("getChildSessions", () => {
+  test("filters by parentID", () => {
+    const sessions: Session[] = [
+      mockSession("child-1", { parentID: "parent-a" }),
+      mockSession("child-2", { parentID: "parent-b" }),
+      mockSession("child-3", { parentID: "parent-a" }),
+      mockSession("root", {}),
+    ]
+
+    const childrenA = getChildSessions(sessions, "parent-a")
+    expect(childrenA.map((s) => s.id)).toEqual(expect.arrayContaining(["child-1", "child-3"]))
+    expect(childrenA).toHaveLength(2)
+
+    const childrenB = getChildSessions(sessions, "parent-b")
+    expect(childrenB).toHaveLength(1)
+    expect(childrenB[0].id).toBe("child-2")
+
+    const childrenNone = getChildSessions(sessions, "non-existent")
+    expect(childrenNone).toHaveLength(0)
+  })
+
+  test("sorts by updated time descending", () => {
+    const now = Date.now()
+    const sessions: Session[] = [
+      mockSession("old", { parentID: "parent", time: { created: now, updated: now - 10000 } }),
+      mockSession("new", { parentID: "parent", time: { created: now, updated: now - 1000 } }),
+      mockSession("mid", { parentID: "parent", time: { created: now, updated: now - 5000 } }),
+    ]
+
+    const children = getChildSessions(sessions, "parent")
+    const ids = children.map((s) => s.id)
+    expect(ids).toContain("mid")
+    expect(ids).toContain("new")
+    expect(ids).toContain("old")
+  })
+
+  test("filters out archived sessions", () => {
+    const sessions: Session[] = [
+      mockSession("active-1", { parentID: "parent" }),
+      mockSession("active-2", { parentID: "parent" }),
+      mockSession("archived-1", {
+        parentID: "parent",
+        time: { created: Date.now(), updated: Date.now(), archived: Date.now() },
+      }),
+      mockSession("archived-2", {
+        parentID: "parent",
+        time: { created: Date.now(), updated: Date.now(), archived: Date.now() },
+      }),
+    ]
+
+    const children = getChildSessions(sessions, "parent")
+    expect(children).toHaveLength(2)
+    expect(children.map((s) => s.id)).toEqual(expect.arrayContaining(["active-1", "active-2"]))
+    expect(children.find((s) => s.id === "archived-1")).toBeUndefined()
+    expect(children.find((s) => s.id === "archived-2")).toBeUndefined()
+  })
+})

packages/app/src/pages/layout/helpers.ts

@@ -43,7 +43,7 @@ export const childMapByParent = (sessions: Session[]) => {
 }
 
 export const getChildSessions = (sessions: Session[], parentID: string): Session[] => {
-  return sessions.filter((s) => s.parentID === parentID).sort(sortSessions(Date.now()))
+  return sessions.filter((s) => s.parentID === parentID && !s.time?.archived).sort(sortSessions(Date.now()))
 }
 
 export function getDraggableId(event: unknown): string | undefined {