@miaws/miaw 1.18.3 → 1.18.5

package/test/question/question.test.ts

@@ -0,0 +1,465 @@
+import { afterEach, expect } from "bun:test"
+import { Cause, Effect, Exit, Fiber, Layer, Queue } from "effect"
+import { Question } from "../../src/question"
+import { InstanceRef } from "../../src/effect/instance-ref"
+import { InstanceStore } from "../../src/project/instance-store"
+import { QuestionID } from "../../src/question/schema"
+import { disposeAllInstances, provideInstance, testInstanceStoreLayer, tmpdirScoped } from "../fixture/fixture"
+import { SessionID } from "../../src/session/schema"
+import { testEffect } from "../lib/effect"
+import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
+import { EventV2Bridge } from "../../src/event-v2-bridge"
+
+const it = testEffect(
+  Layer.mergeAll(Question.layer.pipe(Layer.provideMerge(EventV2Bridge.defaultLayer)), CrossSpawnSpawner.defaultLayer),
+)
+const lifecycle = testEffect(
+  Layer.mergeAll(
+    Question.layer.pipe(Layer.provideMerge(EventV2Bridge.defaultLayer)),
+    CrossSpawnSpawner.defaultLayer,
+    testInstanceStoreLayer,
+  ),
+)
+
+const askEffect = Effect.fn("QuestionTest.ask")(function* (input: {
+  sessionID: SessionID
+  questions: ReadonlyArray<Question.Info>
+  tool?: Question.Tool
+}) {
+  const question = yield* Question.Service
+  return yield* question.ask(input)
+})
+
+const listEffect = Question.Service.use((svc) => svc.list())
+
+const replyEffect = Effect.fn("QuestionTest.reply")(function* (input: {
+  requestID: QuestionID
+  answers: ReadonlyArray<Question.Answer>
+}) {
+  const question = yield* Question.Service
+  yield* question.reply(input)
+})
+
+const rejectEffect = Effect.fn("QuestionTest.reject")(function* (id: QuestionID) {
+  const question = yield* Question.Service
+  yield* question.reject(id)
+})
+
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
+/** Reject all pending questions so dangling Deferred fibers don't hang the test. */
+const rejectAll = Effect.gen(function* () {
+  yield* Effect.forEach(yield* listEffect, (req) => rejectEffect(req.id), { discard: true })
+})
+
+const waitForPending = Effect.fn("QuestionTest.waitForPending")(function* (count: number) {
+  const question = yield* Question.Service
+  const events = yield* EventV2Bridge.Service
+  const asked = yield* Queue.unbounded<void>()
+  const off = yield* events.listen((event) => {
+    if (event.type === Question.Event.Asked.type) Queue.offerUnsafe(asked, undefined)
+    return Effect.void
+  })
+  yield* Effect.addFinalizer(() => off)
+
+  for (;;) {
+    const pending = yield* question.list()
+    if (pending.length === count) return pending
+    yield* Queue.take(asked).pipe(Effect.timeout("2 seconds"))
+  }
+})
+
+it.instance(
+  "ask - remains pending until answered",
+  () =>
+    Effect.gen(function* () {
+      const fiber = yield* askEffect({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [
+              { label: "Option 1", description: "First option" },
+              { label: "Option 2", description: "Second option" },
+            ],
+          },
+        ],
+      }).pipe(Effect.forkScoped)
+
+      expect(yield* waitForPending(1)).toHaveLength(1)
+      yield* rejectAll
+      expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
+    }),
+  { git: true },
+)
+
+it.instance(
+  "ask - adds to pending list",
+  () =>
+    Effect.gen(function* () {
+      const questions = [
+        {
+          question: "What would you like to do?",
+          header: "Action",
+          options: [
+            { label: "Option 1", description: "First option" },
+            { label: "Option 2", description: "Second option" },
+          ],
+        },
+      ]
+
+      const fiber = yield* askEffect({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      }).pipe(Effect.forkScoped)
+
+      const pending = yield* waitForPending(1)
+      expect(pending.length).toBe(1)
+      expect(pending[0].questions).toEqual(questions)
+      yield* rejectAll
+      expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
+    }),
+  { git: true },
+)
+
+// reply tests
+
+it.instance(
+  "reply - resolves the pending ask with answers",
+  () =>
+    Effect.gen(function* () {
+      const questions = [
+        {
+          question: "What would you like to do?",
+          header: "Action",
+          options: [
+            { label: "Option 1", description: "First option" },
+            { label: "Option 2", description: "Second option" },
+          ],
+        },
+      ]
+
+      const fiber = yield* askEffect({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      }).pipe(Effect.forkScoped)
+
+      const pending = yield* waitForPending(1)
+      const requestID = pending[0].id
+
+      yield* replyEffect({
+        requestID,
+        answers: [["Option 1"]],
+      })
+
+      expect(yield* Fiber.join(fiber)).toEqual([["Option 1"]])
+    }),
+  { git: true },
+)
+
+it.instance(
+  "reply - removes from pending list",
+  () =>
+    Effect.gen(function* () {
+      const fiber = yield* askEffect({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [
+              { label: "Option 1", description: "First option" },
+              { label: "Option 2", description: "Second option" },
+            ],
+          },
+        ],
+      }).pipe(Effect.forkScoped)
+
+      const pending = yield* waitForPending(1)
+      expect(pending.length).toBe(1)
+
+      yield* replyEffect({
+        requestID: pending[0].id,
+        answers: [["Option 1"]],
+      })
+      yield* Fiber.join(fiber)
+
+      const after = yield* listEffect
+      expect(after.length).toBe(0)
+    }),
+  { git: true },
+)
+
+it.instance(
+  "reply - fails for unknown requestID",
+  () =>
+    Effect.gen(function* () {
+      const exit = yield* replyEffect({
+        requestID: QuestionID.make("que_unknown"),
+        answers: [["Option 1"]],
+      }).pipe(Effect.exit)
+      expect(Exit.isFailure(exit)).toBe(true)
+      if (Exit.isFailure(exit)) {
+        expect(Cause.squash(exit.cause)).toMatchObject({ _tag: "Question.NotFoundError", requestID: "que_unknown" })
+      }
+    }),
+  { git: true },
+)
+
+// reject tests
+
+it.instance(
+  "reject - throws RejectedError",
+  () =>
+    Effect.gen(function* () {
+      const fiber = yield* askEffect({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [
+              { label: "Option 1", description: "First option" },
+              { label: "Option 2", description: "Second option" },
+            ],
+          },
+        ],
+      }).pipe(Effect.forkScoped)
+
+      const pending = yield* waitForPending(1)
+      yield* rejectEffect(pending[0].id)
+
+      const exit = yield* Fiber.await(fiber)
+      expect(exit._tag).toBe("Failure")
+      if (exit._tag === "Failure") expect(exit.cause.toString()).toContain("QuestionRejectedError")
+    }),
+  { git: true },
+)
+
+it.instance(
+  "reject - removes from pending list",
+  () =>
+    Effect.gen(function* () {
+      const fiber = yield* askEffect({
+        sessionID: SessionID.make("ses_test"),
+        questions: [
+          {
+            question: "What would you like to do?",
+            header: "Action",
+            options: [
+              { label: "Option 1", description: "First option" },
+              { label: "Option 2", description: "Second option" },
+            ],
+          },
+        ],
+      }).pipe(Effect.forkScoped)
+
+      const pending = yield* waitForPending(1)
+      expect(pending.length).toBe(1)
+
+      yield* rejectEffect(pending[0].id)
+      expect((yield* Fiber.await(fiber))._tag).toBe("Failure")
+
+      const after = yield* listEffect
+      expect(after.length).toBe(0)
+    }),
+  { git: true },
+)
+
+it.instance(
+  "reject - fails for unknown requestID",
+  () =>
+    Effect.gen(function* () {
+      const exit = yield* rejectEffect(QuestionID.make("que_unknown")).pipe(Effect.exit)
+      expect(Exit.isFailure(exit)).toBe(true)
+      if (Exit.isFailure(exit)) {
+        expect(Cause.squash(exit.cause)).toMatchObject({ _tag: "Question.NotFoundError", requestID: "que_unknown" })
+      }
+    }),
+  { git: true },
+)
+
+// multiple questions tests
+
+it.instance(
+  "ask - handles multiple questions",
+  () =>
+    Effect.gen(function* () {
+      const questions = [
+        {
+          question: "What would you like to do?",
+          header: "Action",
+          options: [
+            { label: "Build", description: "Build the project" },
+            { label: "Test", description: "Run tests" },
+          ],
+        },
+        {
+          question: "Which environment?",
+          header: "Env",
+          options: [
+            { label: "Dev", description: "Development" },
+            { label: "Prod", description: "Production" },
+          ],
+        },
+      ]
+
+      const fiber = yield* askEffect({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      }).pipe(Effect.forkScoped)
+
+      const pending = yield* waitForPending(1)
+
+      yield* replyEffect({
+        requestID: pending[0].id,
+        answers: [["Build"], ["Dev"]],
+      })
+
+      expect(yield* Fiber.join(fiber)).toEqual([["Build"], ["Dev"]])
+    }),
+  { git: true },
+)
+
+// list tests
+
+it.instance(
+  "list - returns all pending requests",
+  () =>
+    Effect.gen(function* () {
+      const fiber1 = yield* askEffect({
+        sessionID: SessionID.make("ses_test1"),
+        questions: [
+          {
+            question: "Question 1?",
+            header: "Q1",
+            options: [{ label: "A", description: "A" }],
+          },
+        ],
+      }).pipe(Effect.forkScoped)
+
+      const fiber2 = yield* askEffect({
+        sessionID: SessionID.make("ses_test2"),
+        questions: [
+          {
+            question: "Question 2?",
+            header: "Q2",
+            options: [{ label: "B", description: "B" }],
+          },
+        ],
+      }).pipe(Effect.forkScoped)
+
+      const pending = yield* waitForPending(2)
+      expect(pending.length).toBe(2)
+      yield* rejectAll
+      expect((yield* Fiber.await(fiber1))._tag).toBe("Failure")
+      expect((yield* Fiber.await(fiber2))._tag).toBe("Failure")
+    }),
+  { git: true },
+)
+
+it.instance(
+  "list - returns empty when no pending",
+  () =>
+    Effect.gen(function* () {
+      const pending = yield* listEffect
+      expect(pending.length).toBe(0)
+    }),
+  { git: true },
+)
+
+lifecycle.live("questions stay isolated by directory", () =>
+  Effect.gen(function* () {
+    const one = yield* tmpdirScoped({ git: true })
+    const two = yield* tmpdirScoped({ git: true })
+
+    const fiber1 = yield* askEffect({
+      sessionID: SessionID.make("ses_one"),
+      questions: [
+        {
+          question: "Question 1?",
+          header: "Q1",
+          options: [{ label: "A", description: "A" }],
+        },
+      ],
+    }).pipe(provideInstance(one), Effect.forkScoped)
+
+    const fiber2 = yield* askEffect({
+      sessionID: SessionID.make("ses_two"),
+      questions: [
+        {
+          question: "Question 2?",
+          header: "Q2",
+          options: [{ label: "B", description: "B" }],
+        },
+      ],
+    }).pipe(provideInstance(two), Effect.forkScoped)
+
+    const onePending = yield* waitForPending(1).pipe(provideInstance(one))
+    const twoPending = yield* waitForPending(1).pipe(provideInstance(two))
+
+    expect(onePending.length).toBe(1)
+    expect(twoPending.length).toBe(1)
+    expect(onePending[0].sessionID).toBe(SessionID.make("ses_one"))
+    expect(twoPending[0].sessionID).toBe(SessionID.make("ses_two"))
+
+    yield* rejectEffect(onePending[0].id).pipe(provideInstance(one))
+    yield* rejectEffect(twoPending[0].id).pipe(provideInstance(two))
+
+    expect((yield* Fiber.await(fiber1))._tag).toBe("Failure")
+    expect((yield* Fiber.await(fiber2))._tag).toBe("Failure")
+  }),
+)
+
+lifecycle.live("pending question rejects on instance dispose", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped({ git: true })
+    const fiber = yield* askEffect({
+      sessionID: SessionID.make("ses_dispose"),
+      questions: [
+        {
+          question: "Dispose me?",
+          header: "Dispose",
+          options: [{ label: "Yes", description: "Yes" }],
+        },
+      ],
+    }).pipe(provideInstance(dir), Effect.forkScoped)
+
+    expect(yield* waitForPending(1).pipe(provideInstance(dir))).toHaveLength(1)
+    const ctx = yield* Effect.gen(function* () {
+      return yield* InstanceRef
+    }).pipe(provideInstance(dir))
+    if (!ctx) return yield* Effect.die(new Error("missing test instance"))
+    yield* InstanceStore.Service.use((store) => store.dispose(ctx))
+
+    const exit = yield* Fiber.await(fiber)
+    expect(Exit.isFailure(exit)).toBe(true)
+    if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Question.RejectedError)
+  }),
+)
+
+lifecycle.live("pending question rejects on instance reload", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped({ git: true })
+    const fiber = yield* askEffect({
+      sessionID: SessionID.make("ses_reload"),
+      questions: [
+        {
+          question: "Reload me?",
+          header: "Reload",
+          options: [{ label: "Yes", description: "Yes" }],
+        },
+      ],
+    }).pipe(provideInstance(dir), Effect.forkScoped)
+
+    expect(yield* waitForPending(1).pipe(provideInstance(dir))).toHaveLength(1)
+    yield* InstanceStore.Service.use((store) => store.reload({ directory: dir }))
+
+    const exit = yield* Fiber.await(fiber)
+    expect(Exit.isFailure(exit)).toBe(true)
+    if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Question.RejectedError)
+  }),
+)

package/test/server/AGENTS.md

@@ -0,0 +1,15 @@
+# Server Test Guide
+
+Use these patterns for server and HttpApi middleware tests in this directory.
+
+- Prefer focused middleware tests with tiny fake routes over full API route trees when testing routing, context, proxying, or middleware policy.
+- Use `testEffect(...)` with `NodeHttpServer.layerTest` for the primary in-test server and make relative `HttpClient` requests against it.
+- Use tiny `HttpApiBuilder` probe groups that declare the typed middleware under test and expose context such as `WorkspaceRouteContext`, `InstanceRef`, or `WorkspaceRef`.
+- Declare middleware in the same order as production when testing interactions, for example `InstanceContextMiddleware` followed by `WorkspaceRoutingMiddleware`.
+- For secondary upstream servers, build Effect `NodeHttpServer.layer(...)` into the current test scope with `Layer.build(...)` so the listener stays alive until the test scope exits.
+- Avoid `Bun.serve` when testing Effect HTTP middleware. Keep the test in the Effect HTTP stack unless the production path being tested is Bun-specific.
+- For WebSocket paths, use `Socket.makeWebSocket(...)` from the test client and assert protocol forwarding or frame relay when relevant.
+- Use scoped test layers for flags, database reset, and other global mutable state. Restore flags and reset state in finalizers.
+- Use `tmpdirScoped({ git: true })` plus `Project.use.fromDirectory(dir)` for project-backed requests.
+- If a test needs persisted state without matching runtime state, keep direct database setup inside a narrowly named helper that explains that state.
+- Add comments for non-obvious test topology, especially tests involving both the local test server and a fake upstream server.

package/test/server/auth.test.ts

@@ -0,0 +1,59 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Option, Redacted } from "effect"
+import { Flag } from "@miaw/core/flag/flag"
+import { ServerAuth } from "../../src/server/auth"
+
+const original = {
+  MIAW_SERVER_PASSWORD: Flag.MIAW_SERVER_PASSWORD,
+  MIAW_SERVER_USERNAME: Flag.MIAW_SERVER_USERNAME,
+}
+
+afterEach(() => {
+  Flag.MIAW_SERVER_PASSWORD = original.MIAW_SERVER_PASSWORD
+  Flag.MIAW_SERVER_USERNAME = original.MIAW_SERVER_USERNAME
+})
+
+describe("ServerAuth", () => {
+  test("does not emit auth headers without a password", () => {
+    Flag.MIAW_SERVER_PASSWORD = undefined
+    Flag.MIAW_SERVER_USERNAME = "alice"
+
+    expect(ServerAuth.header()).toBeUndefined()
+    expect(ServerAuth.headers()).toBeUndefined()
+  })
+
+  test("defaults to the miaw username", () => {
+    Flag.MIAW_SERVER_PASSWORD = "secret"
+    Flag.MIAW_SERVER_USERNAME = undefined
+
+    expect(ServerAuth.headers()).toEqual({
+      Authorization: `Basic ${Buffer.from("miaw:secret").toString("base64")}`,
+    })
+  })
+
+  test("uses the configured username", () => {
+    Flag.MIAW_SERVER_PASSWORD = "secret"
+    Flag.MIAW_SERVER_USERNAME = "alice"
+
+    expect(ServerAuth.headers()).toEqual({
+      Authorization: `Basic ${Buffer.from("alice:secret").toString("base64")}`,
+    })
+  })
+
+  test("prefers explicit credentials", () => {
+    Flag.MIAW_SERVER_PASSWORD = "secret"
+    Flag.MIAW_SERVER_USERNAME = "alice"
+
+    expect(ServerAuth.headers({ password: "cli-secret", username: "bob" })).toEqual({
+      Authorization: `Basic ${Buffer.from("bob:cli-secret").toString("base64")}`,
+    })
+  })
+
+  test("validates decoded credentials against effect config", () => {
+    const config = { password: Option.some("secret"), username: "alice" }
+
+    expect(ServerAuth.required(config)).toBe(true)
+    expect(ServerAuth.authorized({ username: "alice", password: Redacted.make("secret") }, config)).toBe(true)
+    expect(ServerAuth.authorized({ username: "miaw", password: Redacted.make("secret") }, config)).toBe(false)
+  })
+})

package/test/server/global-bus.ts

@@ -0,0 +1,31 @@
+import { GlobalBus, type GlobalEvent } from "@/bus/global"
+import { Cause, Effect } from "effect"
+
+export function waitGlobalBusEvent(input: {
+  timeout?: number
+  message?: string
+  predicate: (event: GlobalEvent) => boolean
+}) {
+  return Effect.callback<GlobalEvent, unknown>((resume) => {
+    const cleanup = () => GlobalBus.off("event", handler)
+
+    const handler = (event: GlobalEvent) => {
+      try {
+        if (!input.predicate(event)) return
+        cleanup()
+        resume(Effect.succeed(event))
+      } catch (error) {
+        cleanup()
+        resume(Effect.fail(error))
+      }
+    }
+
+    GlobalBus.on("event", handler)
+    return Effect.sync(cleanup)
+  }).pipe(
+    Effect.timeout(input.timeout ?? 10_000),
+    Effect.mapError((error) =>
+      Cause.isTimeoutError(error) ? new Error(input.message ?? "timed out waiting for global bus event") : error,
+    ),
+  )
+}

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

@@ -0,0 +1,104 @@
+import { describe, expect } from "bun:test"
+import { Deferred, Effect, Layer } from "effect"
+import { Project } from "@/project/project"
+import { Session as SessionNs } from "@/session/session"
+import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
+import { provideInstance, TestInstance, tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(Layer.mergeAll(SessionNs.defaultLayer, Project.defaultLayer, CrossSpawnSpawner.defaultLayer))
+
+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)),
+  )
+
+describe("session.listGlobal", () => {
+  it.instance(
+    "lists sessions across projects with project metadata",
+    () =>
+      Effect.gen(function* () {
+        const first = yield* TestInstance
+        const second = yield* tmpdirScoped({ git: true })
+
+        const firstSession = yield* withSession({ title: "first-session" })
+        const secondSession = yield* withSession({ title: "second-session" }).pipe(provideInstance(second))
+
+        const sessions = yield* SessionNs.Service.use((session) => session.listGlobal({ limit: 200 }))
+        const ids = sessions.map((session) => session.id)
+
+        expect(ids).toContain(firstSession.id)
+        expect(ids).toContain(secondSession.id)
+
+        const firstProject = yield* Project.use.get(firstSession.projectID)
+        const secondProject = yield* Project.use.get(secondSession.projectID)
+
+        const firstItem = sessions.find((session) => session.id === firstSession.id)
+        const secondItem = sessions.find((session) => session.id === secondSession.id)
+
+        expect(firstItem?.project?.id).toBe(firstProject?.id)
+        expect(firstItem?.project?.worktree).toBe(firstProject?.worktree)
+        expect(secondItem?.project?.id).toBe(secondProject?.id)
+        expect(secondItem?.project?.worktree).toBe(secondProject?.worktree)
+        expect(first.directory).not.toBe(second)
+      }),
+    { git: true },
+  )
+
+  it.instance(
+    "excludes archived sessions by default",
+    () =>
+      Effect.gen(function* () {
+        const archived = yield* withSession({ title: "archived-session" })
+
+        yield* SessionNs.Service.use((session) => session.setArchived({ sessionID: archived.id, time: Date.now() }))
+
+        const sessions = yield* SessionNs.Service.use((session) => session.listGlobal({ limit: 200 }))
+        const ids = sessions.map((session) => session.id)
+
+        expect(ids).not.toContain(archived.id)
+
+        const allSessions = yield* SessionNs.Service.use((session) =>
+          session.listGlobal({ limit: 200, archived: true }),
+        )
+        const allIds = allSessions.map((session) => session.id)
+
+        expect(allIds).toContain(archived.id)
+      }),
+    { git: true },
+  )
+
+  it.instance(
+    "supports cursor pagination",
+    () =>
+      Effect.gen(function* () {
+        const test = yield* TestInstance
+
+        const first = yield* withSession({ title: "page-one" })
+        const ready = yield* Deferred.make<void>()
+        yield* Deferred.succeed(ready, undefined).pipe(Effect.delay("5 millis"), Effect.forkScoped)
+        yield* Deferred.await(ready).pipe(
+          Effect.timeoutOrElse({
+            duration: "1 second",
+            orElse: () => Effect.fail(new Error("timed out waiting between session creates")),
+          }),
+        )
+        const second = yield* withSession({ title: "page-two" })
+
+        const page = yield* SessionNs.Service.use((session) =>
+          session.listGlobal({ directory: test.directory, limit: 1 }),
+        )
+        expect(page.length).toBe(1)
+        expect(page[0].id).toBe(second.id)
+
+        const next = yield* SessionNs.Service.use((session) =>
+          session.listGlobal({ directory: test.directory, limit: 10, cursor: page[0].time.updated }),
+        )
+        const ids = next.map((session) => session.id)
+
+        expect(ids).toContain(first.id)
+        expect(ids).not.toContain(second.id)
+      }),
+    { git: true },
+  )
+})