@miaws/miaw 1.18.5 → 1.18.7

package/test/preload.ts

@@ -1,92 +0,0 @@
-// IMPORTANT: Set env vars BEFORE any imports from src/ directory
-// xdg-basedir reads env vars at import time, so we must set these first
-import os from "os"
-import path from "path"
-import fs from "fs/promises"
-import { setTimeout as sleep } from "node:timers/promises"
-import { afterAll } from "bun:test"
-
-// Set XDG env vars FIRST, before any src/ imports
-const dir = path.join(os.tmpdir(), "miaw-test-data-" + process.pid)
-await fs.mkdir(dir, { recursive: true })
-afterAll(async () => {
-  const { AppRuntime } = await import("../src/effect/app-runtime")
-  await AppRuntime.dispose()
-
-  const busy = (error: unknown) =>
-    typeof error === "object" && error !== null && "code" in error && error.code === "EBUSY"
-  const rm = async (left: number): Promise<void> => {
-    Bun.gc(true)
-    await sleep(100)
-    return fs.rm(dir, { recursive: true, force: true }).catch((error) => {
-      if (!busy(error)) throw error
-      if (left <= 1 && process.platform !== "win32") throw error
-      if (left <= 1) return
-      return rm(left - 1)
-    })
-  }
-
-  // Windows can keep SQLite WAL handles alive until GC finalizers run, so we
-  // force GC and retry teardown to avoid flaky EBUSY in test cleanup.
-  await rm(30)
-})
-
-process.env["XDG_DATA_HOME"] = path.join(dir, "share")
-process.env["XDG_CACHE_HOME"] = path.join(dir, "cache")
-process.env["XDG_CONFIG_HOME"] = path.join(dir, "config")
-process.env["XDG_STATE_HOME"] = path.join(dir, "state")
-process.env["MIAW_MODELS_PATH"] = path.join(import.meta.dir, "tool", "fixtures", "models-api.json")
-process.env["MIAW_EXPERIMENTAL_EVENT_SYSTEM"] = "true"
-process.env["MIAW_EXPERIMENTAL_WORKSPACES"] = "true"
-
-// Set test home directory to isolate tests from user's actual home directory
-// This prevents tests from picking up real user configs/skills from ~/.claude/skills
-const testHome = path.join(dir, "home")
-await fs.mkdir(testHome, { recursive: true })
-process.env["MIAW_TEST_HOME"] = testHome
-
-// Set test managed config directory to isolate tests from system managed settings
-const testManagedConfigDir = path.join(dir, "managed")
-process.env["MIAW_TEST_MANAGED_CONFIG_DIR"] = testManagedConfigDir
-
-// Write the cache version file to prevent global/index.ts from clearing the cache
-const cacheDir = path.join(dir, "cache", "miaw")
-await fs.mkdir(cacheDir, { recursive: true })
-await fs.writeFile(path.join(cacheDir, "version"), "14")
-
-// Clear provider and server auth env vars to ensure clean test state
-delete process.env["ANTHROPIC_API_KEY"]
-delete process.env["OPENAI_API_KEY"]
-delete process.env["GOOGLE_API_KEY"]
-delete process.env["GOOGLE_GENERATIVE_AI_API_KEY"]
-delete process.env["AZURE_OPENAI_API_KEY"]
-delete process.env["AWS_ACCESS_KEY_ID"]
-delete process.env["AWS_PROFILE"]
-delete process.env["AWS_REGION"]
-delete process.env["AWS_BEARER_TOKEN_BEDROCK"]
-delete process.env["OPENROUTER_API_KEY"]
-delete process.env["LLM_GATEWAY_API_KEY"]
-delete process.env["GROQ_API_KEY"]
-delete process.env["MISTRAL_API_KEY"]
-delete process.env["PERPLEXITY_API_KEY"]
-delete process.env["TOGETHER_API_KEY"]
-delete process.env["XAI_API_KEY"]
-delete process.env["DEEPSEEK_API_KEY"]
-delete process.env["FIREWORKS_API_KEY"]
-delete process.env["CEREBRAS_API_KEY"]
-delete process.env["SAMBANOVA_API_KEY"]
-delete process.env["MIAW_SERVER_PASSWORD"]
-delete process.env["MIAW_SERVER_USERNAME"]
-delete process.env["MIAW_EXPERIMENTAL"]
-delete process.env["MIAW_ENABLE_EXPERIMENTAL_MODELS"]
-delete process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]
-delete process.env["OTEL_EXPORTER_OTLP_HEADERS"]
-delete process.env["OTEL_RESOURCE_ATTRIBUTES"]
-
-// Use in-memory sqlite
-process.env["MIAW_DB"] = ":memory:"
-
-// Now safe to import from src/
-const { initProjectors } = await import("../src/server/projectors")
-
-initProjectors()

package/test/project/instance-bootstrap.test.ts

@@ -1,110 +0,0 @@
-import { afterEach, expect } from "bun:test"
-import { existsSync } from "node:fs"
-import path from "node:path"
-import { pathToFileURL } from "node:url"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { Cause, Effect, Exit, Fiber, Layer } from "effect"
-import { bootstrap as cliBootstrap } from "../../src/cli/bootstrap"
-import { InstanceLayer } from "../../src/project/instance-layer"
-import { InstanceStore } from "../../src/project/instance-store"
-import { disposeAllInstances, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { waitGlobalBusEvent } from "../server/global-bus"
-
-const it = testEffect(Layer.mergeAll(InstanceLayer.layer, CrossSpawnSpawner.defaultLayer))
-
-// InstanceBootstrap must run before any code touches the instance —
-// originally tracked by PRs #25389 and #25449, now a permanent
-// invariant. The plugin config hook writes a marker file; the test
-// bodies deliberately avoid Plugin/config directly. The marker only
-// appears if InstanceBootstrap ran at the instance boundary.
-//
-// The boundaries below are transport-agnostic and stay.
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-const bootstrapFixture = Effect.gen(function* () {
-  const dir = yield* tmpdirScoped({ git: true })
-  const marker = path.join(dir, "config-hook-fired")
-  const pluginFile = path.join(dir, "plugin.ts")
-  yield* Effect.promise(() =>
-    Bun.write(
-      pluginFile,
-      [
-        `const MARKER = ${JSON.stringify(marker)}`,
-        "export default async () => ({",
-        "  config: async () => {",
-        '    await Bun.write(MARKER, "ran")',
-        "  },",
-        "})",
-        "",
-      ].join("\n"),
-    ),
-  )
-  yield* Effect.promise(() =>
-    Bun.write(
-      path.join(dir, "miaw.json"),
-      JSON.stringify({
-        $schema: "https://miaw/config.json",
-        plugin: [pathToFileURL(pluginFile).href],
-      }),
-    ),
-  )
-  return { directory: dir, marker }
-})
-
-function waitDisposed(directory: string) {
-  return waitGlobalBusEvent({
-    message: "timed out waiting for CLI bootstrap instance disposal",
-    predicate: (event) => event.payload.type === "server.instance.disposed" && event.directory === directory,
-  })
-}
-
-it.live("InstanceStore.provide runs InstanceBootstrap before effect", () =>
-  Effect.gen(function* () {
-    const tmp = yield* bootstrapFixture
-    const store = yield* InstanceStore.Service
-
-    yield* store.provide({ directory: tmp.directory }, Effect.succeed("ok"))
-
-    expect(existsSync(tmp.marker)).toBe(true)
-  }),
-)
-
-it.live("CLI bootstrap runs InstanceBootstrap before callback", () =>
-  Effect.gen(function* () {
-    const tmp = yield* bootstrapFixture
-
-    yield* Effect.promise(() => cliBootstrap(tmp.directory, async () => "ok"))
-
-    expect(existsSync(tmp.marker)).toBe(true)
-  }),
-)
-
-it.live("CLI bootstrap disposes the instance when the callback rejects", () =>
-  Effect.gen(function* () {
-    const tmp = yield* bootstrapFixture
-    const disposed = yield* waitDisposed(tmp.directory).pipe(Effect.forkScoped({ startImmediately: true }))
-
-    const exit = yield* Effect.promise(() =>
-      cliBootstrap(tmp.directory, async () => Promise.reject(new Error("boom"))),
-    ).pipe(Effect.exit)
-
-    expect(Exit.isFailure(exit)).toBe(true)
-    if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toMatchObject({ message: "boom" })
-    yield* Fiber.join(disposed)
-  }),
-)
-
-it.live("InstanceStore.reload runs InstanceBootstrap", () =>
-  Effect.gen(function* () {
-    const tmp = yield* bootstrapFixture
-    const store = yield* InstanceStore.Service
-
-    yield* store.reload({ directory: tmp.directory })
-
-    expect(existsSync(tmp.marker)).toBe(true)
-  }),
-)

package/test/project/instance.test.ts

@@ -1,245 +0,0 @@
-import { describe, expect } from "bun:test"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { Deferred, Effect, Fiber, Layer } from "effect"
-import { InstanceRef } from "../../src/effect/instance-ref"
-import { registerDisposer } from "../../src/effect/instance-registry"
-import { InstanceBootstrap } from "../../src/project/bootstrap-service"
-import { InstanceStore } from "../../src/project/instance-store"
-import { tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-let bootstrapRun: Effect.Effect<void> = Effect.void
-const noopBootstrap = Layer.succeed(
-  InstanceBootstrap.Service,
-  InstanceBootstrap.Service.of({ run: Effect.suspend(() => bootstrapRun) }),
-)
-
-const it = testEffect(
-  Layer.mergeAll(InstanceStore.defaultLayer, CrossSpawnSpawner.defaultLayer).pipe(Layer.provide(noopBootstrap)),
-)
-
-const setBootstrap = (run: Effect.Effect<void>) =>
-  Effect.acquireRelease(
-    Effect.sync(() => {
-      bootstrapRun = run
-    }),
-    () =>
-      Effect.sync(() => {
-        bootstrapRun = Effect.void
-      }),
-  )
-
-const registerDisposerScoped = (disposer: (directory: string) => Promise<void>) =>
-  Effect.acquireRelease(
-    Effect.sync(() => registerDisposer(disposer)),
-    (off) => Effect.sync(off),
-  )
-
-describe("InstanceStore", () => {
-  it.live("loads instance context", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-      const ctx = yield* store.load({ directory: dir })
-
-      expect(ctx.directory).toBe(dir)
-      expect(ctx.worktree).toBe(dir)
-    }),
-  )
-
-  it.live("runs bootstrap with InstanceRef provided", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-      let initializedDirectory: string | undefined
-
-      yield* setBootstrap(
-        Effect.gen(function* () {
-          initializedDirectory = (yield* InstanceRef)?.directory
-        }),
-      )
-      yield* store.load({ directory: dir })
-
-      expect(initializedDirectory).toBe(dir)
-    }),
-  )
-
-  it.live("caches loaded instance context by directory", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-      let initialized = 0
-
-      yield* setBootstrap(
-        Effect.sync(() => {
-          initialized++
-        }),
-      )
-      const first = yield* store.load({ directory: dir })
-      const second = yield* store.load({ directory: dir })
-
-      expect(second).toBe(first)
-      expect(initialized).toBe(1)
-    }),
-  )
-
-  it.live("dedupes concurrent loads while init is in flight", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-      const started = yield* Deferred.make<void>()
-      const release = yield* Deferred.make<void>()
-      let initialized = 0
-
-      yield* setBootstrap(
-        Effect.gen(function* () {
-          initialized++
-          yield* Deferred.succeed(started, undefined)
-          yield* Deferred.await(release)
-        }),
-      )
-      const first = yield* store.load({ directory: dir }).pipe(Effect.forkScoped)
-
-      yield* Deferred.await(started)
-
-      yield* setBootstrap(
-        Effect.sync(() => {
-          initialized++
-        }),
-      )
-      const second = yield* store.load({ directory: dir }).pipe(Effect.forkScoped)
-
-      expect(initialized).toBe(1)
-      yield* Deferred.succeed(release, undefined)
-
-      const [firstCtx, secondCtx] = yield* Effect.all([Fiber.join(first), Fiber.join(second)])
-      expect(secondCtx).toBe(firstCtx)
-      expect(initialized).toBe(1)
-    }),
-  )
-
-  it.live("removes failed loads from the cache", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-      let attempts = 0
-
-      yield* setBootstrap(
-        Effect.sync(() => {
-          attempts++
-          throw new Error("init failed")
-        }),
-      )
-      const failed = yield* store.load({ directory: dir }).pipe(
-        Effect.as(false),
-        Effect.catchCause(() => Effect.succeed(true)),
-      )
-
-      expect(failed).toBe(true)
-
-      yield* setBootstrap(
-        Effect.sync(() => {
-          attempts++
-        }),
-      )
-      const ctx = yield* store.load({ directory: dir })
-
-      expect(ctx.directory).toBe(dir)
-      expect(attempts).toBe(2)
-    }),
-  )
-
-  it.live("reload replaces the cached context", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-
-      const first = yield* store.load({ directory: dir })
-      const second = yield* store.reload({ directory: dir })
-      const cached = yield* store.load({ directory: dir })
-
-      expect(second).not.toBe(first)
-      expect(cached).toBe(second)
-    }),
-  )
-
-  it.live("stale dispose does not delete an in-flight reload", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-      const reloading = yield* Deferred.make<void>()
-      const releaseReload = yield* Deferred.make<void>()
-      const disposed: Array<string> = []
-      yield* registerDisposerScoped(async (directory) => {
-        disposed.push(directory)
-      })
-
-      const first = yield* store.load({ directory: dir })
-      yield* setBootstrap(
-        Effect.gen(function* () {
-          yield* Deferred.succeed(reloading, undefined)
-          yield* Deferred.await(releaseReload)
-        }),
-      )
-      const reload = yield* store.reload({ directory: dir }).pipe(Effect.forkScoped)
-
-      yield* Deferred.await(reloading)
-      const staleDispose = yield* store.dispose(first).pipe(Effect.forkScoped)
-      yield* Deferred.succeed(releaseReload, undefined)
-
-      const second = yield* Fiber.join(reload)
-      yield* Fiber.join(staleDispose)
-
-      expect(disposed).toEqual([dir])
-      expect(yield* store.load({ directory: dir })).toBe(second)
-    }),
-  )
-
-  it.live("dedupes concurrent disposeAll calls", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-      const disposing = yield* Deferred.make<void>()
-      const releaseDispose = yield* Deferred.make<() => void>()
-      const disposed: Array<string> = []
-      yield* registerDisposerScoped((directory) => {
-        disposed.push(directory)
-        Deferred.doneUnsafe(disposing, Effect.void)
-        return new Promise<void>((resolve) => {
-          Deferred.doneUnsafe(releaseDispose, Effect.succeed(resolve))
-        })
-      })
-
-      yield* store.load({ directory: dir })
-      const first = yield* store.disposeAll().pipe(Effect.forkScoped)
-      yield* Deferred.await(disposing)
-      const release = yield* Deferred.await(releaseDispose)
-      const second = yield* store.disposeAll().pipe(Effect.forkScoped)
-
-      expect(disposed).toEqual([dir])
-      yield* Effect.sync(release)
-      yield* Effect.all([Fiber.join(first), Fiber.join(second)])
-      expect(disposed).toEqual([dir])
-    }),
-  )
-
-  it.live("re-arms disposeAll after completion", () =>
-    Effect.gen(function* () {
-      const dir1 = yield* tmpdirScoped({ git: true })
-      const dir2 = yield* tmpdirScoped({ git: true })
-      const store = yield* InstanceStore.Service
-      const disposed: Array<string> = []
-      yield* registerDisposerScoped(async (directory) => {
-        disposed.push(directory)
-      })
-
-      yield* store.load({ directory: dir1 })
-      yield* store.disposeAll()
-      expect(disposed).toEqual([dir1])
-
-      yield* store.load({ directory: dir2 })
-      yield* store.disposeAll()
-      expect(disposed).toEqual([dir1, dir2])
-    }),
-  )
-})

package/test/project/migrate-global.test.ts

@@ -1,167 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Project } from "@/project/project"
-import { Database } from "@miaw/core/database/database"
-import { eq } from "drizzle-orm"
-import { SessionTable } from "@miaw/core/session/sql"
-import { ProjectTable } from "@miaw/core/project/sql"
-import { AbsolutePath } from "@miaw/core/schema"
-import { ProjectV2 } from "@miaw/core/project"
-import { SessionID } from "../../src/session/schema"
-import { $ } from "bun"
-import { tmpdirScoped } from "../fixture/fixture"
-import { Effect, Layer } from "effect"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Layer.mergeAll(Project.defaultLayer, CrossSpawnSpawner.defaultLayer, Database.defaultLayer))
-
-function legacySessionID() {
-  // Global-session migration covers persisted IDs from before prefixed session IDs.
-  return crypto.randomUUID() as SessionID
-}
-
-function seed(opts: { id: SessionID; dir: string; project: ProjectV2.ID }) {
-  const now = Date.now()
-  return Database.Service.use(({ db }) =>
-    db
-      .insert(SessionTable)
-      .values({
-        id: opts.id,
-        project_id: opts.project,
-        slug: opts.id,
-        directory: opts.dir,
-        title: "test",
-        version: "0.0.0-test",
-        time_created: now,
-        time_updated: now,
-      })
-      .run()
-      .pipe(Effect.orDie),
-  )
-}
-
-function ensureGlobal() {
-  return Database.Service.use(({ db }) =>
-    db
-      .insert(ProjectTable)
-      .values({
-        id: ProjectV2.ID.global,
-        worktree: AbsolutePath.make("/"),
-        time_created: Date.now(),
-        time_updated: Date.now(),
-        sandboxes: [],
-      })
-      .onConflictDoNothing()
-      .run()
-      .pipe(Effect.orDie),
-  )
-}
-
-describe("migrateFromGlobal", () => {
-  it.live("migrates global sessions on first project creation", () =>
-    Effect.gen(function* () {
-      // 1. Start with git init but no commits — creates "global" project row
-      const tmp = yield* tmpdirScoped()
-      yield* Effect.promise(() => $`git init`.cwd(tmp).quiet())
-      yield* Effect.promise(() => $`git config user.name "Test"`.cwd(tmp).quiet())
-      yield* Effect.promise(() => $`git config user.email "test@miaw.test"`.cwd(tmp).quiet())
-      yield* Effect.promise(() => $`git config commit.gpgsign false`.cwd(tmp).quiet())
-      const projects = yield* Project.Service
-      const { project: pre } = yield* projects.fromDirectory(tmp)
-      expect(pre.id).toBe(ProjectV2.ID.global)
-
-      // 2. Seed a session under "global" with matching directory
-      const id = legacySessionID()
-      yield* seed({ id, dir: tmp, project: ProjectV2.ID.global })
-
-      // 3. Make a commit so the project gets a real ID
-      yield* Effect.promise(() => $`git commit --allow-empty -m "root"`.cwd(tmp).quiet())
-
-      const { project: real } = yield* projects.fromDirectory(tmp)
-      expect(real.id).not.toBe(ProjectV2.ID.global)
-
-      // 4. The session should have been migrated to the real project ID
-      const row = yield* Database.Service.use(({ db }) =>
-        db.select().from(SessionTable).where(eq(SessionTable.id, id)).get().pipe(Effect.orDie),
-      )
-      expect(row).toBeDefined()
-      expect(row!.project_id).toBe(real.id)
-    }),
-  )
-
-  it.live("migrates global sessions even when project row already exists", () =>
-    Effect.gen(function* () {
-      // 1. Create a repo with a commit — real project ID created immediately
-      const tmp = yield* tmpdirScoped({ git: true })
-      const projects = yield* Project.Service
-      const { project } = yield* projects.fromDirectory(tmp)
-      expect(project.id).not.toBe(ProjectV2.ID.global)
-
-      // 2. Ensure "global" project row exists (as it would from a prior no-git session)
-      yield* ensureGlobal()
-
-      // 3. Seed a session under "global" with matching directory.
-      //    This simulates a session created before git init that wasn't
-      //    present when the real project row was first created.
-      const id = legacySessionID()
-      yield* seed({ id, dir: tmp, project: ProjectV2.ID.global })
-
-      // 4. Call fromDirectory again — project row already exists,
-      //    so the current code skips migration entirely. This is the bug.
-      yield* projects.fromDirectory(tmp)
-
-      const row = yield* Database.Service.use(({ db }) =>
-        db.select().from(SessionTable).where(eq(SessionTable.id, id)).get().pipe(Effect.orDie),
-      )
-      expect(row).toBeDefined()
-      expect(row!.project_id).toBe(project.id)
-    }),
-  )
-
-  it.live("does not claim sessions with empty directory", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped({ git: true })
-      const projects = yield* Project.Service
-      const { project } = yield* projects.fromDirectory(tmp)
-      expect(project.id).not.toBe(ProjectV2.ID.global)
-
-      yield* ensureGlobal()
-
-      // Legacy sessions may lack a directory value.
-      // Without a matching origin directory, they should remain global.
-      const id = legacySessionID()
-      yield* seed({ id, dir: "", project: ProjectV2.ID.global })
-
-      yield* projects.fromDirectory(tmp)
-
-      const row = yield* Database.Service.use(({ db }) =>
-        db.select().from(SessionTable).where(eq(SessionTable.id, id)).get().pipe(Effect.orDie),
-      )
-      expect(row).toBeDefined()
-      expect(row!.project_id).toBe(ProjectV2.ID.global)
-    }),
-  )
-
-  it.live("does not steal sessions from unrelated directories", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped({ git: true })
-      const projects = yield* Project.Service
-      const { project } = yield* projects.fromDirectory(tmp)
-      expect(project.id).not.toBe(ProjectV2.ID.global)
-
-      yield* ensureGlobal()
-
-      // Seed a session under "global" but for a DIFFERENT directory
-      const id = legacySessionID()
-      yield* seed({ id, dir: "/some/other/dir", project: ProjectV2.ID.global })
-
-      yield* projects.fromDirectory(tmp)
-      const row = yield* Database.Service.use(({ db }) =>
-        db.select().from(SessionTable).where(eq(SessionTable.id, id)).get().pipe(Effect.orDie),
-      )
-      expect(row).toBeDefined()
-      // Should remain under "global" — not stolen
-      expect(row!.project_id).toBe(ProjectV2.ID.global)
-    }),
-  )
-})