@supatype/cli 0.1.1 → 0.1.3

package/tests/cli-package-version.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest"
+import { readFileSync } from "node:fs"
+import { join, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+import { cliPackageVersion } from "../src/cli-package-version.js"
+
+const packageJson = JSON.parse(
+  readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../package.json"), "utf8"),
+) as { version: string }
+
+describe("cliPackageVersion", () => {
+  it("matches packages/cli/package.json version", () => {
+    expect(cliPackageVersion()).toBe(packageJson.version)
+  })
+})

package/tests/command-chrome-coverage.test.ts

@@ -0,0 +1,149 @@
+import { Command } from "commander"
+import { describe, expect, it } from "vitest"
+import { registerInit } from "../src/commands/init.js"
+import { registerDev } from "../src/commands/dev.js"
+import { registerCache } from "../src/commands/cache.js"
+import { registerSelfUpdate } from "../src/commands/self-update.js"
+import { registerUpdate } from "../src/commands/update.js"
+import { registerPg } from "../src/commands/pg.js"
+import { registerPush } from "../src/commands/push.js"
+import { registerDiff } from "../src/commands/diff.js"
+import { registerPull } from "../src/commands/pull.js"
+import { registerDoctor } from "../src/commands/doctor.js"
+import { registerIntrospect } from "../src/commands/introspect.js"
+import { registerAdopt } from "../src/commands/adopt.js"
+import { registerGenerate } from "../src/commands/generate.js"
+import { registerMigrate } from "../src/commands/migrate.js"
+import { registerSeed } from "../src/commands/seed.js"
+import { registerKeys } from "../src/commands/keys.js"
+import { registerApp } from "../src/commands/app.js"
+import { registerAdd } from "../src/commands/add.js"
+import { registerSelfHost } from "../src/commands/self-host.js"
+import { registerCloud } from "../src/commands/cloud.js"
+import { registerEngine } from "../src/commands/engine.js"
+import { registerDb } from "../src/commands/db.js"
+import { registerDeploy } from "../src/commands/deploy.js"
+import { registerStatus } from "../src/commands/status.js"
+import { registerLogs } from "../src/commands/logs.js"
+import { registerAdmin } from "../src/commands/admin.js"
+import { registerFunctions } from "../src/commands/functions.js"
+import { registerPlugins } from "../src/commands/plugins.js"
+import { registerTypes } from "../src/commands/types.js"
+import { registerMigrateFromV1 } from "../src/commands/migrate-from-v1.js"
+import {
+  shouldExcludeCommandChrome,
+  wrapProgramActionsWithChrome,
+} from "../src/ui/runtime/command-chrome.js"
+
+type CommandWithAction = Command & {
+  parent?: Command | null
+  _actionHandler?: ((args: unknown) => unknown) | null
+}
+
+function commandPath(cmd: CommandWithAction, root: Command): string {
+  const segments: string[] = []
+  let current: CommandWithAction | null = cmd
+  while (current && current !== root) {
+    segments.unshift(current.name())
+    current = current.parent ?? null
+  }
+  return segments.join(" ")
+}
+
+function collectActionCommands(cmd: CommandWithAction, root: Command): CommandWithAction[] {
+  const out: CommandWithAction[] = []
+  if (cmd._actionHandler) out.push(cmd)
+  for (const sub of cmd.commands) {
+    out.push(...collectActionCommands(sub as CommandWithAction, root))
+  }
+  return out
+}
+
+function buildProgram(): Command {
+  const program = new Command().name("supatype")
+  registerInit(program)
+  registerDev(program)
+  registerCache(program)
+  registerSelfUpdate(program)
+  registerUpdate(program)
+  registerPg(program)
+  registerPush(program)
+  registerDiff(program)
+  registerPull(program)
+  registerDoctor(program)
+  registerIntrospect(program)
+  registerAdopt(program)
+  registerGenerate(program)
+  registerMigrate(program)
+  registerSeed(program)
+  registerKeys(program)
+  registerApp(program)
+  registerAdd(program)
+  registerSelfHost(program)
+  registerCloud(program)
+  registerEngine(program)
+  registerDb(program)
+  registerDeploy(program)
+  registerStatus(program)
+  registerLogs(program)
+  registerAdmin(program)
+  registerFunctions(program)
+  registerPlugins(program)
+  registerTypes(program)
+  registerMigrateFromV1(program)
+  wrapProgramActionsWithChrome(program)
+  return program
+}
+
+describe("CLI command chrome coverage", () => {
+  it("wraps every non-excluded leaf command", () => {
+    const program = buildProgram()
+    const root = program as CommandWithAction
+    const commands = collectActionCommands(root, program)
+
+    expect(commands.length).toBeGreaterThan(50)
+
+    const excluded: string[] = []
+    const wrapped: string[] = []
+
+    for (const cmd of commands) {
+      const path = commandPath(cmd, program)
+      const handlerBefore = cmd._actionHandler
+      // Re-wrap is idempotent only when already wrapped; detect first-wrap by path policy.
+      if (shouldExcludeCommandChrome(path)) {
+        excluded.push(path)
+        continue
+      }
+      wrapped.push(path)
+      expect(handlerBefore, `${path} should be wrapped`).toBeDefined()
+    }
+
+    expect(excluded).toEqual(
+      expect.arrayContaining([
+        "dev",
+        "init",
+        "link",
+        "add domain",
+        "logs",
+        "pg psql",
+        "functions serve",
+        "self-host compose logs",
+      ]),
+    )
+
+    expect(wrapped).toEqual(
+      expect.arrayContaining([
+        "push",
+        "diff",
+        "doctor",
+        "pull",
+        "cache list",
+        "cache rest list",
+        "deploy",
+        "deploy rollback",
+        "keys",
+        "generate",
+      ]),
+    )
+  })
+})

package/tests/command-chrome-wrap.test.ts

@@ -0,0 +1,51 @@
+import { Command } from "commander"
+import { describe, expect, it, vi } from "vitest"
+import {
+  shouldExcludeCommandChrome,
+  wrapProgramActionsWithChrome,
+} from "../src/ui/runtime/command-chrome.js"
+
+describe("shouldExcludeCommandChrome", () => {
+  it("excludes wizard and streaming commands", () => {
+    expect(shouldExcludeCommandChrome("dev")).toBe(true)
+    expect(shouldExcludeCommandChrome("init")).toBe(true)
+    expect(shouldExcludeCommandChrome("link")).toBe(true)
+    expect(shouldExcludeCommandChrome("add domain")).toBe(true)
+    expect(shouldExcludeCommandChrome("logs")).toBe(true)
+    expect(shouldExcludeCommandChrome("pg psql")).toBe(true)
+    expect(shouldExcludeCommandChrome("functions serve")).toBe(true)
+    expect(shouldExcludeCommandChrome("self-host compose logs")).toBe(true)
+  })
+
+  it("includes one-shot commands", () => {
+    expect(shouldExcludeCommandChrome("push")).toBe(false)
+    expect(shouldExcludeCommandChrome("doctor")).toBe(false)
+    expect(shouldExcludeCommandChrome("cache rest list")).toBe(false)
+    expect(shouldExcludeCommandChrome("deploy rollback")).toBe(false)
+  })
+})
+
+describe("wrapProgramActionsWithChrome", () => {
+  it("wraps leaf actions but skips excluded paths", () => {
+    const program = new Command()
+    const pushFn = vi.fn()
+    const devFn = vi.fn()
+
+    program.command("push").action(pushFn)
+    program.command("dev").action(devFn)
+
+    type CommandWithAction = Command & {
+      _actionHandler?: ((args: unknown) => unknown) | null
+    }
+
+    const pushCmd = program.commands.find((c) => c.name() === "push") as CommandWithAction
+    const devCmd = program.commands.find((c) => c.name() === "dev") as CommandWithAction
+    const pushHandlerBefore = pushCmd._actionHandler
+    const devHandlerBefore = devCmd._actionHandler
+
+    wrapProgramActionsWithChrome(program)
+
+    expect(pushCmd._actionHandler).not.toBe(pushHandlerBefore)
+    expect(devCmd._actionHandler).toBe(devHandlerBefore)
+  })
+})

package/tests/config.test.ts

@@ -176,9 +176,28 @@ describe("loadConfig()", () => {
       })}`,
     )
     const cfg = loadConfig(tmpDir)
-    expect(cfg.versions.engine).toBe("0.4.2")
+    expect(cfg.versions!.engine).toBe("0.4.2")
     expect(cfg.schema?.path).toBe("./a.ts")
   })
+
+  it("loads defineConfig import before @supatype/cli is installed (init scaffold)", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `import { defineConfig } from "@supatype/cli"
+
+export default defineConfig({
+  project: { name: "fresh" },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  schema: { path: "./schema/index.ts" },
+})
+`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.project?.name).toBe("fresh")
+    expect(cfg.schema?.path).toBe("./schema/index.ts")
+  })
 })
 
 describe("resolveRuntimeProvider()", () => {
@@ -207,7 +226,9 @@ describe("mergeProjectConfig()", () => {
       ...minimalProject("p"),
       email: { provider: "smtp", smtp: { host: "h1", port: 587, user: "u0" } },
     })
-    const merged = mergeProjectConfig(base, { email: { smtp: { host: "h2", pass: "x" } } })
+    const merged = mergeProjectConfig(base, {
+      email: { smtp: { host: "h2", pass: "x" } },
+    } as Partial<typeof base>)
     expect(merged.email?.provider).toBe("smtp")
     expect(merged.email?.smtp?.host).toBe("h2")
     expect(merged.email?.smtp?.port).toBe(587)
@@ -222,7 +243,7 @@ describe("mergeProjectConfig()", () => {
     })
     const merged = mergeProjectConfig(base, {
       email: { send_email_hook_secrets: "v1,whsec_customsecret0000000000000000" },
-    })
+    } as Partial<typeof base>)
     expect(merged.email?.send_email_hook).toBe(true)
     expect(merged.email?.send_email_hook_uri).toBe("http://old/hook")
     expect(merged.email?.send_email_hook_secrets).toBe("v1,whsec_customsecret0000000000000000")
@@ -233,7 +254,9 @@ describe("mergeProjectConfig()", () => {
       ...minimalProject("p"),
       app: { mode: "static", static_dir: "./dist", vite_dev_url: "http://127.0.0.1:1111" },
     })
-    const merged = mergeProjectConfig(base, { app: { vite_dev_url: "http://127.0.0.1:5173" } })
+    const merged = mergeProjectConfig(base, {
+      app: { vite_dev_url: "http://127.0.0.1:5173" },
+    } as Partial<typeof base>)
     expect(merged.app?.vite_dev_url).toBe("http://127.0.0.1:5173")
   })
 

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

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest"
+import { devReadyPanelCompactRowCount, 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)
+  })
+})
+
+describe("devReadyPanelCompactRowCount", () => {
+  it("uses a shorter layout than the full panel", () => {
+    const panel = {
+      title: "Services running",
+      links: [
+        { label: "API", url: "http://localhost:1" },
+        { label: "REST", url: "http://localhost:1/rest/v1/" },
+        { label: "Studio", url: "http://localhost:1/studio/" },
+      ],
+      hints: ["Demo data: pnpm seed"],
+      anonKey: "anon-jwt",
+      serviceRoleKey: "svc-jwt",
+    }
+    expect(devReadyPanelCompactRowCount(panel)).toBeLessThan(devReadyPanelRowCount(panel))
+  })
+})

package/tests/dev-ui.test.ts

@@ -2,9 +2,13 @@ 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,
@@ -25,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")
@@ -78,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", () => {

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-project-detect.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { detectProjectSetup } from "../src/init-project-detect.js"
+
+let dir: string
+
+beforeEach(() => {
+  dir = join(tmpdir(), `supatype-detect-${Date.now()}`)
+  mkdirSync(dir, { recursive: true })
+})
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+})
+
+describe("detectProjectSetup()", () => {
+  it("returns empty summary for an empty directory", () => {
+    const detected = detectProjectSetup(dir)
+    expect(detected.hasExistingFiles).toBe(false)
+    expect(detected.hasVite).toBe(false)
+    expect(detected.summaryLines).toEqual([])
+  })
+
+  it("detects Vite config and port", () => {
+    writeFileSync(
+      join(dir, "vite.config.ts"),
+      `export default { server: { port: 5174 } }`,
+      "utf8",
+    )
+    const detected = detectProjectSetup(dir)
+    expect(detected.hasVite).toBe(true)
+    expect(detected.hasViteConfig).toBe(true)
+    expect(detected.viteDevUrl).toBe("http://127.0.0.1:5174")
+    expect(detected.summaryLines.some((line) => line.includes("Vite config"))).toBe(true)
+  })
+
+  it("detects static dist directory", () => {
+    mkdirSync(join(dir, "dist"), { recursive: true })
+    writeFileSync(join(dir, "dist", "index.html"), "<html></html>", "utf8")
+    const detected = detectProjectSetup(dir)
+    expect(detected.staticDir).toBe("./dist")
+    expect(detected.summaryLines.some((line) => line.includes("./dist"))).toBe(true)
+  })
+
+  it("detects existing supatype.config.ts", () => {
+    writeFileSync(join(dir, "supatype.config.ts"), "export default {}", "utf8")
+    const detected = detectProjectSetup(dir)
+    expect(detected.hasSupatypeConfig).toBe(true)
+    expect(detected.summaryLines).toContain("supatype.config already present")
+  })
+})

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"),