woozlit 2.3.0 → 2.3.1

package/test/server/session-actions.test.ts

@@ -1,49 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test"
-import { Effect } from "effect"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { Session as SessionNs } from "../../src/session"
-import type { SessionID } from "../../src/session/schema"
-import { Log } from "../../src/util"
-import { tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-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)))
-  },
-  remove(id: SessionID) {
-    return run(SessionNs.Service.use((svc) => svc.remove(id)))
-  },
-}
-
-afterEach(async () => {
-  mock.restore()
-  await Instance.disposeAll()
-})
-
-describe("session action routes", () => {
-  test("abort route returns success", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await svc.create({})
-        const app = Server.Default().app
-
-        const res = await app.request(`/session/${session.id}/abort`, { method: "POST" })
-
-        expect(res.status).toBe(200)
-        expect(await res.json()).toBe(true)
-
-        await svc.remove(session.id)
-      },
-    })
-  })
-})

package/test/server/session-list.test.ts

@@ -1,110 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Instance } from "../../src/project/instance"
-import { Session as SessionNs } from "../../src/session"
-import { Log } from "../../src/util"
-import { tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-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)))
-  },
-}
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-describe("session.list", () => {
-  test("filters by directory", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const first = await svc.create({})
-
-        await using other = await tmpdir({ git: true })
-        const second = await Instance.provide({
-          directory: other.path,
-          fn: async () => svc.create({}),
-        })
-
-        const sessions = [...svc.list({ directory: tmp.path })]
-        const ids = sessions.map((s) => s.id)
-
-        expect(ids).toContain(first.id)
-        expect(ids).not.toContain(second.id)
-      },
-    })
-  })
-
-  test("filters root sessions", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const root = await svc.create({ title: "root-session" })
-        const child = await svc.create({ title: "child-session", parentID: root.id })
-
-        const sessions = [...svc.list({ roots: true })]
-        const ids = sessions.map((s) => s.id)
-
-        expect(ids).toContain(root.id)
-        expect(ids).not.toContain(child.id)
-      },
-    })
-  })
-
-  test("filters by start time", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await svc.create({ title: "new-session" })
-        const futureStart = Date.now() + 86400000
-
-        const sessions = [...svc.list({ start: futureStart })]
-        expect(sessions.length).toBe(0)
-      },
-    })
-  })
-
-  test("filters by search term", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await svc.create({ title: "unique-search-term-abc" })
-        await svc.create({ title: "other-session-xyz" })
-
-        const sessions = [...svc.list({ search: "unique-search" })]
-        const titles = sessions.map((s) => s.title)
-
-        expect(titles).toContain("unique-search-term-abc")
-        expect(titles).not.toContain("other-session-xyz")
-      },
-    })
-  })
-
-  test("respects limit parameter", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await svc.create({ title: "session-1" })
-        await svc.create({ title: "session-2" })
-        await svc.create({ title: "session-3" })
-
-        const sessions = [...svc.list({ limit: 2 })]
-        expect(sessions.length).toBe(2)
-      },
-    })
-  })
-})

package/test/server/session-messages.test.ts

@@ -1,220 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { Session as SessionNs } from "../../src/session"
-import { MessageV2 } from "../../src/session/message-v2"
-import { MessageID, PartID, type SessionID } from "../../src/session/schema"
-import { Log } from "../../src/util"
-import { tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-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)))
-  },
-  remove(id: SessionID) {
-    return run(SessionNs.Service.use((svc) => svc.remove(id)))
-  },
-  updateMessage<T extends MessageV2.Info>(msg: T) {
-    return run(SessionNs.Service.use((svc) => svc.updateMessage(msg)))
-  },
-  updatePart<T extends MessageV2.Part>(part: T) {
-    return run(SessionNs.Service.use((svc) => svc.updatePart(part)))
-  },
-}
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-async function withoutWatcher<T>(fn: () => Promise<T>) {
-  if (process.platform !== "win32") return fn()
-  const prev = process.env.WOOZLIT_CODE_EXPERIMENTAL_DISABLE_FILEWATCHER
-  process.env.WOOZLIT_CODE_EXPERIMENTAL_DISABLE_FILEWATCHER = "true"
-  try {
-    return await fn()
-  } finally {
-    if (prev === undefined) delete process.env.WOOZLIT_CODE_EXPERIMENTAL_DISABLE_FILEWATCHER
-    else process.env.WOOZLIT_CODE_EXPERIMENTAL_DISABLE_FILEWATCHER = prev
-  }
-}
-
-async function fill(
-  sessionID: SessionID,
-  count: number,
-  time = (i: number) => Date.now() + i,
-  agentID?: string,
-) {
-  const ids = [] as MessageID[]
-  for (let i = 0; i < count; i++) {
-    const id = MessageID.ascending()
-    ids.push(id)
-    await svc.updateMessage({
-      id,
-      sessionID,
-      role: "user",
-      time: { created: time(i) },
-      agent: "test",
-      model: { providerID: "test", modelID: "test" },
-      tools: {},
-      mode: "",
-      ...(agentID !== undefined ? { agentID } : {}),
-    } as unknown as MessageV2.Info)
-    await svc.updatePart({
-      id: PartID.ascending(),
-      sessionID,
-      messageID: id,
-      type: "text",
-      text: `m${i}${agentID ? `-${agentID}` : ""}`,
-    })
-  }
-  return ids
-}
-
-describe("session messages endpoint", () => {
-  test("returns cursor headers for older pages", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          const ids = await fill(session.id, 5)
-          const app = Server.Default().app
-
-          const a = await app.request(`/session/${session.id}/message?limit=2`)
-          expect(a.status).toBe(200)
-          const aBody = (await a.json()) as MessageV2.WithParts[]
-          expect(aBody.map((item) => item.info.id)).toEqual(ids.slice(-2))
-          const cursor = a.headers.get("x-next-cursor")
-          expect(cursor).toBeTruthy()
-          expect(a.headers.get("link")).toContain('rel="next"')
-
-          const b = await app.request(`/session/${session.id}/message?limit=2&before=${encodeURIComponent(cursor!)}`)
-          expect(b.status).toBe(200)
-          const bBody = (await b.json()) as MessageV2.WithParts[]
-          expect(bBody.map((item) => item.info.id)).toEqual(ids.slice(-4, -2))
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
-
-  test("keeps full-history responses when limit is omitted", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          const ids = await fill(session.id, 3)
-          const app = Server.Default().app
-
-          const res = await app.request(`/session/${session.id}/message`)
-          expect(res.status).toBe(200)
-          const body = (await res.json()) as MessageV2.WithParts[]
-          expect(body.map((item) => item.info.id)).toEqual(ids)
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
-
-  test("rejects invalid cursors and missing sessions", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          const app = Server.Default().app
-
-          const bad = await app.request(`/session/${session.id}/message?limit=2&before=bad`)
-          expect(bad.status).toBe(400)
-
-          const miss = await app.request(`/session/ses_missing/message?limit=2`)
-          expect(miss.status).toBe(404)
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
-
-  test("filters out subagent slices by default; opts in via agent_id query param", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          // Interleave main + subagent rows so a wrong filter would still
-          // pick some rows up by accident.
-          const baseTime = Date.now()
-          const main = await fill(session.id, 2, (i) => baseTime + i)
-          const writer = await fill(session.id, 2, (i) => baseTime + 10 + i, "checkpoint-writer-1")
-          const more = await fill(session.id, 1, (i) => baseTime + 20 + i)
-
-          const app = Server.Default().app
-
-          // Default — main slice only (the bug we're fixing).
-          const def = await app.request(`/session/${session.id}/message`)
-          expect(def.status).toBe(200)
-          const defBody = (await def.json()) as MessageV2.WithParts[]
-          expect(defBody.map((m) => m.info.id)).toEqual([...main, ...more])
-
-          // ?agent_id=<id> — that subagent's slice only.
-          const sub = await app.request(`/session/${session.id}/message?agent_id=checkpoint-writer-1`)
-          expect(sub.status).toBe(200)
-          const subBody = (await sub.json()) as MessageV2.WithParts[]
-          expect(subBody.map((m) => m.info.id)).toEqual(writer)
-
-          // ?agent_id=* — all slices, preserves the legacy "no filter" behavior
-          // for callers that explicitly opt in.
-          const all = await app.request(`/session/${session.id}/message?agent_id=*`)
-          expect(all.status).toBe(200)
-          const allBody = (await all.json()) as MessageV2.WithParts[]
-          expect(allBody.map((m) => m.info.id)).toEqual([...main, ...writer, ...more])
-
-          // Same defaulting on the cursor-paginated path.
-          const limited = await app.request(`/session/${session.id}/message?limit=10`)
-          expect(limited.status).toBe(200)
-          const limitedBody = (await limited.json()) as MessageV2.WithParts[]
-          expect(limitedBody.map((m) => m.info.id)).toEqual([...main, ...more])
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
-
-  test("does not truncate large legacy limit requests", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await withoutWatcher(() =>
-      Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const session = await svc.create({})
-          await fill(session.id, 520)
-          const app = Server.Default().app
-
-          const res = await app.request(`/session/${session.id}/message?limit=510`)
-          expect(res.status).toBe(200)
-          const body = (await res.json()) as MessageV2.WithParts[]
-          expect(body).toHaveLength(510)
-
-          await svc.remove(session.id)
-        },
-      }),
-    )
-  })
-})

package/test/server/session-prompt-busy.test.ts

@@ -1,146 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Hono } from "hono"
-import { ErrorMiddleware } from "../../src/server/middleware"
-import { Server } from "../../src/server/server"
-import { Instance } from "../../src/project/instance"
-import { Session } from "../../src/session"
-import { SessionRunState } from "../../src/session/run-state"
-import { AppRuntime } from "../../src/effect/app-runtime"
-import { Log } from "../../src/util"
-import { tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-describe("ErrorMiddleware → BusyError mapping", () => {
-  test("BusyError maps to HTTP 409 Conflict", async () => {
-    const app = new Hono()
-    app.get("/throw-busy", () => {
-      throw new Session.BusyError("ses_test_busy")
-    })
-    app.onError(ErrorMiddleware)
-
-    const res = await app.request("/throw-busy")
-    expect(res.status).toBe(409)
-    const body = (await res.json()) as { name: string; data: { message: string } }
-    expect(body.data.message).toContain("ses_test_busy")
-  })
-})
-
-describe("POST /session/:sessionID/message busy-runner behavior", () => {
-  test("returns 409 when session main runner is already busy", async () => {
-    await using tmp = await tmpdir({})
-
-    const status = await Instance.provide({
-      directory: tmp.path,
-      fn: async () =>
-        AppRuntime.runPromise(
-          Effect.gen(function* () {
-            const sessions = yield* Session.Service
-            const sess = yield* sessions.create({ title: "busy-runner test" })
-            const state = yield* SessionRunState.Service
-
-            // Occupy the main runner with an Effect that never resolves.
-            // Forked so we can continue and issue the conflicting POST.
-            yield* state
-              .startShell(
-                sess.id,
-                Effect.succeed({ info: {}, parts: [] } as never),
-                Effect.never as never,
-              )
-              .pipe(Effect.forkChild)
-
-            // Give the scheduler a tick so the occupant marks the runner busy.
-            yield* Effect.sleep("50 millis")
-
-            // Pass ?directory= so InstanceMiddleware resolves to the same instance
-            // the test created. Without this, the route handler would land in a
-            // different Instance (process.cwd()) whose SessionRunState has no busy
-            // runner, defeating the test.
-            const app = Server.Default().app
-            const res = yield* Effect.promise(async () =>
-              app.request(`/session/${sess.id}/message?directory=${encodeURIComponent(tmp.path)}`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                  parts: [{ type: "text", text: "should be rejected" }],
-                }),
-              }),
-            )
-
-            // Best-effort: stop the occupant so afterEach disposal is clean.
-            yield* state.cancel(sess.id)
-
-            return res.status
-          }),
-        ),
-    })
-
-    expect(status).toBe(409)
-  })
-
-  test("POST /:sessionID/abort frees runner; subsequent POST is no longer rejected with 409", async () => {
-    await using tmp = await tmpdir({})
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: async () =>
-        AppRuntime.runPromise(
-          Effect.gen(function* () {
-            const sessions = yield* Session.Service
-            const sess = yield* sessions.create({ title: "busy-recover test" })
-            const state = yield* SessionRunState.Service
-
-            yield* state
-              .startShell(
-                sess.id,
-                Effect.succeed({ info: {}, parts: [] } as never),
-                Effect.never as never,
-              )
-              .pipe(Effect.forkChild)
-            yield* Effect.sleep("50 millis")
-
-            const app = Server.Default().app
-            const dirQuery = `?directory=${encodeURIComponent(tmp.path)}`
-
-            // 1. confirm busy → 409
-            const first = yield* Effect.promise(async () =>
-              app.request(`/session/${sess.id}/message${dirQuery}`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ parts: [{ type: "text", text: "first" }] }),
-              }),
-            )
-
-            // 2. abort frees the runner
-            const abort = yield* Effect.promise(async () =>
-              app.request(`/session/${sess.id}/abort${dirQuery}`, { method: "POST" }),
-            )
-
-            // Wait for runner.cancel to take effect.
-            yield* Effect.sleep("100 millis")
-
-            // 3. subsequent POST is no longer 409 — assert just status != 409.
-            //    (full success requires a real LLM; we only verify the contention
-            //    is gone, not the prompt outcome.)
-            const second = yield* Effect.promise(async () =>
-              app.request(`/session/${sess.id}/message${dirQuery}`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ parts: [{ type: "text", text: "second" }] }),
-              }),
-            )
-            return { firstStatus: first.status, abortStatus: abort.status, secondStatus: second.status }
-          }),
-        ),
-    })
-
-    expect(result.firstStatus).toBe(409)
-    expect(result.abortStatus).toBe(200)
-    expect(result.secondStatus).not.toBe(409)
-  })
-})

package/test/server/session-select.test.ts

@@ -1,100 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Session as SessionNs } from "../../src/session"
-import type { SessionID } from "../../src/session/schema"
-import { Log } from "../../src/util"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-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)))
-  },
-  remove(id: SessionID) {
-    return run(SessionNs.Service.use((svc) => svc.remove(id)))
-  },
-}
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-describe("tui.selectSession endpoint", () => {
-  test("should return 200 when called with valid session", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // #given
-        const session = await svc.create({})
-
-        // #when
-        const app = Server.Default().app
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: session.id }),
-        })
-
-        // #then
-        expect(response.status).toBe(200)
-        const body = await response.json()
-        expect(body).toBe(true)
-
-        await svc.remove(session.id)
-      },
-    })
-  })
-
-  test("should return 404 when session does not exist", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // #given
-        const nonExistentSessionID = "ses_nonexistent123"
-
-        // #when
-        const app = Server.Default().app
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: nonExistentSessionID }),
-        })
-
-        // #then
-        expect(response.status).toBe(404)
-      },
-    })
-  })
-
-  test("should return 400 when session ID format is invalid", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // #given
-        const invalidSessionID = "invalid_session_id"
-
-        // #when
-        const app = Server.Default().app
-        const response = await app.request("/tui/select-session", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: invalidSessionID }),
-        })
-
-        // #then
-        expect(response.status).toBe(400)
-      },
-    })
-  })
-})