@miaws/miaw 1.18.5 → 1.18.6

package/test/cli/run/variant.shared.test.ts

@@ -1,217 +0,0 @@
-import path from "path"
-import { NodeFileSystem } from "@effect/platform-node"
-import { FSUtil } from "@miaw/core/fs-util"
-import { describe, expect, test } from "bun:test"
-import { Effect, FileSystem, Layer } from "effect"
-import { Global } from "@miaw/core/global"
-import {
-  createVariantRuntime,
-  cycleVariant,
-  formatModelLabel,
-  pickVariant,
-  resolveVariant,
-} from "@/cli/cmd/run/variant.shared"
-import type { SessionMessages } from "@/cli/cmd/run/session.shared"
-import type { RunProvider } from "@/cli/cmd/run/types"
-import { testEffect } from "../../lib/effect"
-
-const model = {
-  providerID: "openai",
-  modelID: "gpt-5",
-}
-
-const providers: RunProvider[] = [
-  {
-    id: "openai",
-    name: "OpenAI",
-    source: "api",
-    env: [],
-    options: {},
-    models: {
-      "gpt-5": {
-        id: "gpt-5",
-        providerID: "openai",
-        api: {
-          id: "gpt-5",
-          url: "https://openai.test",
-          npm: "@ai-sdk/openai",
-        },
-        name: "GPT-5",
-        capabilities: {
-          temperature: true,
-          reasoning: true,
-          attachment: true,
-          toolcall: true,
-          input: {
-            text: true,
-            audio: false,
-            image: false,
-            video: false,
-            pdf: false,
-          },
-          output: {
-            text: true,
-            audio: false,
-            image: false,
-            video: false,
-            pdf: false,
-          },
-          interleaved: false,
-        },
-        cost: {
-          input: 0,
-          output: 0,
-          cache: {
-            read: 0,
-            write: 0,
-          },
-        },
-        limit: {
-          context: 128000,
-          output: 8192,
-        },
-        status: "active",
-        options: {},
-        headers: {},
-        release_date: "2026-01-01",
-      },
-    },
-  },
-]
-
-function userMessage(
-  id: string,
-  input: { providerID: string; modelID: string; variant?: string },
-): SessionMessages[number] {
-  return {
-    info: {
-      id,
-      sessionID: "session-1",
-      role: "user",
-      time: {
-        created: 1,
-      },
-      agent: "build",
-      model: input,
-    },
-    parts: [],
-  }
-}
-
-const it = testEffect(Layer.mergeAll(FSUtil.defaultLayer, NodeFileSystem.layer))
-
-function remap(root: string, file: string) {
-  if (file === Global.Path.state) {
-    return root
-  }
-
-  if (file.startsWith(Global.Path.state + path.sep)) {
-    return path.join(root, path.relative(Global.Path.state, file))
-  }
-
-  return file
-}
-
-function remappedFs(root: string) {
-  return Layer.effect(
-    FSUtil.Service,
-    Effect.gen(function* () {
-      const fs = yield* FSUtil.Service
-      return FSUtil.Service.of({
-        ...fs,
-        readJson: (file) => fs.readJson(remap(root, file)),
-        writeJson: (file, data, mode) => fs.writeJson(remap(root, file), data, mode),
-      })
-    }),
-  ).pipe(Layer.provide(FSUtil.defaultLayer))
-}
-
-describe("run variant shared", () => {
-  test("prefers cli then session then saved variants", () => {
-    expect(resolveVariant("max", "high", "low", ["low", "high"])).toBe("max")
-    expect(resolveVariant(undefined, "high", "low", ["low", "high"])).toBe("high")
-    expect(resolveVariant(undefined, "missing", "low", ["low", "high"])).toBe("low")
-  })
-
-  test("cycles through variants and back to default", () => {
-    expect(cycleVariant(undefined, ["low", "high"])).toBe("low")
-    expect(cycleVariant("low", ["low", "high"])).toBe("high")
-    expect(cycleVariant("high", ["low", "high"])).toBeUndefined()
-    expect(cycleVariant(undefined, [])).toBeUndefined()
-  })
-
-  test("formats model labels", () => {
-    expect(formatModelLabel(model, undefined)).toBe("gpt-5 · openai")
-    expect(formatModelLabel(model, "high")).toBe("gpt-5 · openai · high")
-    expect(formatModelLabel(model, undefined, providers)).toBe("GPT-5 · OpenAI")
-    expect(formatModelLabel(model, "high", providers)).toBe("GPT-5 · OpenAI · high")
-  })
-
-  test("picks the latest matching variant from raw session messages", () => {
-    const msgs: SessionMessages = [
-      userMessage("msg-1", { providerID: "openai", modelID: "gpt-5", variant: "high" }),
-      userMessage("msg-2", { providerID: "anthropic", modelID: "sonnet", variant: "max" }),
-      userMessage("msg-3", { providerID: "openai", modelID: "gpt-5", variant: "minimal" }),
-    ]
-
-    expect(pickVariant(model, msgs)).toBe("minimal")
-  })
-
-  it.live("reads and writes saved variants through a runtime-backed app fs layer", () =>
-    Effect.gen(function* () {
-      const filesys = yield* FileSystem.FileSystem
-      const fs = yield* FSUtil.Service
-      const root = yield* filesys.makeTempDirectoryScoped()
-      const file = path.join(root, "model.json")
-
-      yield* fs.writeJson(file, {
-        recent: [{ providerID: "anthropic", modelID: "sonnet" }],
-        variant: {
-          "openai/gpt-4.1": "low",
-        },
-      })
-
-      const svc = createVariantRuntime(remappedFs(root))
-
-      yield* Effect.promise(() => svc.saveVariant(model, "high"))
-      expect(yield* Effect.promise(() => svc.resolveSavedVariant(model))).toBe("high")
-      expect(yield* fs.readJson(file)).toEqual({
-        recent: [{ providerID: "anthropic", modelID: "sonnet" }],
-        variant: {
-          "openai/gpt-4.1": "low",
-          "openai/gpt-5": "high",
-        },
-      })
-
-      yield* Effect.promise(() => svc.saveVariant(model, undefined))
-      expect(yield* Effect.promise(() => svc.resolveSavedVariant(model))).toBeUndefined()
-      expect(yield* fs.readJson(file)).toEqual({
-        recent: [{ providerID: "anthropic", modelID: "sonnet" }],
-        variant: {
-          "openai/gpt-4.1": "low",
-        },
-      })
-    }),
-  )
-
-  it.live("repairs malformed saved variant state on the next write", () =>
-    Effect.gen(function* () {
-      const filesys = yield* FileSystem.FileSystem
-      const fs = yield* FSUtil.Service
-      const root = yield* filesys.makeTempDirectoryScoped()
-      const file = path.join(root, "model.json")
-
-      yield* filesys.writeFileString(file, "{")
-
-      const svc = createVariantRuntime(remappedFs(root))
-
-      yield* Effect.promise(() => svc.saveVariant(model, "high"))
-      expect(yield* Effect.promise(() => svc.resolveSavedVariant(model))).toBe("high")
-      expect(yield* fs.readJson(file)).toEqual({
-        variant: {
-          "openai/gpt-5": "high",
-        },
-      })
-    }),
-  )
-})

package/test/cli/serve/serve-process.test.ts

@@ -1,61 +0,0 @@
-// Subprocess integration tests for `miaw serve`. Spawns the real CLI in
-// headless mode and exercises it over HTTP — this is the only test tier that
-// catches bugs spanning argv → server boot → routing → instance loading.
-//
-// `serve` is long-lived: the harness returns a handle (url/port/kill/exited)
-// and kills the process when the test scope closes. The OS-assigned port is
-// parsed off the "listening on http://..." line.
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import { cliIt } from "../../lib/cli-process"
-
-describe("miaw serve (subprocess)", () => {
-  // Smoke test: server starts, binds a port, and /global/health responds.
-  // If this fails, all other serve tests likely will too — debug here first.
-  cliIt.live(
-    "starts, binds a port, and serves /global/health",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const server = yield* miaw.serve()
-        expect(server.port).toBeGreaterThan(0)
-        expect(server.url).toMatch(/^http:\/\//)
-
-        const client = yield* HttpClient.HttpClient
-        const res = yield* client.get(`${server.url}/global/health`)
-        expect(res.status).toBe(200)
-        // GlobalHealth schema is { success: true, ... } | { success: false, error }.
-        // We don't lock in further shape here — any 200 with parseable JSON is
-        // enough proof the routing + auth-bypass + instance loading is alive.
-        const body = yield* res.json
-        expect(body).toBeDefined()
-      }),
-    60_000,
-  )
-
-  // The scope-close finalizer must actually terminate the child. Without this
-  // test a regression in the kill path (e.g. a future refactor that forgets
-  // to wire the finalizer) would leak processes on every test run.
-  cliIt.live(
-    "kills the subprocess on scope close",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        // Inner scope so we can observe `.exited` resolving after it closes.
-        const exitedPromise = yield* Effect.scoped(
-          Effect.gen(function* () {
-            const server = yield* miaw.serve()
-            // Capture the Promise, not the resolved value — scope closes after
-            // this gen returns, at which point the finalizer kills the child.
-            return server.exited
-          }),
-        )
-        // After scope close: finalizer fired, process must have exited.
-        const code = yield* Effect.promise(() => exitedPromise)
-        // Bun reports the exit code; SIGTERM-killed processes return non-null
-        // (typically 143 on POSIX). We just require resolution within a sane
-        // window — anything else means the kill didn't take.
-        expect(typeof code === "number" || code === null).toBe(true)
-      }),
-    60_000,
-  )
-})

package/test/cli/smokes/read-only.test.ts

@@ -1,115 +0,0 @@
-// Tier-A smoke tests for read-only commands. Each test asserts only that the
-// command exits 0 and produces *some* output in the isolated harness env.
-//
-// These are not behavioral tests — they're the cheapest possible signal that
-// the dependency-layer wiring (config load, DB init, server boot, provider
-// resolution) doesn't crash for the broad class of "no inputs, no side
-// effects" commands. A regression in any shared layer (an Effect.fail that
-// propagates out of a service constructor, a renamed env var, a broken DB
-// migration) will fail one or more of these tests.
-//
-// If a future change should make one of these commands intentionally fail in
-// an empty env, update the assertion + add a note explaining the new contract.
-//
-// Speed: each test pays ~1.5s for bun startup. 7 tests serialize within this
-// file. See script/prebuild-test-cli.ts for an opt-in pre-built binary that
-// cuts per-spawn cost when this suite gets bigger.
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { cliIt } from "../../lib/cli-process"
-
-describe("miaw read-only commands (smoke)", () => {
-  // `mcp list` reads MCP server config and pings each one. With the empty
-  // MIAW_CONFIG_CONTENT={} we provide, no servers should be configured
-  // and the command should report that cleanly.
-  cliIt.live(
-    "mcp list: exits 0",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const r = yield* miaw.spawn(["mcp", "list"])
-        miaw.expectExit(r, 0, "mcp list")
-      }),
-    60_000,
-  )
-
-  // `providers list` enumerates credentials + env-resolved providers.
-  // (Not config-injected ones — those don't appear here by design.) The
-  // Credentials header always renders; the Environment header only renders
-  // when at least one provider env var is set, which the isolation harness
-  // deliberately doesn't guarantee. Assert the always-present marker so the
-  // test passes on a clean CI runner without env-var leakage.
-  cliIt.live(
-    "providers list: exits 0 and prints the credentials section",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const r = yield* miaw.spawn(["providers", "list"])
-        miaw.expectExit(r, 0, "providers list")
-        expect(r.stdout).toContain("Credentials")
-      }),
-    60_000,
-  )
-
-  // `models` lists models from configured providers. Our test/test-model
-  // should appear because it's wired into the test provider config.
-  cliIt.live(
-    "models: exits 0 and lists the test model",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const r = yield* miaw.spawn(["models"])
-        miaw.expectExit(r, 0, "models")
-        expect(r.stdout).toContain("test/test-model")
-      }),
-    60_000,
-  )
-
-  // `agent list` walks the agent config. Empty config means no agents
-  // configured; the command should still exit 0 with a "no agents" line or
-  // similar. We don't pin the message — just exit cleanly.
-  cliIt.live(
-    "agent list: exits 0",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const r = yield* miaw.spawn(["agent", "list"])
-        miaw.expectExit(r, 0, "agent list")
-      }),
-    60_000,
-  )
-
-  // `session list` reads the session DB. Fresh MIAW_TEST_HOME means
-  // empty DB. Exit 0 with no sessions.
-  cliIt.live(
-    "session list: exits 0",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const r = yield* miaw.spawn(["session", "list"])
-        miaw.expectExit(r, 0, "session list")
-      }),
-    60_000,
-  )
-
-  // `stats` aggregates token usage from the session DB. Empty DB → all zeros.
-  cliIt.live(
-    "stats: exits 0",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const r = yield* miaw.spawn(["stats"])
-        miaw.expectExit(r, 0, "stats")
-      }),
-    60_000,
-  )
-
-  // `db path` prints the DB file location. Under harness isolation the DB
-  // resolves to SQLite's `:memory:` (no on-disk pollution between tests);
-  // in production it'd be a path under MIAW_TEST_HOME / XDG_DATA_HOME.
-  // Accept either form — both prove the resolver ran without crashing.
-  cliIt.live(
-    "db path: exits 0 and prints a path or :memory:",
-    ({ miaw }) =>
-      Effect.gen(function* () {
-        const r = yield* miaw.spawn(["db", "path"])
-        miaw.expectExit(r, 0, "db path")
-        expect(r.stdout.trim()).toMatch(/^(:memory:|[/\\].+\.(db|sqlite|sqlite3))$/i)
-      }),
-    60_000,
-  )
-})

package/test/cli/tui/attach.test.ts

@@ -1,11 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-describe("tui attach", () => {
-  test("loads the TUI integration lazily", async () => {
-    const source = await Bun.file(new URL("../../../src/cli/cmd/attach.ts", import.meta.url)).text()
-
-    expect(source).toContain('await import("../tui/layer")')
-    expect(source).toMatch(/await import\(["']@\/plugin\/tui\/runtime["']\)/)
-    expect(source).not.toContain('import("./app")')
-  })
-})