@supatype/cli 0.1.0-alpha.9 → 0.1.1

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

@@ -0,0 +1,162 @@
+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"
+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 {
+  layoutLogoBlock,
+  logoRowCount,
+  pickLogoLines,
+  SUPATYPE_ASCII_LOGO_WORDMARK,
+} from "../src/dev-logo.js"
+import { normalizeStackLogLine, taskColor } from "../src/dev-task-colors.js"
+
+describe("filterDevSubprocessLine()", () => {
+  it("filters npm script banners and vite network URLs for app", () => {
+    expect(filterDevSubprocessLine("app", "> vite")).toBe(false)
+    expect(filterDevSubprocessLine("app", "  ➜  Network: http://10.0.0.1:5173/")).toBe(false)
+    expect(filterDevSubprocessLine("app", "  ➜  Local:   http://localhost:5173/")).toBe(true)
+  })
+
+  it("does not filter stack logs", () => {
+    expect(filterDevSubprocessLine("stack", "> vite")).toBe(true)
+  })
+})
+
+describe("stripAnsi()", () => {
+  it("removes colour codes", () => {
+    expect(stripAnsi("\x1b[33mhello\x1b[0m")).toBe("hello")
+  })
+})
+
+describe("formatConsoleArgs()", () => {
+  it("joins mixed arguments", () => {
+    expect(formatConsoleArgs(["a", 1])).toBe("a 1")
+  })
+})
+
+describe("DevLogBus", () => {
+  it("marks non-focused tasks unread", () => {
+    const bus = new DevLogBus()
+    bus.registerTask("app", "app")
+    bus.setFocusedTaskId("stack")
+    bus.append("app", "ready")
+    expect(bus.getTask("app")?.unread).toBe(true)
+    bus.setFocusedTaskId("app")
+    expect(bus.getTask("app")?.unread).toBe(false)
+  })
+
+  it("splits multiline append into separate rows", () => {
+    const bus = new DevLogBus()
+    bus.append("stack", "line one\nline two")
+    expect(bus.getTask("stack")?.lines).toEqual(["line one", "line two"])
+  })
+
+  it("strips [supatype] prefix on stack task", () => {
+    const bus = new DevLogBus()
+    bus.append("stack", "[supatype] hello")
+    expect(bus.getTask("stack")?.lines).toEqual(["hello"])
+  })
+})
+
+describe("resolveDevUiMode()", () => {
+  it("honours --stream", () => {
+    expect(resolveDevUiMode(true)).toBe("stream")
+  })
+})
+
+describe("appendDevTaskLog()", () => {
+  afterEach(() => {
+    endDevSession()
+  })
+
+  it("routes proxy bootstrap lines to the app task in TUI mode", () => {
+    const session = beginDevSession("tui")
+    appendDevTaskLog("app", "app", "Proxy mode: running npm run vite (/tmp/app)")
+    expect(session.bus.getTask("app")?.lines).toEqual(["Proxy mode: running npm run vite (/tmp/app)"])
+    expect(session.bus.getTask("stack")?.lines ?? []).toEqual([])
+  })
+})
+
+describe("dev-logo", () => {
+  it("preserves authored line spacing including trailing spaces", () => {
+    const out = layoutLogoBlock(["  aa", "    bbbb ", ""])
+    expect(out[0]).toBe("  aa")
+    expect(out[1]).toBe("    bbbb ")
+  })
+
+  it("loads the figlet slant wordmark", () => {
+    expect(pickLogoLines()).toEqual([...SUPATYPE_ASCII_LOGO_WORDMARK])
+    expect(logoRowCount()).toBe(6)
+    expect(SUPATYPE_ASCII_LOGO_WORDMARK[1]).toContain("_______")
+  })
+})
+
+describe("dev-task-colors", () => {
+  it("assigns purple to stack and green to app", () => {
+    expect(taskColor("stack")).toBe("\x1b[35m")
+    expect(taskColor("app")).toBe("\x1b[32m")
+  })
+
+  it("strips stack log prefix", () => {
+    expect(normalizeStackLogLine("[supatype] Waiting for Postgres")).toBe("Waiting for Postgres")
+  })
+})
+
+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(() => {
+    vi.resetModules()
+  })
+
+  it("exits 0 after registered work completes", async () => {
+    vi.resetModules()
+    const { registerDevShutdown, requestDevShutdown } = await import("../src/dev-shutdown.js")
+    let ran = false
+    registerDevShutdown(async () => {
+      ran = true
+    })
+    requestDevShutdown()
+    await vi.waitFor(() => expect(exitSpy).toHaveBeenCalledWith(0))
+    expect(ran).toBe(true)
+  })
+
+  it("warns on second interrupt then force-exits on third", async () => {
+    vi.resetModules()
+    const { registerDevShutdown, requestDevShutdown } = await import("../src/dev-shutdown.js")
+    registerDevShutdown(async () => {
+      await new Promise(() => undefined)
+    })
+    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

@@ -0,0 +1,236 @@
+import { describe, expect, it, vi, beforeEach, afterEach, afterAll } 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())
+
+vi.mock("node:child_process", () => ({
+  spawnSync: spawnSyncMock,
+}))
+
+vi.mock("../src/ui/interactive.js", () => ({
+  isInteractive: isInteractiveMock,
+}))
+
+vi.mock("@clack/prompts", async (importOriginal) => {
+  const original = await importOriginal<typeof import("@clack/prompts")>()
+  return {
+    ...original,
+    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")>()
+  return {
+    ...original,
+    printLogo: printLogoMock,
+  }
+})
+
+import {
+  probeDockerDaemon,
+  reportDockerUnavailable,
+  requireDockerDaemon,
+} from "../src/docker-runtime.js"
+
+function spawnResult(
+  overrides: Partial<SpawnSyncReturns<string>> & Pick<SpawnSyncReturns<string>, "status">,
+): SpawnSyncReturns<string> {
+  return {
+    stdout: "",
+    stderr: "",
+    pid: 0,
+    output: ["", ""],
+    signal: null,
+    ...overrides,
+  }
+}
+
+describe("probeDockerDaemon", () => {
+  beforeEach(() => {
+    spawnSyncMock.mockReset()
+  })
+
+  it("returns ok when docker version and info succeed", () => {
+    spawnSyncMock
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "24.0.0" }))
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "Server Version: 24.0.0" }))
+
+    expect(probeDockerDaemon()).toEqual({ ok: true })
+    expect(spawnSyncMock).toHaveBeenCalledTimes(2)
+    expect(spawnSyncMock.mock.calls[0]?.[1]).toEqual(["version", "--format", "{{.Client.Version}}"])
+    expect(spawnSyncMock.mock.calls[1]?.[1]).toEqual(["info"])
+  })
+
+  it("returns cli_missing when docker is not on PATH", () => {
+    spawnSyncMock.mockReturnValueOnce(
+      spawnResult({ status: 1, error: Object.assign(new Error("spawn docker ENOENT"), { code: "ENOENT" }) }),
+    )
+
+    expect(probeDockerDaemon()).toEqual({ ok: false, reason: "cli_missing" })
+    expect(spawnSyncMock).toHaveBeenCalledTimes(1)
+  })
+
+  it("returns daemon_unavailable when info fails", () => {
+    spawnSyncMock
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "24.0.0" }))
+      .mockReturnValueOnce(
+        spawnResult({
+          status: 1,
+          stderr: "Cannot connect to the Docker daemon at unix:///var/run/docker.sock",
+        }),
+      )
+
+    expect(probeDockerDaemon()).toEqual({
+      ok: false,
+      reason: "daemon_unavailable",
+      detail: "Cannot connect to the Docker daemon at unix:///var/run/docker.sock",
+    })
+  })
+
+  it("returns daemon_unavailable when version exits non-zero but client version is present (e.g. Docker paused)", () => {
+    spawnSyncMock.mockReturnValueOnce(
+      spawnResult({
+        status: 1,
+        stdout: "29.4.0\n",
+        stderr: "Error response from daemon: Docker Desktop is manually paused.",
+      }),
+    )
+
+    expect(probeDockerDaemon()).toEqual({
+      ok: false,
+      reason: "daemon_unavailable",
+      detail: "Error response from daemon: Docker Desktop is manually paused.",
+    })
+    expect(spawnSyncMock).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe("reportDockerUnavailable", () => {
+  const errorMock = vi.spyOn(console, "error").mockImplementation(() => {})
+  const logMock = vi.spyOn(console, "log").mockImplementation(() => {})
+
+  beforeEach(() => {
+    isInteractiveMock.mockReturnValue(false)
+    errorMock.mockClear()
+    logMock.mockClear()
+    clackLogErrorMock.mockClear()
+    clackNoteMock.mockClear()
+    clackIntroMock.mockClear()
+    printLogoMock.mockClear()
+  })
+
+  afterAll(() => {
+    errorMock.mockRestore()
+    logMock.mockRestore()
+  })
+
+  it("uses [supatype] prefix on the headline via error()", () => {
+    reportDockerUnavailable({
+      ok: false,
+      reason: "daemon_unavailable",
+      detail: "Cannot connect to the Docker daemon",
+    })
+
+    expect(errorMock).toHaveBeenCalledWith(
+      "[supatype] Docker is installed but the daemon is not running.",
+    )
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes('provider: "native"'))).toBe(true)
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("docker: Cannot connect"))).toBe(
+      false,
+    )
+  })
+
+  it("mentions unpause when daemon detail says paused", () => {
+    reportDockerUnavailable({
+      ok: false,
+      reason: "daemon_unavailable",
+      detail: "Error response from daemon: Docker Desktop is manually paused.",
+    })
+
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("Unpause Docker Desktop"))).toBe(
+      true,
+    )
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("docker:"))).toBe(false)
+  })
+
+  it("mentions install for cli_missing", () => {
+    reportDockerUnavailable({ ok: false, reason: "cli_missing" })
+
+    expect(errorMock).toHaveBeenCalledWith("[supatype] Docker is not installed or not on your PATH.")
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("docker-desktop"))).toBe(true)
+  })
+
+  it("uses Clack log + note in interactive mode", () => {
+    isInteractiveMock.mockReturnValue(true)
+
+    reportDockerUnavailable(
+      {
+        ok: false,
+        reason: "daemon_unavailable",
+        detail: "Error response from daemon: Docker Desktop is manually paused.",
+      },
+      { brand: { intro: "Local development" } },
+    )
+
+    expect(printLogoMock).toHaveBeenCalled()
+    expect(clackIntroMock).toHaveBeenCalledWith("Local development")
+    expect(clackLogErrorMock).toHaveBeenCalledWith(
+      "Docker is installed but the daemon is not running.",
+    )
+    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">>
+
+  beforeEach(() => {
+    spawnSyncMock.mockReset()
+    isInteractiveMock.mockReturnValue(false)
+    exitMock = vi.spyOn(process, "exit").mockImplementation((() => {}) as typeof process.exit)
+    errorMock = vi.spyOn(console, "error").mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    exitMock.mockRestore()
+    errorMock.mockRestore()
+  })
+
+  it("exits when the daemon is unavailable", () => {
+    spawnSyncMock
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "24.0.0" }))
+      .mockReturnValueOnce(spawnResult({ status: 1, stderr: "daemon down" }))
+
+    requireDockerDaemon()
+
+    expect(errorMock).toHaveBeenCalled()
+    expect(exitMock).toHaveBeenCalledWith(1)
+  })
+
+  it("does not exit when docker is available", () => {
+    spawnSyncMock
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "24.0.0" }))
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "ok" }))
+
+    requireDockerDaemon()
+
+    expect(exitMock).not.toHaveBeenCalled()
+    expect(errorMock).not.toHaveBeenCalled()
+  })
+})

package/tests/engine-push-output.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest"
+import {
+  filterComposeNoise,
+  formatEnginePushMessage,
+  parseEnginePushOutput,
+} from "../src/engine-push-output.js"
+
+describe("parseEnginePushOutput()", () => {
+  it("parses JSON on its own line amid docker progress", () => {
+    const output = [
+      " Container supatype-to-do-db-1 Running",
+      " Container supatype-to-do-db-1 Waiting",
+      " Container supatype-to-do-db-1 Healthy",
+      '{"status":"up_to_date","operations":0,"admin_refreshed":true}',
+      " Container supatype-to-do-schema-engine-run-abc Created",
+    ].join("\n")
+
+    expect(parseEnginePushOutput(output)).toEqual({
+      status: "up_to_date",
+      operations: 0,
+      admin_refreshed: true,
+    })
+  })
+
+  it("parses bare JSON output", () => {
+    expect(parseEnginePushOutput('{"status":"applied","operations":2}')).toEqual({
+      status: "applied",
+      operations: 2,
+    })
+  })
+
+  it("returns null when no JSON present", () => {
+    expect(parseEnginePushOutput("engine failed: connection refused")).toBeNull()
+  })
+})
+
+describe("formatEnginePushMessage()", () => {
+  it("formats up_to_date with admin refresh", () => {
+    expect(
+      formatEnginePushMessage({ status: "up_to_date", operations: 0, admin_refreshed: true }),
+    ).toBe("Schema up to date — Studio metadata synced.")
+  })
+
+  it("formats up_to_date without admin refresh", () => {
+    expect(formatEnginePushMessage({ status: "up_to_date" })).toBe("Schema up to date.")
+  })
+
+  it("formats applied operations", () => {
+    expect(formatEnginePushMessage({ status: "applied", operations: 3 })).toBe(
+      "Applied 3 operation(s).",
+    )
+  })
+})
+
+describe("filterComposeNoise()", () => {
+  it("removes container progress lines but keeps errors", () => {
+    const output = [
+      " Container supatype-to-do-db-1 Running",
+      "engine error: permission denied",
+      '{"status":"up_to_date","operations":0}',
+    ].join("\n")
+
+    expect(filterComposeNoise(output)).toBe(
+      'engine error: permission denied\n{"status":"up_to_date","operations":0}',
+    )
+  })
+})