@miaws/miaw 1.18.5 → 1.18.6

package/test/account/service.test.ts

@@ -1,453 +0,0 @@
-import { expect } from "bun:test"
-import { Duration, Effect, Layer, Option, Schema } from "effect"
-import { sql } from "drizzle-orm"
-import { HttpClient, HttpClientError, HttpClientResponse } from "effect/unstable/http"
-
-import { AccountRepo } from "../../src/account/repo"
-import { Account } from "../../src/account/account"
-import {
-  AccessToken,
-  AccountID,
-  AccountTransportError,
-  DeviceCode,
-  Login,
-  Org,
-  OrgID,
-  RefreshToken,
-  UserCode,
-} from "../../src/account/schema"
-import { Database } from "@miaw/core/database/database"
-import { testEffect } from "../lib/effect"
-
-const truncate = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const { db } = yield* Database.Service
-    yield* db.run(sql`DELETE FROM account_state`)
-    yield* db.run(sql`DELETE FROM account`)
-  }),
-).pipe(Layer.provide(Database.defaultLayer))
-
-const it = testEffect(Layer.merge(AccountRepo.defaultLayer, truncate))
-
-const insideEagerRefreshWindow = Duration.toMillis(Duration.minutes(1))
-const outsideEagerRefreshWindow = Duration.toMillis(Duration.minutes(10))
-
-const live = (client: HttpClient.HttpClient) =>
-  Account.layer.pipe(Layer.provide(Layer.succeed(HttpClient.HttpClient, client)))
-
-const json = (req: Parameters<typeof HttpClientResponse.fromWeb>[0], body: unknown, status = 200) =>
-  HttpClientResponse.fromWeb(
-    req,
-    new Response(JSON.stringify(body), {
-      status,
-      headers: { "content-type": "application/json" },
-    }),
-  )
-
-const encodeOrg = Schema.encodeSync(Org)
-
-const org = (id: string, name: string) => encodeOrg(new Org({ id: OrgID.make(id), name }))
-
-const login = () =>
-  new Login({
-    code: DeviceCode.make("device-code"),
-    user: UserCode.make("user-code"),
-    url: "https://one.example.com/verify",
-    server: "https://one.example.com",
-    expiry: Duration.seconds(600),
-    interval: Duration.seconds(5),
-  })
-
-const deviceTokenClient = (body: unknown, status = 400) =>
-  HttpClient.make((req) =>
-    Effect.succeed(
-      req.url === "https://one.example.com/auth/device/token" ? json(req, body, status) : json(req, {}, 404),
-    ),
-  )
-
-const poll = (body: unknown, status = 400) =>
-  Account.Service.use((s) => s.poll(login())).pipe(Effect.provide(live(deviceTokenClient(body, status))))
-
-it.live("login normalizes trailing slashes in the provided server URL", () =>
-  Effect.gen(function* () {
-    const seen: Array<string> = []
-    const client = HttpClient.make((req) =>
-      Effect.gen(function* () {
-        seen.push(`${req.method} ${req.url}`)
-
-        if (req.url === "https://one.example.com/auth/device/code") {
-          return json(req, {
-            device_code: "device-code",
-            user_code: "user-code",
-            verification_uri_complete: "/device?user_code=user-code",
-            expires_in: 600,
-            interval: 5,
-          })
-        }
-
-        return json(req, {}, 404)
-      }),
-    )
-
-    const result = yield* Account.use.login("https://one.example.com/").pipe(Effect.provide(live(client)))
-
-    expect(seen).toEqual(["POST https://one.example.com/auth/device/code"])
-    expect(result.server).toBe("https://one.example.com")
-    expect(result.url).toBe("https://one.example.com/device?user_code=user-code")
-  }),
-)
-
-it.live("login maps transport failures to account transport errors", () =>
-  Effect.gen(function* () {
-    const client = HttpClient.make((req) =>
-      Effect.fail(
-        new HttpClientError.HttpClientError({
-          reason: new HttpClientError.TransportError({ request: req }),
-        }),
-      ),
-    )
-
-    const error = yield* Effect.flip(Account.use.login("https://one.example.com").pipe(Effect.provide(live(client))))
-
-    expect(error).toBeInstanceOf(AccountTransportError)
-    if (error instanceof AccountTransportError) {
-      expect(error.method).toBe("POST")
-      expect(error.url).toBe("https://one.example.com/auth/device/code")
-    }
-  }),
-)
-
-it.live("orgsByAccount groups orgs per account", () =>
-  Effect.gen(function* () {
-    yield* AccountRepo.Service.use((r) =>
-      r.persistAccount({
-        id: AccountID.make("user-1"),
-        email: "one@example.com",
-        url: "https://one.example.com",
-        accessToken: AccessToken.make("at_1"),
-        refreshToken: RefreshToken.make("rt_1"),
-        expiry: Date.now() + outsideEagerRefreshWindow,
-        orgID: Option.none(),
-      }),
-    )
-
-    yield* AccountRepo.Service.use((r) =>
-      r.persistAccount({
-        id: AccountID.make("user-2"),
-        email: "two@example.com",
-        url: "https://two.example.com",
-        accessToken: AccessToken.make("at_2"),
-        refreshToken: RefreshToken.make("rt_2"),
-        expiry: Date.now() + outsideEagerRefreshWindow,
-        orgID: Option.none(),
-      }),
-    )
-
-    const seen: Array<string> = []
-    const client = HttpClient.make((req) =>
-      Effect.gen(function* () {
-        seen.push(`${req.method} ${req.url}`)
-
-        if (req.url === "https://one.example.com/api/orgs") {
-          return json(req, [org("org-1", "One")])
-        }
-
-        if (req.url === "https://two.example.com/api/orgs") {
-          return json(req, [org("org-2", "Two A"), org("org-3", "Two B")])
-        }
-
-        return json(req, [], 404)
-      }),
-    )
-
-    const rows = yield* Account.use.orgsByAccount().pipe(Effect.provide(live(client)))
-
-    expect(rows.map((row) => [row.account.id, row.orgs.map((org) => org.id)]).map(([id, orgs]) => [id, orgs])).toEqual([
-      [AccountID.make("user-1"), [OrgID.make("org-1")]],
-      [AccountID.make("user-2"), [OrgID.make("org-2"), OrgID.make("org-3")]],
-    ])
-    expect(seen).toEqual(["GET https://one.example.com/api/orgs", "GET https://two.example.com/api/orgs"])
-  }),
-)
-
-it.live("token refresh persists the new token", () =>
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.Service.use((r) =>
-      r.persistAccount({
-        id,
-        email: "user@example.com",
-        url: "https://one.example.com",
-        accessToken: AccessToken.make("at_old"),
-        refreshToken: RefreshToken.make("rt_old"),
-        expiry: Date.now() - 1_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    const client = HttpClient.make((req) =>
-      Effect.succeed(
-        req.url === "https://one.example.com/auth/device/token"
-          ? json(req, {
-              access_token: "at_new",
-              refresh_token: "rt_new",
-              expires_in: 60,
-            })
-          : json(req, {}, 404),
-      ),
-    )
-
-    const token = yield* Account.use.token(id).pipe(Effect.provide(live(client)))
-
-    expect(Option.getOrThrow(token)).toBeDefined()
-    expect(String(Option.getOrThrow(token))).toBe("at_new")
-
-    const row = yield* AccountRepo.use.getRow(id)
-    const value = Option.getOrThrow(row)
-    expect(value.access_token).toBe(AccessToken.make("at_new"))
-    expect(value.refresh_token).toBe(RefreshToken.make("rt_new"))
-    expect(value.token_expiry).toBeGreaterThan(Date.now())
-  }),
-)
-
-it.live("token refreshes before expiry when inside the eager refresh window", () =>
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.Service.use((r) =>
-      r.persistAccount({
-        id,
-        email: "user@example.com",
-        url: "https://one.example.com",
-        accessToken: AccessToken.make("at_old"),
-        refreshToken: RefreshToken.make("rt_old"),
-        expiry: Date.now() + insideEagerRefreshWindow,
-        orgID: Option.none(),
-      }),
-    )
-
-    let refreshCalls = 0
-    const client = HttpClient.make((req) =>
-      Effect.promise(async () => {
-        if (req.url === "https://one.example.com/auth/device/token") {
-          refreshCalls += 1
-          return json(req, {
-            access_token: "at_new",
-            refresh_token: "rt_new",
-            expires_in: 60,
-          })
-        }
-
-        return json(req, {}, 404)
-      }),
-    )
-
-    const token = yield* Account.use.token(id).pipe(Effect.provide(live(client)))
-
-    expect(String(Option.getOrThrow(token))).toBe("at_new")
-    expect(refreshCalls).toBe(1)
-
-    const row = yield* AccountRepo.use.getRow(id)
-    const value = Option.getOrThrow(row)
-    expect(value.access_token).toBe(AccessToken.make("at_new"))
-    expect(value.refresh_token).toBe(RefreshToken.make("rt_new"))
-  }),
-)
-
-it.live("concurrent config and token requests coalesce token refresh", () =>
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.Service.use((r) =>
-      r.persistAccount({
-        id,
-        email: "user@example.com",
-        url: "https://one.example.com",
-        accessToken: AccessToken.make("at_old"),
-        refreshToken: RefreshToken.make("rt_old"),
-        expiry: Date.now() - 1_000,
-        orgID: Option.some(OrgID.make("org-9")),
-      }),
-    )
-
-    let refreshCalls = 0
-    const client = HttpClient.make((req) =>
-      Effect.promise(async () => {
-        if (req.url === "https://one.example.com/auth/device/token") {
-          refreshCalls += 1
-
-          if (refreshCalls === 1) {
-            await new Promise((resolve) => setTimeout(resolve, 25))
-            return json(req, {
-              access_token: "at_new",
-              refresh_token: "rt_new",
-              expires_in: 60,
-            })
-          }
-
-          return json(
-            req,
-            {
-              error: "invalid_grant",
-              error_description: "refresh token already used",
-            },
-            400,
-          )
-        }
-
-        if (req.url === "https://one.example.com/api/config") {
-          return json(req, { config: { theme: "light", seats: 5 } })
-        }
-
-        return json(req, {}, 404)
-      }),
-    )
-
-    const [cfg, token] = yield* Account.Service.use((s) =>
-      Effect.all([s.config(id, OrgID.make("org-9")), s.token(id)], { concurrency: 2 }),
-    ).pipe(Effect.provide(live(client)))
-
-    expect(Option.getOrThrow(cfg)).toEqual({ theme: "light", seats: 5 })
-    expect(String(Option.getOrThrow(token))).toBe("at_new")
-    expect(refreshCalls).toBe(1)
-
-    const row = yield* AccountRepo.use.getRow(id)
-    const value = Option.getOrThrow(row)
-    expect(value.access_token).toBe(AccessToken.make("at_new"))
-    expect(value.refresh_token).toBe(RefreshToken.make("rt_new"))
-  }),
-)
-
-it.live("config sends the selected org header", () =>
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.Service.use((r) =>
-      r.persistAccount({
-        id,
-        email: "user@example.com",
-        url: "https://one.example.com",
-        accessToken: AccessToken.make("at_1"),
-        refreshToken: RefreshToken.make("rt_1"),
-        expiry: Date.now() + outsideEagerRefreshWindow,
-        orgID: Option.none(),
-      }),
-    )
-
-    const seen: { auth?: string; org?: string } = {}
-    const client = HttpClient.make((req) =>
-      Effect.gen(function* () {
-        seen.auth = req.headers.authorization
-        seen.org = req.headers["x-org-id"]
-
-        if (req.url === "https://one.example.com/api/config") {
-          return json(req, { config: { theme: "light", seats: 5 } })
-        }
-
-        return json(req, {}, 404)
-      }),
-    )
-
-    const cfg = yield* Account.Service.use((s) => s.config(id, OrgID.make("org-9"))).pipe(Effect.provide(live(client)))
-
-    expect(Option.getOrThrow(cfg)).toEqual({ theme: "light", seats: 5 })
-    expect(seen).toEqual({
-      auth: "Bearer at_1",
-      org: "org-9",
-    })
-  }),
-)
-
-it.live("poll stores the account and first org on success", () =>
-  Effect.gen(function* () {
-    const client = HttpClient.make((req) =>
-      Effect.succeed(
-        req.url === "https://one.example.com/auth/device/token"
-          ? json(req, {
-              access_token: "at_1",
-              refresh_token: "rt_1",
-              token_type: "Bearer",
-              expires_in: 60,
-            })
-          : req.url === "https://one.example.com/api/user"
-            ? json(req, { id: "user-1", email: "user@example.com" })
-            : req.url === "https://one.example.com/api/orgs"
-              ? json(req, [org("org-1", "One")])
-              : json(req, {}, 404),
-      ),
-    )
-
-    const res = yield* Account.Service.use((s) => s.poll(login())).pipe(Effect.provide(live(client)))
-
-    expect(res._tag).toBe("PollSuccess")
-    if (res._tag === "PollSuccess") {
-      expect(res.email).toBe("user@example.com")
-    }
-
-    const active = yield* AccountRepo.use.active()
-    expect(Option.getOrThrow(active)).toEqual(
-      expect.objectContaining({
-        id: "user-1",
-        email: "user@example.com",
-        active_org_id: "org-1",
-      }),
-    )
-  }),
-)
-
-for (const [name, body, expectedTag] of [
-  [
-    "pending",
-    {
-      error: "authorization_pending",
-      error_description: "The authorization request is still pending",
-    },
-    "PollPending",
-  ],
-  [
-    "slow",
-    {
-      error: "slow_down",
-      error_description: "Polling too frequently, please slow down",
-    },
-    "PollSlow",
-  ],
-  [
-    "denied",
-    {
-      error: "access_denied",
-      error_description: "The authorization request was denied",
-    },
-    "PollDenied",
-  ],
-  [
-    "expired",
-    {
-      error: "expired_token",
-      error_description: "The device code has expired",
-    },
-    "PollExpired",
-  ],
-] as const) {
-  it.live(`poll returns ${name} for ${body.error}`, () =>
-    Effect.gen(function* () {
-      const result = yield* poll(body)
-      expect(result._tag).toBe(expectedTag)
-    }),
-  )
-}
-
-it.live("poll returns poll error for other OAuth errors", () =>
-  Effect.gen(function* () {
-    const result = yield* poll({
-      error: "server_error",
-      error_description: "An unexpected error occurred",
-    })
-
-    expect(result._tag).toBe("PollError")
-    if (result._tag === "PollError") {
-      expect(String(result.cause)).toContain("server_error")
-    }
-  }),
-)

package/test/acp/config-option.test.ts

@@ -1,229 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  buildConfigOptions,
-  buildEffortSelectOption,
-  buildModeSelectOption,
-  buildModelSelectOption,
-  formatCurrentModelId,
-  formatVariantName,
-  parseModelSelection,
-  type ConfigOptionProvider,
-} from "@/acp/config-option"
-
-const providers: ConfigOptionProvider[] = [
-  {
-    id: "anthropic",
-    name: "Anthropic",
-    models: {
-      "claude/sonnet-4": {
-        id: "claude/sonnet-4",
-        name: "Claude Sonnet 4",
-        variants: {
-          default: {},
-          high: {},
-          "very-high": {},
-        },
-      },
-      "claude-haiku": {
-        id: "claude-haiku",
-        name: "Claude Haiku",
-      },
-    },
-  },
-  {
-    id: "openai",
-    name: "OpenAI",
-    models: {
-      "gpt-5": {
-        id: "gpt-5",
-        name: "GPT-5",
-        variants: {
-          minimal: {},
-          low: {},
-        },
-      },
-    },
-  },
-]
-
-describe("acp config options", () => {
-  test("builds the model select option with ACP verifier category", () => {
-    expect(
-      buildModelSelectOption({
-        providers,
-        currentModel: { providerID: "anthropic", modelID: "claude/sonnet-4" },
-        currentVariant: "high",
-      }),
-    ).toEqual({
-      id: "model",
-      name: "Model",
-      category: "model",
-      type: "select",
-      currentValue: "anthropic/claude/sonnet-4",
-      options: [
-        { value: "anthropic/claude-haiku", name: "Anthropic/Claude Haiku" },
-        { value: "anthropic/claude/sonnet-4", name: "Anthropic/Claude Sonnet 4" },
-        { value: "openai/gpt-5", name: "OpenAI/GPT-5" },
-      ],
-    })
-  })
-
-  test("includes variant ids in the model option only when requested", () => {
-    const option = buildModelSelectOption({
-      providers,
-      currentModel: { providerID: "anthropic", modelID: "claude/sonnet-4" },
-      currentVariant: "high",
-      includeVariants: true,
-    })
-
-    expect(option.currentValue).toBe("anthropic/claude/sonnet-4/high")
-    if (option.type !== "select") throw new Error("expected select option")
-    expect(option.options).toContainEqual({
-      value: "anthropic/claude/sonnet-4/high",
-      name: "Anthropic/Claude Sonnet 4 (High)",
-    })
-    expect(option.options).not.toContainEqual({
-      value: "anthropic/claude/sonnet-4/default",
-      name: "Anthropic/Claude Sonnet 4 (Default)",
-    })
-  })
-
-  test("builds effort option from variants and falls back to default when current variant is invalid", () => {
-    expect(buildEffortSelectOption({ variants: ["low", "default", "high"], currentVariant: "missing" })).toEqual({
-      id: "effort",
-      name: "Effort",
-      description: "Available effort levels for this model",
-      category: "thought_level",
-      type: "select",
-      currentValue: "default",
-      options: [
-        { value: "low", name: "Low" },
-        { value: "default", name: "Default" },
-        { value: "high", name: "High" },
-      ],
-    })
-  })
-
-  test("effort fallback uses the first variant when default is absent", () => {
-    expect(buildEffortSelectOption({ variants: ["minimal", "low"], currentVariant: "missing" })?.currentValue).toBe(
-      "minimal",
-    )
-  })
-
-  test("omits effort option when there are no variants", () => {
-    expect(buildEffortSelectOption({ variants: [] })).toBeUndefined()
-  })
-
-  test("builds the mode select option with descriptions when present", () => {
-    expect(
-      buildModeSelectOption({
-        currentModeId: "build",
-        modes: [
-          { id: "build", name: "Build", description: "Make code changes" },
-          { id: "plan", name: "Plan" },
-        ],
-      }),
-    ).toEqual({
-      id: "mode",
-      name: "Session Mode",
-      category: "mode",
-      type: "select",
-      currentValue: "build",
-      options: [
-        { value: "build", name: "Build", description: "Make code changes" },
-        { value: "plan", name: "Plan" },
-      ],
-    })
-  })
-
-  test("builds full config options with model, effort, and mode in stable order", () => {
-    const options = buildConfigOptions({
-      providers,
-      currentModel: { providerID: "anthropic", modelID: "claude/sonnet-4" },
-      currentVariant: "very-high",
-      modes: [
-        { id: "build", name: "Build" },
-        { id: "plan", name: "Plan" },
-      ],
-      currentModeId: "plan",
-    })
-
-    expect(options.map((option) => option.id)).toEqual(["model", "effort", "mode"])
-    expect(options.map((option) => option.category)).toEqual(["model", "thought_level", "mode"])
-    expect(options[1]?.currentValue).toBe("very-high")
-  })
-
-  test("full config options omit effort for models without variants", () => {
-    expect(
-      buildConfigOptions({
-        providers,
-        currentModel: { providerID: "anthropic", modelID: "claude-haiku" },
-      }).map((option) => option.id),
-    ).toEqual(["model"])
-  })
-
-  test("parses provider/model selections", () => {
-    expect(parseModelSelection("openai/gpt-5", providers)).toEqual({
-      model: { providerID: "openai", modelID: "gpt-5" },
-    })
-  })
-
-  test("parses provider/model/variant selections when the base model exposes that variant", () => {
-    expect(parseModelSelection("openai/gpt-5/low", providers)).toEqual({
-      model: { providerID: "openai", modelID: "gpt-5" },
-      variant: "low",
-    })
-  })
-
-  test("prefers exact slash-containing model ids before treating the tail as a variant", () => {
-    expect(parseModelSelection("anthropic/claude/sonnet-4", providers)).toEqual({
-      model: { providerID: "anthropic", modelID: "claude/sonnet-4" },
-    })
-  })
-
-  test("parses trailing variants for slash-containing model ids", () => {
-    expect(parseModelSelection("anthropic/claude/sonnet-4/high", providers)).toEqual({
-      model: { providerID: "anthropic", modelID: "claude/sonnet-4" },
-      variant: "high",
-    })
-  })
-
-  test("keeps unknown trailing segments in the model id when they are not valid variants", () => {
-    expect(parseModelSelection("anthropic/claude/sonnet-4/missing", providers)).toEqual({
-      model: { providerID: "anthropic", modelID: "claude/sonnet-4/missing" },
-    })
-  })
-
-  test("formats current model ids with and without selected variants", () => {
-    expect(
-      formatCurrentModelId({
-        model: { providerID: "openai", modelID: "gpt-5" },
-        variant: "low",
-        variants: ["minimal", "low"],
-      }),
-    ).toBe("openai/gpt-5")
-    expect(
-      formatCurrentModelId({
-        model: { providerID: "openai", modelID: "gpt-5" },
-        variant: "low",
-        variants: ["minimal", "low"],
-        includeVariant: true,
-      }),
-    ).toBe("openai/gpt-5/low")
-  })
-
-  test("formats current model ids with variant fallback", () => {
-    expect(
-      formatCurrentModelId({
-        model: { providerID: "anthropic", modelID: "claude/sonnet-4" },
-        variant: "missing",
-        variants: ["default", "high"],
-        includeVariant: true,
-      }),
-    ).toBe("anthropic/claude/sonnet-4/default")
-  })
-
-  test("formats variant names for display", () => {
-    expect(formatVariantName("very_high-effort")).toBe("Very High Effort")
-  })
-})