refactor(session): remove async facade exports (#22471)

packages/opencode/test/server/global-session-list.test.ts

@@ -1,27 +1,43 @@
 import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import z from "zod"
 import { Instance } from "../../src/project/instance"
 import { Project } from "../../src/project/project"
-import { Session } from "../../src/session"
+import { Session as SessionNs } from "../../src/session"
 import { Log } from "../../src/util/log"
 import { tmpdir } from "../fixture/fixture"
 
 Log.init({ print: false })
 
-describe("Session.listGlobal", () => {
+function run<A, E>(fx: Effect.Effect<A, E, SessionNs.Service>) {
+  return Effect.runPromise(fx.pipe(Effect.provide(SessionNs.defaultLayer)))
+}
+
+const svc = {
+  ...SessionNs,
+  create(input?: SessionNs.CreateInput) {
+    return run(SessionNs.Service.use((svc) => svc.create(input)))
+  },
+  setArchived(input: z.output<typeof SessionNs.SetArchivedInput>) {
+    return run(SessionNs.Service.use((svc) => svc.setArchived(input)))
+  },
+}
+
+describe("session.listGlobal", () => {
   test("lists sessions across projects with project metadata", async () => {
     await using first = await tmpdir({ git: true })
     await using second = await tmpdir({ git: true })
 
     const firstSession = await Instance.provide({
       directory: first.path,
-      fn: async () => Session.create({ title: "first-session" }),
+      fn: async () => svc.create({ title: "first-session" }),
     })
     const secondSession = await Instance.provide({
       directory: second.path,
-      fn: async () => Session.create({ title: "second-session" }),
+      fn: async () => svc.create({ title: "second-session" }),
     })
 
-    const sessions = [...Session.listGlobal({ limit: 200 })]
+    const sessions = [...svc.listGlobal({ limit: 200 })]
     const ids = sessions.map((session) => session.id)
 
     expect(ids).toContain(firstSession.id)
@@ -44,20 +60,20 @@ describe("Session.listGlobal", () => {
 
     const archived = await Instance.provide({
       directory: tmp.path,
-      fn: async () => Session.create({ title: "archived-session" }),
+      fn: async () => svc.create({ title: "archived-session" }),
     })
 
     await Instance.provide({
       directory: tmp.path,
-      fn: async () => Session.setArchived({ sessionID: archived.id, time: Date.now() }),
+      fn: async () => svc.setArchived({ sessionID: archived.id, time: Date.now() }),
     })
 
-    const sessions = [...Session.listGlobal({ limit: 200 })]
+    const sessions = [...svc.listGlobal({ limit: 200 })]
     const ids = sessions.map((session) => session.id)
 
     expect(ids).not.toContain(archived.id)
 
-    const allSessions = [...Session.listGlobal({ limit: 200, archived: true })]
+    const allSessions = [...svc.listGlobal({ limit: 200, archived: true })]
     const allIds = allSessions.map((session) => session.id)
 
     expect(allIds).toContain(archived.id)
@@ -68,19 +84,19 @@ describe("Session.listGlobal", () => {
 
     const first = await Instance.provide({
       directory: tmp.path,
-      fn: async () => Session.create({ title: "page-one" }),
+      fn: async () => svc.create({ title: "page-one" }),
     })
     await new Promise((resolve) => setTimeout(resolve, 5))
     const second = await Instance.provide({
       directory: tmp.path,
-      fn: async () => Session.create({ title: "page-two" }),
+      fn: async () => svc.create({ title: "page-two" }),
     })
 
-    const page = [...Session.listGlobal({ directory: tmp.path, limit: 1 })]
+    const page = [...svc.listGlobal({ directory: tmp.path, limit: 1 })]
     expect(page.length).toBe(1)
     expect(page[0].id).toBe(second.id)
 
-    const next = [...Session.listGlobal({ directory: tmp.path, limit: 10, cursor: page[0].time.updated })]
+    const next = [...svc.listGlobal({ directory: tmp.path, limit: 10, cursor: page[0].time.updated })]
     const ids = next.map((session) => session.id)
 
     expect(ids).toContain(first.id)