@miaws/miaw 1.18.5 → 1.18.6

package/test/server/httpapi-error-middleware.test.ts

@@ -1,101 +0,0 @@
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
-import { NamedError } from "@miaw/core/util/error"
-import { describe, expect } from "bun:test"
-import { ConfigErrorV1 } from "@miaw/core/v1/config/error"
-import { Effect, Layer } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter } from "effect/unstable/http"
-import { errorLayer } from "../../src/server/routes/instance/httpapi/middleware/error"
-import { NotFoundError } from "../../src/storage/storage"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Layer.mergeAll(NodeHttpServer.layerTest, NodeServices.layer))
-
-function expectUnknownErrorBody(body: unknown) {
-  expect(body).toMatchObject({
-    name: "UnknownError",
-    data: { message: "Unexpected server error. Check server logs for details." },
-  })
-  expect((body as { data?: { ref?: unknown } }).data?.ref).toMatch(/^err_[0-9a-f-]{8}$/)
-}
-
-describe("HttpApi error middleware", () => {
-  it.live("returns a safe body for unknown 500 defects", () =>
-    Effect.gen(function* () {
-      yield* HttpRouter.add("GET", "/boom", Effect.die(new Error("secret stack marker"))).pipe(
-        Layer.provide(errorLayer),
-        HttpRouter.serve,
-        Layer.build,
-      )
-
-      const response = yield* HttpClientRequest.get("/boom").pipe(HttpClient.execute)
-      const body = yield* response.json
-
-      expect(response.status).toBe(500)
-      expectUnknownErrorBody(body)
-      expect(JSON.stringify(body)).not.toContain("secret stack marker")
-    }),
-  )
-
-  it.live("returns a safe body for named defects", () =>
-    Effect.gen(function* () {
-      yield* HttpRouter.add(
-        "GET",
-        "/named",
-        Effect.die(new NamedError.Unknown({ message: "secret named marker" })),
-      ).pipe(Layer.provide(errorLayer), HttpRouter.serve, Layer.build)
-
-      const response = yield* HttpClientRequest.get("/named").pipe(HttpClient.execute)
-      const body = yield* response.json
-
-      expect(response.status).toBe(500)
-      expectUnknownErrorBody(body)
-      expect(JSON.stringify(body)).not.toContain("secret named marker")
-    }),
-  )
-
-  it.live("returns invalid config defects as structured client errors", () =>
-    Effect.gen(function* () {
-      const configError = new ConfigErrorV1.InvalidError({
-        path: "/tmp/miaw.json",
-        issues: [{ message: "Expected object", path: ["provider", "anthropic", "options"] }],
-      })
-
-      yield* HttpRouter.add("GET", "/config-error", Effect.die(configError)).pipe(
-        Layer.provide(errorLayer),
-        HttpRouter.serve,
-        Layer.build,
-      )
-
-      const response = yield* HttpClientRequest.get("/config-error").pipe(HttpClient.execute)
-      const body = yield* response.json
-      const serialized = JSON.stringify(body)
-
-      expect(response.status).toBe(400)
-      expect(body).toMatchObject({
-        name: "ConfigInvalidError",
-        data: {
-          path: "/tmp/miaw.json",
-          issues: [{ message: "Expected object", path: ["provider", "anthropic", "options"] }],
-        },
-      })
-      expect(serialized).toContain("/tmp/miaw.json")
-      expect(serialized).toContain("anthropic")
-    }),
-  )
-
-  it.live("does not map storage not-found defects to 404", () =>
-    Effect.gen(function* () {
-      yield* HttpRouter.add(
-        "GET",
-        "/missing",
-        Effect.die(new NotFoundError({ message: "Resource not found: secret" })),
-      ).pipe(Layer.provide(errorLayer), HttpRouter.serve, Layer.build)
-
-      const response = yield* HttpClientRequest.get("/missing").pipe(HttpClient.execute)
-      const body = yield* response.json
-
-      expect(response.status).toBe(500)
-      expectUnknownErrorBody(body)
-    }),
-  )
-})

package/test/server/httpapi-event.test.ts

@@ -1,94 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer, Queue, Schema, Stream } from "effect"
-import { EventPaths } from "../../src/server/routes/instance/httpapi/groups/event"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
-
-const EventData = Schema.Struct({
-  id: Schema.optional(Schema.String),
-  type: Schema.String,
-  properties: Schema.Record(Schema.String, Schema.Any),
-})
-
-const readEvent = (reader: Queue.Dequeue<Uint8Array>) =>
-  Effect.gen(function* () {
-    const value = yield* Queue.take(reader).pipe(
-      Effect.timeoutOrElse({
-        duration: "5 seconds",
-        orElse: () => Effect.fail(new Error("timed out waiting for event")),
-      }),
-    )
-    return Schema.decodeUnknownSync(EventData)(JSON.parse(new TextDecoder().decode(value).replace(/^data: /, "")))
-  })
-
-const openEventStream = (directory: string) =>
-  Effect.gen(function* () {
-    const response = yield* requestInDirectory(EventPaths.event, directory)
-    const reader = yield* Queue.unbounded<Uint8Array>()
-    yield* response.stream.pipe(
-      Stream.runForEach((value) => Queue.offer(reader, value)),
-      Effect.forkScoped,
-    )
-    return { response, reader }
-  })
-
-afterEach(async () => {
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-const it = testEffect(httpApiLayer)
-
-describe("event HttpApi", () => {
-  it.instance(
-    "serves event stream",
-    () =>
-      Effect.gen(function* () {
-        const { directory } = yield* TestInstance
-        const { response, reader } = yield* openEventStream(directory)
-
-        expect(response.status).toBe(200)
-        expect(response.headers["content-type"]).toContain("text/event-stream")
-        expect(response.headers["cache-control"]).toBe("no-cache, no-transform")
-        expect(response.headers["x-accel-buffering"]).toBe("no")
-        expect(response.headers["x-content-type-options"]).toBe("nosniff")
-        expect(yield* readEvent(reader)).toMatchObject({ type: "server.connected", properties: {} })
-      }),
-    { git: true, config: { formatter: false, lsp: false } },
-  )
-
-  it.instance(
-    "keeps the event stream open after the initial event",
-    () =>
-      Effect.gen(function* () {
-        const { directory } = yield* TestInstance
-        const { reader } = yield* openEventStream(directory)
-        expect(yield* readEvent(reader)).toMatchObject({ type: "server.connected", properties: {} })
-
-        // If no second event arrives within 250ms, the stream is still open.
-        const status = yield* Queue.take(reader).pipe(
-          Effect.as("event" as const),
-          Effect.timeoutOrElse({ duration: "250 millis", orElse: () => Effect.succeed("open" as const) }),
-        )
-        expect(status).toBe("open")
-      }),
-    { git: true, config: { formatter: false, lsp: false } },
-  )
-
-  it.instance(
-    "delivers instance events after the initial event",
-    () =>
-      Effect.gen(function* () {
-        const { directory } = yield* TestInstance
-        const { reader } = yield* openEventStream(directory)
-        expect(yield* readEvent(reader)).toMatchObject({ type: "server.connected", properties: {} })
-
-        const created = yield* requestInDirectory("/session", directory, { method: "POST" })
-        expect(created.status).toBe(200)
-        expect(yield* readEvent(reader)).toMatchObject({ type: "session.created" })
-      }),
-    { git: true, config: { formatter: false, lsp: false } },
-  )
-})

package/test/server/httpapi-exercise/assertions.ts

@@ -1,64 +0,0 @@
-import type { CallResult, JsonObject } from "./types"
-
-export function parse(text: string): unknown {
-  if (!text) return undefined
-  try {
-    return JSON.parse(text) as unknown
-  } catch {
-    return text
-  }
-}
-
-export function looksJson(result: CallResult) {
-  return result.contentType.includes("application/json") || result.text.startsWith("{") || result.text.startsWith("[")
-}
-
-export function stable(value: unknown): string {
-  return JSON.stringify(sort(value))
-}
-
-function sort(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(sort)
-  if (!value || typeof value !== "object") return value
-  return Object.fromEntries(
-    Object.entries(value)
-      .sort(([left], [right]) => left.localeCompare(right))
-      .map(([key, item]) => [key, sort(item)]),
-  )
-}
-
-export function array(value: unknown): asserts value is unknown[] {
-  if (!Array.isArray(value)) throw new Error("expected array")
-}
-
-export function object(value: unknown): asserts value is JsonObject {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("expected object")
-}
-
-export function boolean(value: unknown): asserts value is boolean {
-  if (typeof value !== "boolean") throw new Error("expected boolean")
-}
-
-export function isRecord(value: unknown): value is JsonObject {
-  return !!value && typeof value === "object" && !Array.isArray(value)
-}
-
-export function check(value: boolean, message: string): asserts value {
-  if (!value) throw new Error(message)
-}
-
-export function message(error: unknown) {
-  if (error instanceof Error) return error.message
-  return String(error)
-}
-
-export function pad(value: string, size: number) {
-  return value.length >= size ? value : value + " ".repeat(size - value.length)
-}
-
-export function indent(value: string) {
-  return value
-    .split("\n")
-    .map((line) => `  ${line}`)
-    .join("\n")
-}

package/test/server/httpapi-exercise/backend.ts

@@ -1,144 +0,0 @@
-import { ConfigProvider, Effect, Layer } from "effect"
-import { HttpRouter } from "effect/unstable/http"
-import { parse } from "./assertions"
-import { runtime, type Runtime } from "./runtime"
-import type { ActiveScenario, BackendApp, CallResult, CaptureMode, SeededContext } from "./types"
-
-type CallOptions = {
-  auth?: {
-    password?: string
-    username?: string
-  }
-}
-
-export function call(scenario: ActiveScenario, ctx: SeededContext<unknown>, options: CallOptions = {}) {
-  return Effect.promise(async () =>
-    capture(await app(await runtime(), options).request(toRequest(scenario, ctx)), scenario.capture),
-  )
-}
-
-export function callAuthProbe(scenario: ActiveScenario, credentials: "missing" | "valid" = "missing") {
-  return Effect.promise(async () => {
-    const controller = new AbortController()
-    return Promise.race([
-      Promise.resolve(
-        app(await runtime(), { auth: { password: "secret" } }).request(
-          toAuthProbeRequest(scenario, credentials, controller.signal),
-        ),
-      ).then((response) => capture(response, scenario.capture)),
-      Bun.sleep(1_000).then(() => {
-        controller.abort("auth probe timed out")
-        return {
-          status: 0,
-          contentType: "",
-          text: "auth probe timed out",
-          body: undefined,
-          timedOut: true,
-        }
-      }),
-    ])
-  })
-}
-
-type CachedApp = BackendApp & { readonly dispose: () => Promise<void> }
-
-const appCache: Partial<Record<string, CachedApp>> = {}
-
-export async function disposeApps() {
-  const apps = Object.values(appCache)
-  for (const key of Object.keys(appCache)) delete appCache[key]
-  await Promise.all(apps.flatMap((app) => (app === undefined ? [] : [app.dispose()])))
-}
-
-function app(modules: Runtime, options: CallOptions) {
-  const username = options.auth?.username
-  const password = options.auth?.password
-  const cacheKey = `${username ?? ""}:${password ?? ""}`
-  if (appCache[cacheKey]) return appCache[cacheKey]
-
-  const web = HttpRouter.toWebHandler(
-    modules.HttpApiApp.routes.pipe(
-      Layer.provide(
-        ConfigProvider.layer(
-          ConfigProvider.fromUnknown({ MIAW_SERVER_PASSWORD: password, MIAW_SERVER_USERNAME: username }),
-        ),
-      ),
-    ),
-    { disableLogger: true, memoMap: modules.memoMap },
-  )
-  return (appCache[cacheKey] = {
-    dispose: web.dispose,
-    request(input: string | URL | Request, init?: RequestInit) {
-      return web.handler(
-        input instanceof Request ? input : new Request(new URL(input, "http://localhost"), init),
-        modules.HttpApiApp.context,
-      )
-    },
-  })
-}
-
-function toRequest(scenario: ActiveScenario, ctx: SeededContext<unknown>) {
-  const spec = scenario.request(ctx, ctx.state)
-  return new Request(new URL(spec.path, "http://localhost"), {
-    method: scenario.method,
-    headers: spec.body === undefined ? spec.headers : { "content-type": "application/json", ...spec.headers },
-    body: spec.body === undefined ? undefined : JSON.stringify(spec.body),
-  })
-}
-
-function toAuthProbeRequest(scenario: ActiveScenario, credentials: "missing" | "valid", signal: AbortSignal) {
-  const spec = scenario.authProbe ?? {
-    path: authProbePath(scenario.path),
-    body: scenario.method === "GET" ? undefined : {},
-  }
-  const headers = {
-    ...(spec.body === undefined ? {} : { "content-type": "application/json" }),
-    ...spec.headers,
-    ...(credentials === "valid" ? { authorization: basic("miaw", "secret") } : {}),
-  }
-  return new Request(new URL(spec.path, "http://localhost"), {
-    method: scenario.method,
-    headers,
-    body: spec.body === undefined ? undefined : JSON.stringify(spec.body),
-    signal,
-  })
-}
-
-function basic(username: string, password: string) {
-  return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
-}
-
-function authProbePath(path: string) {
-  return path
-    .replace(/\{([^}]+)\}/g, (_match, key: string) => `auth_${key}`)
-    .replace(/:([^/]+)/g, (_match, key: string) => `auth_${key}`)
-}
-
-async function capture(response: Response, mode: CaptureMode): Promise<CallResult> {
-  const text = mode === "stream" ? await captureStream(response) : await response.text()
-  return {
-    status: response.status,
-    contentType: response.headers.get("content-type") ?? "",
-    text,
-    body: parse(text),
-    timedOut: false,
-  }
-}
-
-async function captureStream(response: Response) {
-  if (!response.body) return ""
-  const reader = response.body.getReader()
-  const read = reader.read().then(
-    (result) => ({ result }),
-    (error: unknown) => ({ error }),
-  )
-  const winner = await Promise.race([read, Bun.sleep(1_000).then(() => ({ timeout: true }))])
-  if ("timeout" in winner) {
-    await reader.cancel("timed out waiting for stream chunk").catch(() => undefined)
-    throw new Error("timed out waiting for stream chunk")
-  }
-  if ("error" in winner) throw winner.error
-  await reader.cancel().catch(() => undefined)
-  if (winner.result.done) return ""
-  return new TextDecoder().decode(winner.result.value)
-}

package/test/server/httpapi-exercise/dsl.ts

@@ -1,210 +0,0 @@
-import { Effect } from "effect"
-import { looksJson } from "./assertions"
-import type {
-  ActiveScenario,
-  AuthPolicy,
-  BuilderState,
-  CallResult,
-  Comparison,
-  Method,
-  ProjectOptions,
-  RequestSpec,
-  ScenarioContext,
-  SeededContext,
-  TodoScenario,
-} from "./types"
-
-class ScenarioBuilder<S = undefined> {
-  private readonly state: BuilderState<S>
-
-  constructor(method: Method, path: string, name: string, auth: AuthPolicy) {
-    this.state = {
-      method,
-      path,
-      name,
-      project: { git: true },
-      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- The unseeded builder state is intentionally undefined until `.seeded(...)` narrows it.
-      seed: () => Effect.succeed(undefined as S),
-      request: (ctx) => ({ path, headers: ctx.headers() }),
-      authProbe: undefined,
-      capture: "full",
-      mutates: false,
-      reset: true,
-      auth,
-    }
-  }
-
-  global() {
-    return this.clone({ project: undefined, request: () => ({ path: this.state.path }) })
-  }
-
-  inProject(project: ProjectOptions = { git: true }) {
-    return this.clone({ project })
-  }
-
-  withLlm() {
-    return this.clone({ project: { ...(this.state.project ?? { git: true }), llm: true } })
-  }
-
-  at(request: BuilderState<S>["request"]) {
-    return this.clone({ request })
-  }
-
-  probe(authProbe: RequestSpec) {
-    return this.clone({ authProbe })
-  }
-
-  mutating() {
-    return this.clone({ mutates: true })
-  }
-
-  preserveDatabase() {
-    return this.clone({ reset: false })
-  }
-
-  stream() {
-    return this.clone({ capture: "stream" })
-  }
-
-  protected() {
-    return this.auth("protected")
-  }
-
-  public() {
-    return this.auth("public")
-  }
-
-  publicBypass() {
-    return this.auth("public-bypass")
-  }
-
-  ticketBypass() {
-    return this.auth("ticket-bypass")
-  }
-
-  private auth(auth: AuthPolicy) {
-    return this.clone({ auth })
-  }
-
-  /** Assert a non-JSON or shape-only response. */
-  ok(status = 200, compare: Comparison = "status") {
-    return this.done(compare, (_ctx, result) =>
-      Effect.sync(() => {
-        if (result.status !== status) throw new Error(`expected ${status}, got ${result.status}: ${result.text}`)
-      }),
-    )
-  }
-
-  status(
-    status = 200,
-    inspect?: (ctx: SeededContext<S>, result: CallResult) => Effect.Effect<void>,
-    compare: Comparison = "status",
-  ) {
-    return this.done(compare, (ctx, result) =>
-      Effect.gen(function* () {
-        if (result.status !== status) throw new Error(`expected ${status}, got ${result.status}: ${result.text}`)
-        if (inspect) yield* inspect(ctx, result)
-      }),
-    )
-  }
-
-  /** Assert JSON status/content-type plus an optional synchronous body check. */
-  json(status = 200, inspect?: (body: unknown, ctx: SeededContext<S>) => void, compare: Comparison = "json") {
-    return this.jsonEffect(status, inspect ? (body, ctx) => Effect.sync(() => inspect(body, ctx)) : undefined, compare)
-  }
-
-  /** Assert JSON status/content-type plus optional Effect assertions, e.g. DB side effects. */
-  jsonEffect(
-    status = 200,
-    inspect?: (body: unknown, ctx: SeededContext<S>) => Effect.Effect<void>,
-    compare: Comparison = "json",
-  ) {
-    return this.done(compare, (ctx, result) =>
-      Effect.gen(function* () {
-        if (result.status !== status) throw new Error(`expected ${status}, got ${result.status}: ${result.text}`)
-        if (!looksJson(result))
-          throw new Error(`expected JSON response, got ${result.contentType || "no content-type"}`)
-        if (inspect) yield* inspect(result.body, ctx)
-      }),
-    )
-  }
-
-  private clone(next: Partial<BuilderState<S>>) {
-    const builder = new ScenarioBuilder<S>(this.state.method, this.state.path, this.state.name, this.state.auth)
-    Object.assign(builder.state, this.state, next)
-    return builder
-  }
-
-  /**
-   * Seed typed state before the HTTP request. The returned value becomes `ctx.state`
-   * for `.at(...)` and assertions, giving stateful route tests type-safe setup.
-   */
-  seeded<Next>(seed: (ctx: ScenarioContext) => Effect.Effect<Next>) {
-    const builder = new ScenarioBuilder<Next>(this.state.method, this.state.path, this.state.name, this.state.auth)
-    Object.assign(builder.state, this.state, { seed })
-    return builder
-  }
-
-  private done(
-    compare: Comparison,
-    expect: (ctx: SeededContext<S>, result: CallResult) => Effect.Effect<void>,
-  ): ActiveScenario {
-    const state = this.state
-    return {
-      kind: "active",
-      method: state.method,
-      path: state.path,
-      name: state.name,
-      project: state.project,
-      seed: state.seed,
-      authProbe: state.authProbe,
-      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- `.seeded(...)` preserves the paired request/state type inside the builder.
-      request: (ctx, seeded) => state.request({ ...ctx, state: seeded as S }),
-      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- `.seeded(...)` preserves the paired assertion/state type inside the builder.
-      expect: (ctx, seeded, result) => expect({ ...ctx, state: seeded as S }, result),
-      compare,
-      capture: state.capture,
-      mutates: state.mutates,
-      reset: state.reset,
-      auth: state.auth,
-    }
-  }
-}
-
-const routes = (auth: AuthPolicy) => ({
-  get: (path: string, name: string) => new ScenarioBuilder("GET", path, name, auth),
-  post: (path: string, name: string) => new ScenarioBuilder("POST", path, name, auth),
-  put: (path: string, name: string) => new ScenarioBuilder("PUT", path, name, auth),
-  patch: (path: string, name: string) => new ScenarioBuilder("PATCH", path, name, auth),
-  delete: (path: string, name: string) => new ScenarioBuilder("DELETE", path, name, auth),
-})
-
-export const http = {
-  protected: routes("protected"),
-  public: routes("public"),
-  publicBypass: routes("public-bypass"),
-  ticketBypass: routes("ticket-bypass"),
-}
-
-export const pending = (method: Method, path: string, name: string, reason: string): TodoScenario => ({
-  kind: "todo",
-  method,
-  path,
-  name,
-  reason,
-})
-
-export function route(template: string, params: Record<string, string>) {
-  return Object.entries(params).reduce(
-    (next, [key, value]) => next.replaceAll(`{${key}}`, value).replaceAll(`:${key}`, value),
-    template,
-  )
-}
-
-export function controlledPtyInput(title: string | undefined) {
-  return {
-    command: "/bin/sh",
-    args: ["-c", "sleep 30"],
-    ...(title ? { title } : {}),
-  }
-}

package/test/server/httpapi-exercise/environment.ts

@@ -1,40 +0,0 @@
-import { Flag } from "@miaw/core/flag/flag"
-import { Effect } from "effect"
-import path from "path"
-
-const preserveExerciseGlobalRoot = !!process.env.MIAW_HTTPAPI_EXERCISE_GLOBAL
-export const exerciseGlobalRoot =
-  process.env.MIAW_HTTPAPI_EXERCISE_GLOBAL ??
-  path.join(process.env.TMPDIR ?? "/tmp", `miaw-httpapi-global-${process.pid}`)
-process.env.XDG_DATA_HOME = path.join(exerciseGlobalRoot, "data")
-process.env.XDG_CONFIG_HOME = path.join(exerciseGlobalRoot, "config")
-process.env.XDG_STATE_HOME = path.join(exerciseGlobalRoot, "state")
-process.env.XDG_CACHE_HOME = path.join(exerciseGlobalRoot, "cache")
-process.env.MIAW_DISABLE_SHARE = "true"
-export const exerciseConfigDirectory = path.join(exerciseGlobalRoot, "config", "miaw")
-export const exerciseDataDirectory = path.join(exerciseGlobalRoot, "data", "miaw")
-
-const preserveExerciseDatabase = !!process.env.MIAW_HTTPAPI_EXERCISE_DB
-export const exerciseDatabasePath =
-  process.env.MIAW_HTTPAPI_EXERCISE_DB ??
-  path.join(process.env.TMPDIR ?? "/tmp", `miaw-httpapi-exercise-${process.pid}.db`)
-process.env.MIAW_DB = exerciseDatabasePath
-Flag.MIAW_DB = exerciseDatabasePath
-
-export const original = {
-  MIAW_SERVER_PASSWORD: Flag.MIAW_SERVER_PASSWORD,
-  MIAW_SERVER_USERNAME: Flag.MIAW_SERVER_USERNAME,
-}
-
-export const cleanupExercisePaths = Effect.promise(async () => {
-  const fs = await import("fs/promises")
-  if (!preserveExerciseDatabase) {
-    await Promise.all(
-      [exerciseDatabasePath, `${exerciseDatabasePath}-wal`, `${exerciseDatabasePath}-shm`].map((file) =>
-        fs.rm(file, { force: true }).catch(() => undefined),
-      ),
-    )
-  }
-  if (!preserveExerciseGlobalRoot)
-    await fs.rm(exerciseGlobalRoot, { recursive: true, force: true }).catch(() => undefined)
-})