saeeol 1.2.5 → 1.2.8

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 "@/session/session"
-import type { SessionID } from "../../src/session/schema"
-import * as Log from "@saeeol/core/util/log"
-import { disposeAllInstances, 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 disposeAllInstances()
-})
-
-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,238 +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 "@/session/session"
-import * as Log from "@saeeol/core/util/log"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { Flag } from "@saeeol/core/flag/flag"
-import { mkdir } from "fs/promises"
-import path from "path"
-import { Database } from "@/storage/db"
-import { SessionTable } from "@/session/session.sql"
-import { eq } from "drizzle-orm"
-
-void Log.init({ print: false })
-const originalWorkspaces = Flag.SAEEOL_EXPERIMENTAL_WORKSPACES
-
-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)))
-  },
-  list(input?: SessionNs.ListInput) {
-    return run(SessionNs.Service.use((svc) => svc.list(input)))
-  },
-}
-
-afterEach(async () => {
-  Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = originalWorkspaces
-  await disposeAllInstances()
-})
-
-describe("session.list", () => {
-  test("does not filter by directory when directory is omitted", async () => {
-    Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = false
-    await using tmp = await tmpdir({ git: true })
-    await mkdir(path.join(tmp.path, "packages", "saeeol"), { recursive: true })
-    await mkdir(path.join(tmp.path, "packages", "app"), { recursive: true })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const root = await svc.create({ title: "root" })
-
-        const parent = await Instance.provide({
-          directory: path.join(tmp.path, "packages"),
-          fn: async () => svc.create({ title: "parent" }),
-        })
-        const current = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "saeeol"),
-          fn: async () => svc.create({ title: "current" }),
-        })
-        const sibling = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "app"),
-          fn: async () => svc.create({ title: "sibling" }),
-        })
-
-        const ids = (await svc.list()).map((s) => s.id)
-        expect(ids).toContain(root.id)
-        expect(ids).toContain(parent.id)
-        expect(ids).toContain(current.id)
-        expect(ids).toContain(sibling.id)
-      },
-    })
-  })
-
-  test("filters by directory when directory is provided", async () => {
-    Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = false
-    await using tmp = await tmpdir({ git: true })
-    await mkdir(path.join(tmp.path, "packages", "saeeol"), { recursive: true })
-    await mkdir(path.join(tmp.path, "packages", "app"), { recursive: true })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const root = await svc.create({ title: "root" })
-
-        const parent = await Instance.provide({
-          directory: path.join(tmp.path, "packages"),
-          fn: async () => svc.create({ title: "parent" }),
-        })
-        const current = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "saeeol"),
-          fn: async () => svc.create({ title: "current" }),
-        })
-        const sibling = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "app"),
-          fn: async () => svc.create({ title: "sibling" }),
-        })
-
-        const ids = (await svc.list({ directory: path.join(tmp.path, "packages", "saeeol") })).map((s) => s.id)
-        expect(ids).not.toContain(root.id)
-        expect(ids).not.toContain(parent.id)
-        expect(ids).toContain(current.id)
-        expect(ids).not.toContain(sibling.id)
-      },
-    })
-  })
-
-  test("filters by path and ignores directory when path is provided", async () => {
-    Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = false
-    await using tmp = await tmpdir({ git: true })
-    await mkdir(path.join(tmp.path, "packages", "saeeol", "src", "deep"), { recursive: true })
-    await mkdir(path.join(tmp.path, "packages", "app"), { recursive: true })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const parent = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "saeeol"),
-          fn: async () => svc.create({ title: "parent" }),
-        })
-        const current = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "saeeol", "src"),
-          fn: async () => svc.create({ title: "current" }),
-        })
-        const deeper = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "saeeol", "src", "deep"),
-          fn: async () => svc.create({ title: "deeper" }),
-        })
-        const sibling = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "app"),
-          fn: async () => svc.create({ title: "sibling" }),
-        })
-
-        const pathIDs = (
-          await svc.list({
-            directory: path.join(tmp.path, "packages", "app"),
-            path: "packages/saeeol/src",
-          })
-        ).map((s) => s.id)
-        expect(pathIDs).not.toContain(parent.id)
-        expect(pathIDs).toContain(current.id)
-        expect(pathIDs).toContain(deeper.id)
-        expect(pathIDs).not.toContain(sibling.id)
-      },
-    })
-  })
-
-  test("falls back to directory when filtering legacy sessions without path", async () => {
-    Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = false
-    await using tmp = await tmpdir({ git: true })
-    await mkdir(path.join(tmp.path, "packages", "saeeol", "src"), { recursive: true })
-    await mkdir(path.join(tmp.path, "packages", "app"), { recursive: true })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const current = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "saeeol", "src"),
-          fn: async () => svc.create({ title: "legacy-current" }),
-        })
-        const sibling = await Instance.provide({
-          directory: path.join(tmp.path, "packages", "app"),
-          fn: async () => svc.create({ title: "legacy-sibling" }),
-        })
-
-        Database.use((db) => db.update(SessionTable).set({ path: null }).where(eq(SessionTable.id, current.id)).run())
-        Database.use((db) => db.update(SessionTable).set({ path: null }).where(eq(SessionTable.id, sibling.id)).run())
-
-        const pathIDs = (
-          await svc.list({
-            directory: path.join(tmp.path, "packages", "saeeol", "src"),
-            path: "packages/saeeol/src",
-          })
-        ).map((s) => s.id)
-        expect(pathIDs).toContain(current.id)
-        expect(pathIDs).not.toContain(sibling.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 = await 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 = await 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 = await 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 = await svc.list({ limit: 2 })
-        expect(sessions.length).toBe(2)
-      },
-    })
-  })
-})

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

@@ -1,167 +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 "@/session/session"
-import { MessageV2 } from "../../src/session/message-v2"
-import { MessageID, PartID, type SessionID } from "../../src/session/schema"
-import * as Log from "@saeeol/core/util/log"
-import { disposeAllInstances, 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 disposeAllInstances()
-})
-
-async function withoutWatcher<T>(fn: () => Promise<T>) {
-  if (process.platform !== "win32") return fn()
-  const prev = process.env.SAEEOL_EXPERIMENTAL_DISABLE_FILEWATCHER
-  process.env.SAEEOL_EXPERIMENTAL_DISABLE_FILEWATCHER = "true"
-  try {
-    return await fn()
-  } finally {
-    if (prev === undefined) delete process.env.SAEEOL_EXPERIMENTAL_DISABLE_FILEWATCHER
-    else process.env.SAEEOL_EXPERIMENTAL_DISABLE_FILEWATCHER = prev
-  }
-}
-
-async function fill(sessionID: SessionID, count: number, time = (i: number) => Date.now() + i) {
-  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: "",
-    } as unknown as MessageV2.Info)
-    await svc.updatePart({
-      id: PartID.ascending(),
-      sessionID,
-      messageID: id,
-      type: "text",
-      text: `m${i}`,
-    })
-  }
-  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("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-select.test.ts

@@ -1,100 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Session as SessionNs } from "@/session/session"
-import type { SessionID } from "../../src/session/schema"
-import * as Log from "@saeeol/core/util/log"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { disposeAllInstances, 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 disposeAllInstances()
-})
-
-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)
-      },
-    })
-  })
-})

package/test/server/trace-attributes.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { paramToAttributeKey, requestAttributes } from "../../src/server/routes/instance/trace"
-
-function fakeContext(method: string, url: string, params: Record<string, string>) {
-  return {
-    req: {
-      method,
-      url,
-      param: () => params,
-    },
-  }
-}
-
-describe("paramToAttributeKey", () => {
-  test("converts fooID to foo.id", () => {
-    expect(paramToAttributeKey("sessionID")).toBe("session.id")
-    expect(paramToAttributeKey("messageID")).toBe("message.id")
-    expect(paramToAttributeKey("partID")).toBe("part.id")
-    expect(paramToAttributeKey("projectID")).toBe("project.id")
-    expect(paramToAttributeKey("providerID")).toBe("provider.id")
-    expect(paramToAttributeKey("ptyID")).toBe("pty.id")
-    expect(paramToAttributeKey("permissionID")).toBe("permission.id")
-    expect(paramToAttributeKey("requestID")).toBe("request.id")
-    expect(paramToAttributeKey("workspaceID")).toBe("workspace.id")
-  })
-
-  test("namespaces non-ID params under saeeol.", () => {
-    expect(paramToAttributeKey("name")).toBe("saeeol.name")
-    expect(paramToAttributeKey("slug")).toBe("saeeol.slug")
-  })
-})
-
-describe("requestAttributes", () => {
-  test("includes http method and path", () => {
-    const attrs = requestAttributes(fakeContext("GET", "http://localhost/session", {}))
-    expect(attrs["http.method"]).toBe("GET")
-    expect(attrs["http.path"]).toBe("/session")
-  })
-
-  test("strips query string from path", () => {
-    const attrs = requestAttributes(fakeContext("GET", "http://localhost/file/search?query=foo&limit=10", {}))
-    expect(attrs["http.path"]).toBe("/file/search")
-  })
-
-  test("emits OTel-style <domain>.id for ID-shaped route params", () => {
-    const attrs = requestAttributes(
-      fakeContext("GET", "http://localhost/session/ses_abc/message/msg_def/part/prt_ghi", {
-        sessionID: "ses_abc",
-        messageID: "msg_def",
-        partID: "prt_ghi",
-      }),
-    )
-    expect(attrs["session.id"]).toBe("ses_abc")
-    expect(attrs["message.id"]).toBe("msg_def")
-    expect(attrs["part.id"]).toBe("prt_ghi")
-    // No camelCase leftovers:
-    expect(attrs["saeeol.sessionID"]).toBeUndefined()
-    expect(attrs["saeeol.messageID"]).toBeUndefined()
-    expect(attrs["saeeol.partID"]).toBeUndefined()
-  })
-
-  test("produces no param attributes when no params are matched", () => {
-    const attrs = requestAttributes(fakeContext("POST", "http://localhost/config", {}))
-    expect(Object.keys(attrs).filter((k) => k !== "http.method" && k !== "http.path")).toEqual([])
-  })
-
-  test("namespaces non-ID params under saeeol. (e.g. mcp :name)", () => {
-    const attrs = requestAttributes(
-      fakeContext("POST", "http://localhost/mcp/exa/connect", {
-        name: "exa",
-      }),
-    )
-    expect(attrs["saeeol.name"]).toBe("exa")
-    expect(attrs["name"]).toBeUndefined()
-  })
-})