@miaws/miaw 1.18.5 → 1.18.7

package/test/server/session-diff-missing-patch.test.ts

@@ -1,96 +0,0 @@
-/**
- * Regression test for the same bug class as #26574 (sibling of #26566 and
- * #26553). The Desktop app calls GET /session/<id>/diff; before #26574
- * the response was Schema-encoded against `Snapshot.FileDiff` with
- * `patch: Schema.String` (required), so any session whose stored
- * `summary_diffs` had a row without `patch` returned HTTP 400 and the
- * session never loaded. Legacy session-level diffs are no longer surfaced,
- * but the endpoint remains compatible and must still return successfully.
- *
- * This test inserts a session row with a missing-patch diff entry and
- * asserts that GET /session/<id>/diff returns 200 with empty data.
- */
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { SessionPaths } from "@/server/routes/instance/httpapi/groups/session"
-import { Session } from "@/session/session"
-import { Storage } from "@/storage/storage"
-import { SessionV1 } from "@miaw/core/v1/session"
-import { MessageID } from "@/session/schema"
-import { ProviderV2 } from "@miaw/core/provider"
-import { ModelV2 } from "@miaw/core/model"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
-
-const it = testEffect(Layer.mergeAll(Session.defaultLayer, Storage.defaultLayer, httpApiLayer))
-
-afterEach(async () => {
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-function pathFor(template: string, params: Record<string, string>) {
-  return Object.entries(params).reduce((result, [key, value]) => result.replace(`:${key}`, value), template)
-}
-
-const withSession = (input?: Parameters<Session.Interface["create"]>[0]) =>
-  Effect.acquireRelease(Session.use.create(input), (created) => Session.use.remove(created.id).pipe(Effect.ignore))
-
-describe("session diff with missing patch (#26574)", () => {
-  it.instance(
-    "GET /session/<id>/diff ignores legacy session-level diff storage",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const session = yield* withSession({ title: "missing-patch" })
-
-        // Mimic legacy/imported on-disk shape: a diff entry with no
-        // `patch` text. Pre-fix the typed response encoder rejects
-        // this and returns 400.
-        yield* Storage.Service.use((storage) =>
-          storage.write(["session_diff", session.id], [{ file: "legacy.txt", additions: 1, deletions: 0 }]),
-        )
-
-        const response = yield* requestInDirectory(
-          pathFor(SessionPaths.diff, { sessionID: session.id }),
-          test.directory,
-        )
-
-        expect(response.status).toBe(200)
-        expect(yield* response.json).toEqual([])
-      }),
-    { git: true, config: { formatter: false, lsp: false } },
-  )
-
-  it.instance(
-    "GET /session/<id>/diff returns requested turn diffs",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const session = yield* withSession({ title: "turn-diff" })
-        const messageID = MessageID.ascending()
-        yield* Session.use.updateMessage({
-          id: messageID,
-          sessionID: session.id,
-          role: "user",
-          time: { created: Date.now() },
-          agent: "build",
-          model: { providerID: ProviderV2.ID.make("test"), modelID: ModelV2.ID.make("model") },
-          summary: {
-            diffs: [{ file: "turn.ts", additions: 1, deletions: 0, status: "modified" }],
-          },
-        } satisfies SessionV1.User)
-
-        const response = yield* requestInDirectory(
-          `${pathFor(SessionPaths.diff, { sessionID: session.id })}?messageID=${messageID}`,
-          test.directory,
-        )
-
-        expect(response.status).toBe(200)
-        expect(yield* response.json).toEqual([{ file: "turn.ts", additions: 1, deletions: 0, status: "modified" }])
-      }),
-    { git: true, config: { formatter: false, lsp: false } },
-  )
-})

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

@@ -1,312 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Database } from "@miaw/core/database/database"
-import { SessionProjector } from "@miaw/core/session/projector"
-import { Session as SessionNs } from "@/session/session"
-import { disposeAllInstances, provideInstance, TestInstance } from "../fixture/fixture"
-import { mkdir } from "fs/promises"
-import path from "path"
-import { SessionTable } from "@miaw/core/session/sql"
-import { eq } from "drizzle-orm"
-import { testEffect } from "../lib/effect"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { Storage } from "@/storage/storage"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import { BackgroundJob } from "@/background/job"
-
-const layer = (experimentalWorkspaces: boolean) =>
-  Layer.mergeAll(
-    Database.defaultLayer,
-    SessionNs.layer.pipe(
-      Layer.provide(EventV2Bridge.defaultLayer),
-      Layer.provide(Storage.defaultLayer),
-      Layer.provide(Database.defaultLayer),
-      Layer.provide(EventV2Bridge.defaultLayer),
-      Layer.provide(SessionProjector.defaultLayer),
-      Layer.provide(RuntimeFlags.layer({ experimentalWorkspaces })),
-      Layer.provide(BackgroundJob.defaultLayer),
-    ),
-  )
-const it = testEffect(layer(false))
-const itWorkspaces = testEffect(layer(true))
-
-const withSession = (input?: Parameters<SessionNs.Interface["create"]>[0]) =>
-  Effect.acquireRelease(SessionNs.use.create(input), (created) =>
-    SessionNs.Service.use((session) => session.remove(created.id).pipe(Effect.ignore)),
-  )
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-describe("session.list", () => {
-  it.instance(
-    "does not filter by directory when directory is omitted",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "miaw"), { recursive: true }))
-        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
-
-        const root = yield* withSession({ title: "root" })
-        const parent = yield* withSession({ title: "parent" }).pipe(
-          provideInstance(path.join(test.directory, "packages")),
-        )
-        const current = yield* withSession({ title: "current" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "miaw")),
-        )
-        const sibling = yield* withSession({ title: "sibling" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "app")),
-        )
-
-        const ids = (yield* SessionNs.use.list()).map((session) => session.id)
-        expect(ids).toContain(root.id)
-        expect(ids).toContain(parent.id)
-        expect(ids).toContain(current.id)
-        expect(ids).toContain(sibling.id)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "filters by directory when directory is provided",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "miaw"), { recursive: true }))
-        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
-
-        const root = yield* withSession({ title: "root" })
-        const parent = yield* withSession({ title: "parent" }).pipe(
-          provideInstance(path.join(test.directory, "packages")),
-        )
-        const current = yield* withSession({ title: "current" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "miaw")),
-        )
-        const sibling = yield* withSession({ title: "sibling" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "app")),
-        )
-
-        const ids = (yield* SessionNs.Service.use((session) =>
-          session.list({ directory: path.join(test.directory, "packages", "miaw") }),
-        )).map((session) => session.id)
-        expect(ids).not.toContain(root.id)
-        expect(ids).not.toContain(parent.id)
-        expect(ids).toContain(current.id)
-        expect(ids).not.toContain(sibling.id)
-      }),
-    { git: true },
-  )
-
-  itWorkspaces.instance(
-    "filters by directory when experimental workspaces are enabled",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "miaw"), { recursive: true }))
-        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
-
-        const current = yield* withSession({ title: "current" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "miaw")),
-        )
-        const sibling = yield* withSession({ title: "sibling" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "app")),
-        )
-
-        const ids = (yield* SessionNs.Service.use((session) =>
-          session.list({ directory: path.join(test.directory, "packages", "miaw") }),
-        )).map((session) => session.id)
-        expect(ids).toContain(current.id)
-        expect(ids).not.toContain(sibling.id)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "matches a session regardless of directory separator on Windows",
-    () =>
-      Effect.gen(function* () {
-        if (process.platform !== "win32") return
-        const test = yield* TestInstance
-        const dir = path.join(test.directory, "packages", "miaw")
-        yield* Effect.promise(() => mkdir(dir, { recursive: true }))
-
-        const created = yield* withSession({ title: "separator" }).pipe(provideInstance(dir))
-
-        // A forward-slash query (e.g. from the SDK/HTTP layer) must still find it —
-        // this is the regression: backslash-stored vs forward-slash-queried.
-        const forwardIDs = (yield* SessionNs.Service.use((session) =>
-          session.list({ directory: dir.replaceAll("\\", "/") }),
-        )).map((session) => session.id)
-        expect(forwardIDs).toContain(created.id)
-
-        // The native form must keep matching too.
-        const nativeIDs = (yield* SessionNs.Service.use((session) => session.list({ directory: dir }))).map(
-          (session) => session.id,
-        )
-        expect(nativeIDs).toContain(created.id)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "filters by path and ignores directory when path is provided",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        yield* Effect.promise(() =>
-          mkdir(path.join(test.directory, "packages", "miaw", "src", "deep"), { recursive: true }),
-        )
-        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
-
-        const parent = yield* withSession({ title: "parent" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "miaw")),
-        )
-        const current = yield* withSession({ title: "current" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "miaw", "src")),
-        )
-        const deeper = yield* withSession({ title: "deeper" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "miaw", "src", "deep")),
-        )
-        const sibling = yield* withSession({ title: "sibling" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "app")),
-        )
-
-        const pathIDs = (yield* SessionNs.Service.use((session) =>
-          session.list({
-            directory: path.join(test.directory, "packages", "app"),
-            path: "packages/miaw/src",
-          }),
-        )).map((session) => session.id)
-        expect(pathIDs).not.toContain(parent.id)
-        expect(pathIDs).toContain(current.id)
-        expect(pathIDs).toContain(deeper.id)
-        expect(pathIDs).not.toContain(sibling.id)
-
-        if (process.platform === "win32") {
-          const windowsPathIDs = (yield* SessionNs.Service.use((session) =>
-            session.list({ path: "packages\\miaw\\src" }),
-          )).map((session) => session.id)
-          expect(windowsPathIDs).toContain(current.id)
-          expect(windowsPathIDs).toContain(deeper.id)
-        }
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "falls back to directory when filtering legacy sessions without path",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        yield* Effect.promise(() =>
-          mkdir(path.join(test.directory, "packages", "miaw", "src"), { recursive: true }),
-        )
-        yield* Effect.promise(() => mkdir(path.join(test.directory, "packages", "app"), { recursive: true }))
-
-        const current = yield* withSession({ title: "legacy-current" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "miaw", "src")),
-        )
-        const sibling = yield* withSession({ title: "legacy-sibling" }).pipe(
-          provideInstance(path.join(test.directory, "packages", "app")),
-        )
-
-        const { db } = yield* Database.Service
-        yield* db
-          .update(SessionTable)
-          .set({ path: null })
-          .where(eq(SessionTable.id, current.id))
-          .run()
-          .pipe(Effect.orDie)
-        yield* db
-          .update(SessionTable)
-          .set({ path: null })
-          .where(eq(SessionTable.id, sibling.id))
-          .run()
-          .pipe(Effect.orDie)
-
-        const pathIDs = (yield* SessionNs.Service.use((session) =>
-          session.list({
-            directory: path.join(test.directory, "packages", "miaw", "src"),
-            path: "packages/miaw/src",
-          }),
-        )).map((session) => session.id)
-        expect(pathIDs).toContain(current.id)
-        expect(pathIDs).not.toContain(sibling.id)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "filters root sessions",
-    () =>
-      Effect.gen(function* () {
-        const root = yield* withSession({ title: "root-session" })
-        const child = yield* withSession({ title: "child-session", parentID: root.id })
-
-        const sessions = yield* SessionNs.use.list({ roots: true })
-        const ids = sessions.map((session) => session.id)
-
-        expect(ids).toContain(root.id)
-        expect(ids).not.toContain(child.id)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "filters by start time",
-    () =>
-      Effect.gen(function* () {
-        yield* withSession({ title: "new-session" })
-        const sessions = yield* SessionNs.Service.use((session) => session.list({ start: Date.now() + 86400000 }))
-        expect(sessions.length).toBe(0)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "filters by search term",
-    () =>
-      Effect.gen(function* () {
-        yield* withSession({ title: "unique-search-term-abc" })
-        yield* withSession({ title: "other-session-xyz" })
-
-        const sessions = yield* SessionNs.use.list({ search: "unique-search" })
-        const titles = sessions.map((session) => session.title)
-
-        expect(titles).toContain("unique-search-term-abc")
-        expect(titles).not.toContain("other-session-xyz")
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "respects limit parameter",
-    () =>
-      Effect.gen(function* () {
-        yield* withSession({ title: "session-1" })
-        yield* withSession({ title: "session-2" })
-        yield* withSession({ title: "session-3" })
-
-        const sessions = yield* SessionNs.use.list({ limit: 2 })
-        expect(sessions.length).toBe(2)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "includes metadata in listed sessions",
-    () =>
-      Effect.gen(function* () {
-        const meta = { source: "sdk", trace: { id: "abc" } }
-        const created = yield* withSession({ title: "meta-session", metadata: meta })
-
-        const listed = (yield* SessionNs.Service.use((session) => session.list({ search: "meta-session" }))).find(
-          (item) => item.id === created.id,
-        )
-
-        expect(listed?.metadata).toEqual(meta)
-      }),
-    { git: true },
-  )
-})

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

@@ -1,179 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { SessionV1 } from "@miaw/core/v1/session"
-import { Effect, Layer } from "effect"
-import { HttpClientResponse } from "effect/unstable/http"
-import { Session as SessionNs } from "@/session/session"
-import { MessageV2 } from "../../src/session/message-v2"
-
-import { MessageID, PartID, type SessionID } from "../../src/session/schema"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { ProviderV2 } from "@miaw/core/provider"
-import { ModelV2 } from "@miaw/core/model"
-import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
-
-const it = testEffect(Layer.mergeAll(SessionNs.defaultLayer, httpApiLayer))
-
-const model = {
-  providerID: ProviderV2.ID.make("test"),
-  modelID: ModelV2.ID.make("test"),
-}
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-const withoutWatcher = <A, E, R>(effect: Effect.Effect<A, E, R>) => {
-  if (process.platform !== "win32") return effect
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = process.env.MIAW_EXPERIMENTAL_DISABLE_FILEWATCHER
-      process.env.MIAW_EXPERIMENTAL_DISABLE_FILEWATCHER = "true"
-      return previous
-    }),
-    () => effect,
-    (previous) =>
-      Effect.sync(() => {
-        if (previous === undefined) delete process.env.MIAW_EXPERIMENTAL_DISABLE_FILEWATCHER
-        else process.env.MIAW_EXPERIMENTAL_DISABLE_FILEWATCHER = previous
-      }),
-  )
-}
-
-const sessionScoped = Effect.acquireRelease(SessionNs.use.create({}), (session) =>
-  SessionNs.use.remove(session.id).pipe(Effect.ignore),
-)
-
-const fill = Effect.fn("SessionMessagesTest.fill")(function* (
-  sessionID: SessionID,
-  count: number,
-  time = (i: number) => Date.now() + i,
-) {
-  const session = yield* SessionNs.Service
-  return yield* Effect.forEach(
-    Array.from({ length: count }, (_, i) => i),
-    (i) =>
-      Effect.gen(function* () {
-        const id = MessageID.ascending()
-        yield* session.updateMessage({
-          id,
-          sessionID,
-          role: "user",
-          time: { created: time(i) },
-          agent: "test",
-          model,
-          tools: {},
-        } satisfies SessionV1.User)
-        yield* session.updatePart({
-          id: PartID.ascending(),
-          sessionID,
-          messageID: id,
-          type: "text",
-          text: `m${i}`,
-        } satisfies SessionV1.TextPart)
-        return id
-      }),
-  )
-})
-
-function request(path: string) {
-  return TestInstance.pipe(Effect.flatMap((test) => requestInDirectory(path, test.directory)))
-}
-
-function json<T>(response: HttpClientResponse.HttpClientResponse) {
-  return response.json.pipe(Effect.map((body) => body as T))
-}
-
-describe("session messages endpoint", () => {
-  it.instance(
-    "returns cursor headers for older pages",
-    withoutWatcher(
-      Effect.gen(function* () {
-        const session = yield* sessionScoped
-        const ids = yield* fill(session.id, 5)
-
-        const a = yield* request(`/session/${session.id}/message?limit=2`)
-        expect(a.status).toBe(200)
-        const aBody = yield* json<SessionV1.WithParts[]>(a)
-        expect(aBody.map((item) => item.info.id)).toEqual(ids.slice(-2))
-        const cursor = a.headers["x-next-cursor"]
-        expect(cursor).toBeTruthy()
-        expect(a.headers["link"]).toContain('rel="next"')
-
-        const b = yield* request(`/session/${session.id}/message?limit=2&before=${encodeURIComponent(cursor!)}`)
-        expect(b.status).toBe(200)
-        const bBody = yield* json<SessionV1.WithParts[]>(b)
-        expect(bBody.map((item) => item.info.id)).toEqual(ids.slice(-4, -2))
-      }),
-    ),
-    { git: true },
-  )
-
-  it.instance(
-    "keeps full-history responses when limit is omitted",
-    withoutWatcher(
-      Effect.gen(function* () {
-        const session = yield* sessionScoped
-        const ids = yield* fill(session.id, 3)
-
-        const res = yield* request(`/session/${session.id}/message`)
-        expect(res.status).toBe(200)
-        const body = yield* json<SessionV1.WithParts[]>(res)
-        expect(body.map((item) => item.info.id)).toEqual(ids)
-      }),
-    ),
-    { git: true },
-  )
-
-  it.instance(
-    "rejects invalid cursors and missing sessions",
-    withoutWatcher(
-      Effect.gen(function* () {
-        const session = yield* sessionScoped
-
-        const bad = yield* request(`/session/${session.id}/message?limit=2&before=bad`)
-        expect(bad.status).toBe(400)
-
-        const miss = yield* request(`/session/ses_missing/message?limit=2`)
-        expect(miss.status).toBe(404)
-      }),
-    ),
-    { git: true },
-  )
-
-  it.instance(
-    "does not truncate large legacy limit requests",
-    withoutWatcher(
-      Effect.gen(function* () {
-        const session = yield* sessionScoped
-        yield* fill(session.id, 520)
-
-        const res = yield* request(`/session/${session.id}/message?limit=510`)
-        expect(res.status).toBe(200)
-        const body = yield* json<SessionV1.WithParts[]>(res)
-        expect(body).toHaveLength(510)
-      }),
-    ),
-    { git: true },
-  )
-
-  it.instance(
-    "accepts directory query used by workspace routing",
-    withoutWatcher(
-      Effect.gen(function* () {
-        const tmp = yield* TestInstance
-        const session = yield* sessionScoped
-        yield* fill(session.id, 1)
-
-        const res = yield* request(
-          `/session/${session.id}/message?limit=80&directory=${encodeURIComponent(tmp.directory)}`,
-        )
-        expect(res.status).toBe(200)
-        const body = yield* json<unknown[]>(res)
-        expect(Array.isArray(body)).toBe(true)
-        expect(body).toHaveLength(1)
-      }),
-    ),
-    { git: true },
-  )
-})

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

@@ -1,66 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Session } from "@/session/session"
-import { TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
-
-const it = testEffect(Layer.mergeAll(Session.defaultLayer, httpApiLayer))
-
-describe("tui.selectSession endpoint", () => {
-  it.instance(
-    "should return 200 when called with valid session",
-    () =>
-      Effect.gen(function* () {
-        const tmp = yield* TestInstance
-        const session = yield* Session.use.create({})
-
-        const response = yield* requestInDirectory("/tui/select-session", tmp.directory, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: session.id }),
-        })
-
-        expect(response.status).toBe(200)
-        const body = yield* response.json
-        expect(body).toBe(true)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "should return 404 when session does not exist",
-    () =>
-      Effect.gen(function* () {
-        const tmp = yield* TestInstance
-        const nonExistentSessionID = "ses_nonexistent123"
-
-        const response = yield* requestInDirectory("/tui/select-session", tmp.directory, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: nonExistentSessionID }),
-        })
-
-        expect(response.status).toBe(404)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "should return 400 when session ID format is invalid",
-    () =>
-      Effect.gen(function* () {
-        const tmp = yield* TestInstance
-        const invalidSessionID = "invalid_session_id"
-
-        const response = yield* requestInDirectory("/tui/select-session", tmp.directory, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ sessionID: invalidSessionID }),
-        })
-
-        expect(response.status).toBe(400)
-      }),
-    { git: true },
-  )
-})