@supatype/cli 0.1.0 → 0.1.2

package/tests/dev-ready-panel.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest"
+import { devReadyPanelRowCount } from "../src/dev-ready-panel.js"
+
+describe("devReadyPanelRowCount", () => {
+  it("accounts for border, keys block, and hints", () => {
+    const rows = devReadyPanelRowCount({
+      title: "Services running",
+      links: [
+        { label: "API", url: "http://localhost:1" },
+        { label: "Studio", url: "http://localhost:1/studio/" },
+      ],
+      hints: ["Demo data: pnpm seed"],
+      anonKey: "anon-jwt",
+      serviceRoleKey: "svc-jwt",
+    })
+
+    // border(2) + title(1) + links(2) + hint(1) + keys header(1) + anon(1) + svc(1) + margin(1)
+    expect(rows).toBe(10)
+  })
+})

package/tests/dev-session-lock.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"
+import { mkdtempSync, writeFileSync, existsSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import {
+  clearDevSessionLock,
+  devSessionLockPath,
+  readDevSessionLock,
+  writeDevSessionLock,
+} from "../src/dev-session-lock.js"
+
+describe("dev-session-lock", () => {
+  let dir: string
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "supatype-lock-"))
+  })
+
+  afterEach(() => {
+    clearDevSessionLock(dir)
+  })
+
+  it("writes and reads a lock file", () => {
+    writeDevSessionLock(dir, {
+      composeProject: "supatype-demo",
+      projectRef: "demo",
+      composePath: join(dir, ".supatype/self-host/docker-compose.yml"),
+      kongPort: 18473,
+      startedAt: "2026-01-01T00:00:00.000Z",
+    })
+    expect(existsSync(devSessionLockPath(dir))).toBe(true)
+    const lock = readDevSessionLock(dir)
+    expect(lock?.composeProject).toBe("supatype-demo")
+    expect(lock?.kongPort).toBe(18473)
+  })
+
+  it("clears the lock file", () => {
+    mkdirSync(join(dir, ".supatype"), { recursive: true })
+    writeFileSync(
+      devSessionLockPath(dir),
+      JSON.stringify({
+        version: 1,
+        composeProject: "supatype-demo",
+        projectRef: "demo",
+        composePath: "x",
+        kongPort: 1,
+        startedAt: "t",
+      }),
+      "utf8",
+    )
+    clearDevSessionLock(dir)
+    expect(existsSync(devSessionLockPath(dir))).toBe(false)
+  })
+})

package/tests/dev-ui.test.ts

@@ -1,7 +1,14 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"
+import { mkdtempSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+
+vi.mock("ink", () => ({
+  render: vi.fn(() => ({ unmount: vi.fn() })),
+}))
 import { DevLogBus } from "../src/dev-log-bus.js"
-import { filterDevSubprocessLine, formatConsoleArgs, stripAnsi } from "../src/dev-log-filter.js"
-import { appendDevTaskLog, beginDevSession, endDevSession, resolveDevUiMode } from "../src/dev-session.js"
+import { filterCommandLogLine, filterDevSubprocessLine, filterStackLogLine, formatConsoleArgs, stripAnsi } from "../src/dev-log-filter.js"
+import { appendDevTaskLog, beginDevSession, endDevSession, getActiveDevSession, resolveDevUiMode, withDevSessionSuspended } from "../src/dev-session.js"
 import {
   layoutLogoBlock,
   logoRowCount,
@@ -22,6 +29,28 @@ describe("filterDevSubprocessLine()", () => {
   })
 })
 
+describe("filterStackLogLine()", () => {
+  it("drops docker build progress but keeps supatype messages", () => {
+    expect(filterStackLogLine("#1 [internal] load build definition from Dockerfile")).toBe(false)
+    expect(filterStackLogLine(" Container supatype-demo-db-1 Running")).toBe(false)
+    expect(filterStackLogLine("[supatype] Waiting for Postgres (compose)...")).toBe(true)
+    expect(filterStackLogLine("Services running.")).toBe(true)
+    expect(filterStackLogLine("  API (Kong)       http://localhost:18473")).toBe(true)
+  })
+
+  it("keeps override banner lines", () => {
+    expect(filterStackLogLine("  engine       → ../supatype-schema-engine/bin/engine")).toBe(true)
+  })
+})
+
+describe("filterCommandLogLine()", () => {
+  it("keeps diff output but drops docker container progress", () => {
+    expect(filterCommandLogLine("  [+] add_column users.email")).toBe(true)
+    expect(filterCommandLogLine(" Container supatype-demo-db-1 Running")).toBe(false)
+    expect(filterCommandLogLine("[supatype] Schema pushed.")).toBe(true)
+  })
+})
+
 describe("stripAnsi()", () => {
   it("removes colour codes", () => {
     expect(stripAnsi("\x1b[33mhello\x1b[0m")).toBe("hello")
@@ -75,6 +104,20 @@ describe("appendDevTaskLog()", () => {
     expect(session.bus.getTask("app")?.lines).toEqual(["Proxy mode: running npm run vite (/tmp/app)"])
     expect(session.bus.getTask("stack")?.lines ?? []).toEqual([])
   })
+
+  it("captures console.log to the bus before ink mounts", () => {
+    beginDevSession("tui")
+    console.log("[supatype] bootstrap line")
+    expect(getActiveDevSession()?.bus.getTask("stack")?.lines).toEqual(["bootstrap line"])
+    expect(getActiveDevSession()?.isInkMounted()).toBe(true)
+  })
+
+  it("withDevSessionSuspended is a no-op during bootstrap", async () => {
+    beginDevSession("tui")
+    await withDevSessionSuspended(async () => "ok")
+    expect(getActiveDevSession()?.isConsoleCaptured()).toBe(true)
+    expect(getActiveDevSession()?.isInkMounted()).toBe(true)
+  })
 })
 
 describe("dev-logo", () => {
@@ -104,9 +147,11 @@ describe("dev-task-colors", () => {
 
 describe("dev-shutdown", () => {
   const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => undefined) as typeof process.exit)
+  const stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true)
 
   beforeEach(() => {
     exitSpy.mockClear()
+    stderrSpy.mockClear()
   })
 
   afterEach(() => {
@@ -125,7 +170,7 @@ describe("dev-shutdown", () => {
     expect(ran).toBe(true)
   })
 
-  it("force-exits 130 on second interrupt", async () => {
+  it("warns on second interrupt then force-exits on third", async () => {
     vi.resetModules()
     const { registerDevShutdown, requestDevShutdown } = await import("../src/dev-shutdown.js")
     registerDevShutdown(async () => {
@@ -134,6 +179,24 @@ describe("dev-shutdown", () => {
     requestDevShutdown()
     await vi.waitFor(() => expect(exitSpy).toHaveBeenCalledTimes(0))
     requestDevShutdown()
+    expect(stderrSpy).toHaveBeenCalled()
+    expect(exitSpy).toHaveBeenCalledTimes(0)
+    requestDevShutdown()
     expect(exitSpy).toHaveBeenCalledWith(130)
   })
+
+  it("registers compose fallback for sync exit cleanup", async () => {
+    vi.resetModules()
+    const { registerDevShutdown, hasComposeShutdownFallback, resetDevShutdownForTests } =
+      await import("../src/dev-shutdown.js")
+    resetDevShutdownForTests()
+    const dir = mkdtempSync(join(tmpdir(), "supatype-shutdown-"))
+    const composePath = join(dir, "docker-compose.yml")
+    writeFileSync(composePath, "services: {}\n", "utf8")
+    registerDevShutdown(async () => undefined, {
+      cwd: dir,
+      compose: { cwd: dir, composePath, composeProject: "supatype-test" },
+    })
+    expect(hasComposeShutdownFallback()).toBe(true)
+  })
 })

package/tests/docker-runtime.test.ts

@@ -1,9 +1,8 @@
-import { describe, expect, it, vi, beforeEach, afterEach, afterAll } from "vitest"
+import { describe, expect, it, vi, beforeEach, afterEach, afterAll, type MockInstance } from "vitest"
 import type { SpawnSyncReturns } from "node:child_process"
 
 const spawnSyncMock = vi.hoisted(() => vi.fn())
 const isInteractiveMock = vi.hoisted(() => vi.fn(() => false))
-const clackLogErrorMock = vi.hoisted(() => vi.fn())
 const clackNoteMock = vi.hoisted(() => vi.fn())
 const clackIntroMock = vi.hoisted(() => vi.fn())
 const printLogoMock = vi.hoisted(() => vi.fn())
@@ -16,18 +15,12 @@ vi.mock("../src/ui/interactive.js", () => ({
   isInteractive: isInteractiveMock,
 }))
 
-vi.mock("@clack/prompts", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@clack/prompts")>()
-  return {
-    ...original,
+vi.mock("../src/ui/clack.js", () => ({
+  p: {
     intro: clackIntroMock,
     note: clackNoteMock,
-    log: {
-      ...original.log,
-      error: clackLogErrorMock,
-    },
-  }
-})
+  },
+}))
 
 vi.mock("../src/ui/prompts.js", async (importOriginal) => {
   const original = await importOriginal<typeof import("../src/ui/prompts.js")>()
@@ -124,7 +117,6 @@ describe("reportDockerUnavailable", () => {
     isInteractiveMock.mockReturnValue(false)
     errorMock.mockClear()
     logMock.mockClear()
-    clackLogErrorMock.mockClear()
     clackNoteMock.mockClear()
     clackIntroMock.mockClear()
     printLogoMock.mockClear()
@@ -171,7 +163,7 @@ describe("reportDockerUnavailable", () => {
     expect(logMock.mock.calls.some((call) => String(call[0]).includes("docker-desktop"))).toBe(true)
   })
 
-  it("uses Clack log + note in interactive mode", () => {
+  it("uses Ink intro + note and themed error in interactive mode", () => {
     isInteractiveMock.mockReturnValue(true)
 
     reportDockerUnavailable(
@@ -185,20 +177,17 @@ describe("reportDockerUnavailable", () => {
 
     expect(printLogoMock).toHaveBeenCalled()
     expect(clackIntroMock).toHaveBeenCalledWith("Local development")
-    expect(clackLogErrorMock).toHaveBeenCalledWith(
-      "Docker is installed but the daemon is not running.",
-    )
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("daemon is not running"))).toBe(true)
     expect(clackNoteMock).toHaveBeenCalledWith(
       expect.stringContaining("Unpause Docker Desktop"),
     )
     expect(errorMock).not.toHaveBeenCalled()
-    expect(logMock).not.toHaveBeenCalled()
   })
 })
 
 describe("requireDockerDaemon", () => {
-  let exitMock: ReturnType<typeof vi.spyOn<typeof process, "exit">>
-  let errorMock: ReturnType<typeof vi.spyOn<typeof console, "error">>
+  let exitMock: MockInstance<(code?: string | number | null | undefined) => never>
+  let errorMock: MockInstance<typeof console.error>
 
   beforeEach(() => {
     spawnSyncMock.mockReset()

package/tests/ensure-dev-api-config.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest"
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { ensureDevApiConfig } from "../src/ensure-dev-api-config.js"
+
+describe("ensureDevApiConfig()", () => {
+  it("copies config/api-config.json when target is missing", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-api-config-"))
+    const configDir = join(dir, "config")
+    const template = join(configDir, "api-config.json")
+    const target = join(dir, ".supatype", "api-config.json")
+
+    mkdirSync(configDir, { recursive: true })
+    writeFileSync(template, '{"rest":{"schema":"public"}}\n', "utf8")
+
+    expect(ensureDevApiConfig(dir)).toBe(true)
+    expect(existsSync(target)).toBe(true)
+    expect(readFileSync(target, "utf8")).toContain('"rest"')
+    expect(ensureDevApiConfig(dir)).toBe(false)
+  })
+})

package/tests/init-dependency-versions.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+import {
+  initDependencyVersionsFallback,
+  resolveInitDependencyVersions,
+} from "../src/init-dependency-versions.js"
+
+function mockRegistry(packages: Record<string, { latest: string; versions: string[] }>) {
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (url: string) => {
+      const name = decodeURIComponent(url.replace("https://registry.npmjs.org/", ""))
+      const pkg = packages[name]
+      if (!pkg) return new Response(null, { status: 404 })
+      const versions = Object.fromEntries(pkg.versions.map((v) => [v, {}]))
+      return Response.json({ versions, "dist-tags": { latest: pkg.latest } })
+    }),
+  )
+}
+
+describe("resolveInitDependencyVersions", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it("uses the running CLI version when both packages publish it", async () => {
+    mockRegistry({
+      "@supatype/cli": { latest: "0.1.3", versions: ["0.1.1", "0.1.3"] },
+      "@supatype/types": { latest: "0.1.3", versions: ["0.1.1", "0.1.3"] },
+    })
+
+    const deps = await resolveInitDependencyVersions()
+    expect(deps.cli).toBe("0.1.3")
+    expect(deps.types).toBe("0.1.3")
+  })
+
+  it("falls back to npm latest when the running CLI version is unpublished", async () => {
+    mockRegistry({
+      "@supatype/cli": { latest: "0.1.1", versions: ["0.1.1"] },
+      "@supatype/types": { latest: "0.1.1", versions: ["0.1.1"] },
+    })
+
+    const deps = await resolveInitDependencyVersions()
+    expect(deps.cli).toBe("0.1.1")
+    expect(deps.types).toBe("0.1.1")
+  })
+
+  it("can pin cli and types to different published versions", async () => {
+    mockRegistry({
+      "@supatype/cli": { latest: "0.1.3", versions: ["0.1.1", "0.1.3"] },
+      "@supatype/types": { latest: "0.1.1", versions: ["0.1.1"] },
+    })
+
+    const deps = await resolveInitDependencyVersions()
+    expect(deps.cli).toBe("0.1.3")
+    expect(deps.types).toBe("0.1.1")
+  })
+
+  it("falls back to the running CLI version when the registry is unreachable", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => new Response(null, { status: 500 })))
+    expect(await resolveInitDependencyVersions()).toEqual(initDependencyVersionsFallback())
+  })
+})

package/tests/init-package-json.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest"
+import { mergeSupatypePackageJson } from "../src/init-package-json.js"
+
+describe("mergeSupatypePackageJson", () => {
+  it("adds Supatype deps and scripts without overwriting existing dev script", () => {
+    const merged = mergeSupatypePackageJson(
+      { name: "existing", scripts: { dev: "next dev" } },
+      { projectName: "existing", app: { mode: "none" }, helloFunction: false },
+      { cli: "0.1.1", types: "0.1.1" },
+    )
+
+    expect(merged.dependencies?.["@supatype/cli"]).toBe("^0.1.1")
+    expect(merged.dependencies?.["@supatype/types"]).toBe("^0.1.1")
+    expect(merged.scripts?.dev).toBe("next dev")
+    expect(merged.scripts?.["supatype:dev"]).toBe("supatype dev")
+    expect(merged.scripts?.push).toBe("supatype push")
+  })
+})

package/tests/init.test.ts

@@ -53,11 +53,15 @@ describe("scaffold()", () => {
     expect(content).toContain("pkg-app")
   })
 
-  it("skips package.json when it already exists", () => {
+  it("merges Supatype deps into package.json when it already exists", () => {
     const pkgPath = join(tmpRoot, "package.json")
-    writeFileSync(pkgPath, '{"name":"existing"}', "utf8")
+    writeFileSync(pkgPath, '{"name":"existing","scripts":{"dev":"next dev"}}', "utf8")
     scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
-    expect(readFileSync(pkgPath, "utf8")).toBe('{"name":"existing"}')
+    const content = readFileSync(pkgPath, "utf8")
+    expect(content).toContain("@supatype/cli")
+    expect(content).toContain("@supatype/types")
+    expect(content).toContain("next dev")
+    expect(content).toContain("supatype:dev")
   })
 
   it("supatype.config.ts documents self-host workflow", () => {
@@ -185,6 +189,29 @@ describe("scaffold()", () => {
     expect(html).toContain("github.com/supatype")
   })
 
+  it("static app mode with Vite on self-host splits production static and local proxy override", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app", "self-host"),
+      domain: "api.example.com",
+      app: {
+        mode: "static",
+        staticDir: "./public",
+        viteDevUrl: "http://127.0.0.1:5173",
+      },
+    })
+    const committed = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(committed).toContain('mode: "static"')
+    expect(committed).toContain('static_dir: "./dist"')
+    expect(committed).not.toContain("vite_dev_url")
+
+    const local = readFileSync(join(tmpRoot, "supatype.local.config.ts"), "utf8")
+    expect(local).toContain('mode: "proxy"')
+    expect(local).toContain('start: "vite"')
+    expect(local).toContain('vite_dev_url: "http://127.0.0.1:5173"')
+    expect(existsSync(join(tmpRoot, "dist/index.html"))).toBe(true)
+    expect(existsSync(join(tmpRoot, "vite.config.ts"))).toBe(true)
+  })
+
   it("static app mode with Vite scaffolds root index.html and vite.config.ts", () => {
     scaffold(tmpRoot, {
       ...defaultScaffoldOptions("my-app"),

package/tests/required-host-components.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest"
+import { mkdirSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { requiredHostComponents } from "../src/required-host-components.js"
+import type { SupatypeProjectConfig } from "../src/project-config.js"
+
+function baseConfig(provider: "docker" | "native"): SupatypeProjectConfig {
+  return {
+    project: { name: "test" },
+    provider,
+    database: { provider },
+    server: { mode: "dev" },
+    app: { mode: "none" },
+  }
+}
+
+describe("requiredHostComponents", () => {
+  it("returns engine for docker (types + admin config on the host)", () => {
+    expect(requiredHostComponents(baseConfig("docker"))).toEqual(["engine"])
+  })
+
+  it("returns engine for docker with overrides.engine", () => {
+    const config = baseConfig("docker")
+    config.overrides = { engine: "/path/to/engine" }
+    expect(requiredHostComponents(config)).toEqual(["engine"])
+  })
+
+  it("returns native core binaries without functions/", () => {
+    const dir = join(tmpdir(), `supatype-req-host-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+    expect(requiredHostComponents(baseConfig("native"), dir)).toEqual([
+      "engine",
+      "server",
+      "postgres",
+    ])
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  it("includes deno for native when functions/ exists", () => {
+    const dir = join(tmpdir(), `supatype-req-host-fn-${Date.now()}`)
+    mkdirSync(join(dir, "functions"), { recursive: true })
+    expect(requiredHostComponents(baseConfig("native"), dir)).toEqual([
+      "engine",
+      "server",
+      "postgres",
+      "deno",
+    ])
+    rmSync(dir, { recursive: true, force: true })
+  })
+})

package/tests/resolve-api-url.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest"
+import { mkdtempSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { resolveProjectApiUrl } from "../src/resolve-api-url.js"
+
+describe("resolveProjectApiUrl()", () => {
+  it("prefers PUBLIC_SUPATYPE_URL from .env (docker dev)", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "supatype-api-url-"))
+    writeFileSync(
+      join(cwd, ".env"),
+      "PUBLIC_SUPATYPE_URL=http://localhost:18473\nPORT=54321\n",
+      "utf8",
+    )
+    expect(resolveProjectApiUrl(cwd)).toBe("http://localhost:18473")
+  })
+
+  it("uses SUPATYPE_KONG_PORT when no URL env is set", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "supatype-api-url-"))
+    writeFileSync(join(cwd, ".env"), "SUPATYPE_KONG_PORT=19200\nPORT=54321\n", "utf8")
+    expect(resolveProjectApiUrl(cwd)).toBe("http://localhost:19200")
+  })
+})

package/tests/rest-cache-admin.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from "vitest"
+
+vi.mock("../src/env-file.js", () => ({
+  readEnvValue: () => "test-service-role-key",
+}))
+
+vi.mock("../src/resolve-api-url.js", () => ({
+  resolveProjectApiUrl: () => "http://localhost:1234",
+}))
+
+describe("listRestCacheEntries", () => {
+  it("coerces null entries to an empty array", async () => {
+    const { listRestCacheEntries } = await import("../src/rest-cache-admin.js")
+
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ entries: null, cursor: "0" }), { status: 200 }),
+    )
+
+    try {
+      const result = await listRestCacheEntries(process.cwd())
+      expect(result.entries).toEqual([])
+      expect(result.cursor).toBe("0")
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+})

package/tests/runtime-contract.test.ts

@@ -115,7 +115,9 @@ describe("runtime contract", () => {
       SUPATYPE_SERVER_IMAGE: "supatype/server:v0.1.0",
       SUPATYPE_POSTGRES_IMAGE: "supatype/postgres:17-latest",
     })
-    expect(composeDockerImageEnv({ ...baseConfig, versions: undefined })).toEqual({})
+    const withoutVersions = { ...baseConfig }
+    delete withoutVersions.versions
+    expect(composeDockerImageEnv(withoutVersions)).toEqual({})
     expect(
       composeDockerImageEnv({
         ...baseConfig,
@@ -483,9 +485,16 @@ export default defineConfig({
     expect(compose).not.toContain("HTTPS is off")
   })
 
+  it("self-host compose always includes Valkey and SUPATYPE_VALKEY_ADDR on server", () => {
+    const compose = renderSelfHostCompose(baseConfig)
+    expect(compose).toContain("\n  valkey:\n")
+    expect(compose).toContain("valkey/valkey:8-alpine")
+    expect(compose).toContain("SUPATYPE_VALKEY_ADDR: valkey:6379")
+    expect(compose).toMatch(/^\s{2}valkey-data:/m)
+  })
+
   it("self-host compose stays plain HTTP with a discoverable hint when TLS is off", () => {
     const compose = renderSelfHostCompose(baseConfig)
-    expect(compose).not.toContain("\n  valkey:\n")
     expect(compose).not.toContain('- "443:8443"')
     expect(compose).toContain("${SUPATYPE_KONG_PORT:-18473}:8000")
     expect(compose).toContain("HTTPS is off")
@@ -496,7 +505,7 @@ export default defineConfig({
       ...baseConfig,
       server: { mode: "standalone", domain: "api.example.com" },
     })
-    expect(compose).not.toContain("\n  valkey:\n")
+    expect(compose).toContain("\n  valkey:\n")
     expect(compose).not.toContain('- "443:8443"')
   })
 

package/tests/tsconfig.json

@@ -3,7 +3,13 @@
   "compilerOptions": {
     "noEmit": true,
     "composite": false,
-    "rootDir": ".."
+    "rootDir": "../.."
   },
-  "include": ["./**/*.ts"]
+  "include": [
+    "./**/*.ts",
+    "../src/**/*.ts",
+    "../../studio/src/lib/normalize-admin-config.ts",
+    "../../studio/src/config.ts"
+  ],
+  "exclude": ["engine-distribution.test.ts"]
 }

package/tests/ui-confirm.test.ts

@@ -1,35 +1,39 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
 
-vi.mock("@clack/prompts", () => ({
-  confirm: vi.fn(),
+const confirmMock = vi.hoisted(() => vi.fn())
+
+vi.mock("../src/ui/clack.js", () => ({
+  p: {
+    confirm: confirmMock,
+    cancel: vi.fn(() => process.exit(0)),
+  },
   isCancel: vi.fn((v: unknown) => v === Symbol.for("cancel")),
-  cancel: vi.fn(),
+  CLACK_CANCEL: Symbol.for("cancel"),
 }))
 
 vi.mock("../src/ui/interactive.js", () => ({
   isInteractive: vi.fn(() => true),
 }))
 
-import * as clack from "@clack/prompts"
 import { confirm, logSkippedConfirm } from "../src/ui/confirm.js"
 import { isInteractive } from "../src/ui/interactive.js"
 
 describe("ui confirm", () => {
   beforeEach(() => {
-    vi.mocked(clack.confirm).mockReset()
+    confirmMock.mockReset()
     vi.mocked(isInteractive).mockReturnValue(true)
   })
 
-  it("returns clack confirm result in TTY mode", async () => {
-    vi.mocked(clack.confirm).mockResolvedValue(true)
+  it("returns ink confirm result in TTY mode", async () => {
+    confirmMock.mockResolvedValue(true)
     await expect(confirm("Proceed?")).resolves.toBe(true)
-    expect(clack.confirm).toHaveBeenCalledWith({ message: "Proceed?", initialValue: false })
+    expect(confirmMock).toHaveBeenCalledWith({ message: "Proceed?", initialValue: false })
   })
 
   it("uses nonInteractive fallback when not a TTY", async () => {
     vi.mocked(isInteractive).mockReturnValue(false)
     await expect(confirm("Proceed?", { nonInteractive: false })).resolves.toBe(false)
-    expect(clack.confirm).not.toHaveBeenCalled()
+    expect(confirmMock).not.toHaveBeenCalled()
   })
 
   it("logSkippedConfirm mentions --yes", () => {