@supatype/cli 0.1.1 → 0.1.3

package/src/ui/runtime/command-chrome.ts

@@ -0,0 +1,147 @@
+/**
+ * Branded Ink chrome for one-shot CLI commands (push, diff, adopt, …).
+ * Reuses the flow shell: figlet logo, coloured log pane, ink-spinner, prompts.
+ */
+
+import type { Command } from "commander"
+import type { ClackApi } from "../clack-api.js"
+import { getActiveFlowApi } from "./flow-session.js"
+import { runClackFlow } from "../clack.js"
+import { isInteractive } from "../interactive.js"
+import {
+  filterCommandLogLine,
+  formatConsoleArgs,
+  stripAnsi,
+} from "../../dev-log-filter.js"
+
+function patchConsoleForCommand(api: ClackApi): () => void {
+  const original = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+  }
+
+  const emitLine = (raw: string, stream: "log" | "warn" | "error"): void => {
+    if (!filterCommandLogLine(raw)) return
+    const t = stripAnsi(raw).trim()
+    if (!t) return
+    const stripped = t.replace(/^\[supatype\]\s*/, "")
+
+    if (stream === "error" || stripped.startsWith("✗")) {
+      api.log.error(stripped.replace(/^✗\s*/, ""))
+      return
+    }
+    if (stream === "warn" || stripped.startsWith("⚠")) {
+      api.log.warn(stripped.replace(/^⚠\s*/, ""))
+      return
+    }
+    if (stripped.startsWith("✓")) {
+      api.log.success(stripped.replace(/^✓\s*/, ""))
+      return
+    }
+    if (/\[supatype\]/.test(raw)) {
+      api.log.info(stripped)
+      return
+    }
+    api.note(t)
+  }
+
+  const wrap =
+    (stream: "log" | "warn" | "error") =>
+    (...args: unknown[]): void => {
+      for (const part of formatConsoleArgs(args).split(/\r?\n/)) {
+        emitLine(part, stream)
+      }
+    }
+
+  console.log = wrap("log")
+  console.warn = wrap("warn")
+  console.error = wrap("error")
+
+  return () => {
+    console.log = original.log
+    console.warn = original.warn
+    console.error = original.error
+  }
+}
+
+/**
+ * Run a command body inside the branded Ink shell (logo + logs + spinner).
+ * Falls back to plain stdout when not interactive.
+ */
+export async function runCommandChrome<T>(fn: () => Promise<T>): Promise<T> {
+  if (!isInteractive() || isCommandChromeActive()) {
+    return fn()
+  }
+
+  return runClackFlow(async (api) => {
+    const restore = patchConsoleForCommand(api)
+    try {
+      return await fn()
+    } finally {
+      restore()
+    }
+  })
+}
+
+/** True while `runCommandChrome` / `runClackFlow` is active. */
+export function isCommandChromeActive(): boolean {
+  return getActiveFlowApi() !== null
+}
+
+/** Commands that mount their own Ink UI — do not wrap with command chrome. */
+const WIZARD_COMMAND_PATHS = new Set(["dev", "init", "link"])
+
+/** Prefixes for subcommands that call `runClackFlow` internally. */
+const WIZARD_COMMAND_PREFIXES = ["add "]
+
+/** Long-running or stdio-inherit commands where chrome would fight subprocess output. */
+const STREAMING_COMMAND_PATHS = new Set([
+  "logs",
+  "pg psql",
+  "functions serve",
+  "self-host compose logs",
+])
+
+type CommandWithAction = Command & {
+  parent?: Command | null
+  _actionHandler?: ((args: unknown) => unknown) | null
+}
+
+/** Whether a registered command path should skip automatic command chrome. */
+export function shouldExcludeCommandChrome(commandPath: string): boolean {
+  if (WIZARD_COMMAND_PATHS.has(commandPath)) return true
+  if (WIZARD_COMMAND_PREFIXES.some((prefix) => commandPath.startsWith(prefix))) return true
+  if (STREAMING_COMMAND_PATHS.has(commandPath)) return true
+  return false
+}
+
+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 wrapCommandAction(cmd: CommandWithAction, root: Command): void {
+  const path = commandPath(cmd, root)
+  const handler = cmd._actionHandler
+  if (!handler || shouldExcludeCommandChrome(path)) return
+
+  cmd._actionHandler = (args: unknown) =>
+    runCommandChrome(() => Promise.resolve(handler(args)))
+}
+
+/** Wrap every leaf command action with branded Ink chrome (see exclusions above). */
+export function wrapProgramActionsWithChrome(program: Command): void {
+  const walk = (cmd: CommandWithAction): void => {
+    wrapCommandAction(cmd, program)
+    for (const sub of cmd.commands) {
+      walk(sub as CommandWithAction)
+    }
+  }
+  walk(program as CommandWithAction)
+}

package/src/ui/runtime/dev-prompt-queue.ts

@@ -0,0 +1,84 @@
+/**
+ * Imperative prompt queue for the dev dashboard overlay.
+ */
+
+import { CLACK_CANCEL } from "./cancel.js"
+
+export type DevPromptKind = "confirm" | "text" | "password" | "select"
+
+export interface DevSelectOption<T extends string = string> {
+  value: T
+  label: string
+  hint?: string
+}
+
+export interface DevPromptRequest<T = unknown> {
+  id: number
+  kind: DevPromptKind
+  message: string
+  initialValue?: string | boolean
+  defaultValue?: string
+  placeholder?: string
+  mask?: boolean
+  options?: DevSelectOption[]
+  validate?: (value: string) => string | undefined
+  resolve: (value: T | typeof CLACK_CANCEL) => void
+}
+
+let nextId = 0
+let active: DevPromptRequest | null = null
+const waiters: DevPromptRequest[] = []
+const listeners = new Set<() => void>()
+
+function notify(): void {
+  for (const listener of listeners) listener()
+}
+
+export function subscribeDevPrompts(listener: () => void): () => void {
+  listeners.add(listener)
+  return () => listeners.delete(listener)
+}
+
+export function getActiveDevPrompt(): DevPromptRequest | null {
+  return active
+}
+
+export function enqueueDevPrompt<T>(spec: Omit<DevPromptRequest<T>, "id" | "resolve">): Promise<T | typeof CLACK_CANCEL> {
+  return new Promise((resolve) => {
+    const request: DevPromptRequest<T> = {
+      ...spec,
+      id: nextId++,
+      resolve: resolve as DevPromptRequest["resolve"],
+    }
+    waiters.push(request as DevPromptRequest)
+    if (!active) {
+      active = waiters.shift() ?? null
+    }
+    notify()
+  })
+}
+
+export function resolveDevPrompt(value: unknown): void {
+  if (!active) return
+  const current = active
+  active = waiters.shift() ?? null
+  current.resolve(value)
+  notify()
+}
+
+export function clearDevPromptQueue(): void {
+  while (active) {
+    active.resolve(CLACK_CANCEL)
+    active = waiters.shift() ?? null
+  }
+  for (const pending of waiters.splice(0)) {
+    pending.resolve(CLACK_CANCEL)
+  }
+  notify()
+}
+
+/** @internal Tests */
+export function resetDevPromptQueueForTests(): void {
+  clearDevPromptQueue()
+  nextId = 0
+}

package/src/ui/runtime/flow-session.ts

@@ -0,0 +1,11 @@
+import type { ClackApi } from "../clack-api.js"
+
+let activeFlowApi: ClackApi | null = null
+
+export function setActiveFlowApi(api: ClackApi | null): void {
+  activeFlowApi = api
+}
+
+export function getActiveFlowApi(): ClackApi | null {
+  return activeFlowApi
+}

package/src/ui/runtime/run-clack-flow.tsx

@@ -0,0 +1,65 @@
+import React, { useRef } from "react"
+import { render, type Instance } from "ink"
+import { isInteractive } from "../interactive.js"
+import { createClackApi, type ClackApi } from "../clack-api.js"
+import { FlowApp } from "../flows/FlowApp.js"
+import { restoreStdinAfterInk } from "./stdin-after-ink.js"
+
+interface RunClackFlowRootProps {
+  run: (api: ClackApi) => Promise<unknown>
+  onComplete: (value: unknown) => void
+  onError: (err: unknown) => void
+}
+
+function RunClackFlowRoot({ run, onComplete, onError }: RunClackFlowRootProps): React.ReactElement {
+  const started = useRef(false)
+
+  return (
+    <FlowApp
+      bind={(controller) => {
+        if (started.current) return
+        started.current = true
+        void run(createClackApi(controller))
+          .then(onComplete)
+          .catch(onError)
+      }}
+    />
+  )
+}
+
+/** Mount a single Ink flow session (init wizard, standalone confirm, etc.). */
+export async function runClackFlow<T>(run: (api: ClackApi) => Promise<T>): Promise<T> {
+  if (!isInteractive()) {
+    throw new Error("Interactive Ink flow requires a TTY.")
+  }
+
+  return new Promise<T>((resolve, reject) => {
+    const instance = render(
+      <RunClackFlowRoot
+        run={run as (api: ClackApi) => Promise<unknown>}
+        onComplete={(value) => {
+          teardownInk(instance)
+          resolve(value as T)
+        }}
+        onError={(err) => {
+          teardownInk(instance)
+          reject(err)
+        }}
+      />,
+      { patchConsole: false },
+    )
+  })
+}
+
+function teardownInk(instance: Instance): void {
+  try {
+    instance.clear()
+  } catch {
+    // ignore — terminal may already be reset
+  }
+  instance.unmount()
+  instance.cleanup()
+  restoreStdinAfterInk()
+}
+
+export { CLACK_CANCEL } from "./cancel.js"

package/src/ui/runtime/stdin-after-ink.ts

@@ -0,0 +1,18 @@
+/** Restore stdin after Ink unmount so one-shot commands (init, link) can exit cleanly. */
+export function restoreStdinAfterInk(): void {
+  if (!process.stdin.isTTY) return
+
+  const stdin = process.stdin as NodeJS.ReadStream & {
+    isRaw?: boolean
+    setRawMode?(mode: boolean): void
+  }
+
+  try {
+    if (stdin.isRaw) stdin.setRawMode?.(false)
+  } catch {
+    // ignore — stdin may already be restored
+  }
+
+  stdin.resume()
+  process.stdout.write("\n")
+}

package/src/ui/theme.ts

@@ -0,0 +1,41 @@
+/**
+ * Supatype terminal design tokens — shared by Ink components and plain CI output.
+ */
+
+export const RESET = "\x1b[0m"
+export const DIM = "\x1b[2m"
+export const BOLD = "\x1b[1m"
+
+export const theme = {
+  brand: "magenta" as const,
+  brandHex: "#c084fc",
+  info: "cyan" as const,
+  warn: "yellow" as const,
+  error: "red" as const,
+  success: "green" as const,
+  dim: "gray" as const,
+  muted: "gray" as const,
+} as const
+
+/** Legacy ANSI exports used by dev-logo / dev-task-colors. */
+export const BRAND_COLOR = "\x1b[35m"
+
+export function brandStyle(text: string): string {
+  return `${BRAND_COLOR}${BOLD}${text}${RESET}`
+}
+
+export function plainInfo(message: string): string {
+  return `${theme.info === "cyan" ? "\x1b[36m" : ""}ℹ ${message}${RESET}`
+}
+
+export function plainWarn(message: string): string {
+  return `\x1b[33m⚠ ${message}${RESET}`
+}
+
+export function plainError(message: string): string {
+  return `\x1b[31m✗ ${message}${RESET}`
+}
+
+export function plainSuccess(message: string): string {
+  return `\x1b[32m✓ ${message}${RESET}`
+}

package/src/valkey-sidecar.ts

@@ -0,0 +1,126 @@
+/**
+ * Lightweight Valkey container for native `supatype dev` (REST response cache).
+ */
+
+import { spawnSync } from "node:child_process"
+import { createConnection } from "node:net"
+
+const DEFAULT_HOST = "127.0.0.1"
+const DEFAULT_PORT = 6379
+const IMAGE = "valkey/valkey:8-alpine"
+
+function containerName(projectName: string): string {
+  const safe = projectName.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 48)
+  return `supatype-valkey-dev-${safe}`
+}
+
+function dockerAvailable(): boolean {
+  const r = spawnSync("docker", ["info"], { stdio: "ignore" })
+  return r.status === 0
+}
+
+function isAddrReachable(host: string, port: number, timeoutMs = 800): boolean {
+  try {
+    const r = spawnSync(
+      process.execPath,
+      [
+        "-e",
+        `const n=require('net');const s=n.createConnection({host:${JSON.stringify(host)},port:${port}});` +
+          `s.on('connect',()=>{s.end();process.exit(0)});s.on('error',()=>process.exit(1));` +
+          `setTimeout(()=>process.exit(1),${timeoutMs})`,
+      ],
+      { stdio: "ignore" },
+    )
+    return r.status === 0
+  } catch {
+    return false
+  }
+}
+
+function sleepMs(ms: number): void {
+  const end = Date.now() + ms
+  while (Date.now() < end) {
+    /* spin */
+  }
+}
+
+export interface ValkeySidecarResult {
+  addr: string
+  containerName: string | null
+  started: boolean
+}
+
+/**
+ * Ensure Valkey is reachable at 127.0.0.1:6379 for native dev.
+ * Starts a named Docker container when Docker is available and nothing is listening.
+ */
+export function ensureValkeySidecar(projectName: string): ValkeySidecarResult {
+  const envAddr = process.env["SUPATYPE_VALKEY_ADDR"]?.trim()
+  if (envAddr) {
+    return { addr: envAddr, containerName: null, started: false }
+  }
+
+  const addr = `${DEFAULT_HOST}:${DEFAULT_PORT}`
+
+  if (isAddrReachable(DEFAULT_HOST, DEFAULT_PORT)) {
+    return { addr, containerName: null, started: false }
+  }
+
+  if (!dockerAvailable()) {
+    console.warn(
+      "[supatype] ⚠  Valkey not available (Docker not running). " +
+        "REST server cache (`cache({ server: true })`) will bypass until Valkey is reachable.",
+    )
+    return { addr: "", containerName: null, started: false }
+  }
+
+  const name = containerName(projectName)
+  spawnSync("docker", ["rm", "-f", name], { stdio: "ignore" })
+
+  const run = spawnSync(
+    "docker",
+    ["run", "-d", "--name", name, "-p", `${DEFAULT_PORT}:6379`, IMAGE],
+    { encoding: "utf8" },
+  )
+
+  if (run.status !== 0) {
+    const detail = (run.stderr || run.stdout || "").trim()
+    console.warn(
+      `[supatype] ⚠  Could not start Valkey sidecar: ${detail || `exit ${run.status}`}\n` +
+        "  REST server cache will bypass until Valkey is available.",
+    )
+    return { addr: "", containerName: null, started: false }
+  }
+
+  for (let i = 0; i < 30; i++) {
+    if (isAddrReachable(DEFAULT_HOST, DEFAULT_PORT)) {
+      console.log(`[supatype] Valkey sidecar running (${addr})`)
+      return { addr, containerName: name, started: true }
+    }
+    sleepMs(100)
+  }
+
+  console.warn("[supatype] ⚠  Valkey sidecar started but not reachable yet — cache may bypass initially.")
+  return { addr, containerName: name, started: true }
+}
+
+export function stopValkeySidecar(containerName: string | null): void {
+  if (!containerName) return
+  spawnSync("docker", ["rm", "-f", containerName], { stdio: "ignore" })
+}
+
+/** @internal Test helper — probe without subprocess. */
+export function probeTcp(host: string, port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const s = createConnection({ host, port })
+    s.once("connect", () => {
+      s.destroy()
+      resolve(true)
+    })
+    s.once("error", () => resolve(false))
+    setTimeout(() => {
+      s.destroy()
+      resolve(false)
+    }, 800)
+  })
+}

package/tests/admin-ensure.test.ts

@@ -3,7 +3,11 @@ import {
   ADMIN_EMAIL_ENV,
   ADMIN_PASSWORD_ENV,
   clearAdminSeedPassword,
+  composePostgresPassword,
+  GOTRUE_NIL_INSTANCE_ID,
+  gotrueJwtAud,
   hashPasswordForAuth,
+  resolveAuthConfirmedAtColumn,
 } from "../src/commands/admin.js"
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
@@ -38,6 +42,82 @@ describe("clearAdminSeedPassword", () => {
   })
 })
 
+describe("composePostgresPassword", () => {
+  it("reads POSTGRES_PASSWORD from .env", () => {
+    const dir = join(tmpdir(), `supatype-admin-pgpass-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(join(dir, ".env"), "POSTGRES_PASSWORD=secret\n", "utf8")
+    try {
+      expect(composePostgresPassword(dir)).toBe("secret")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("defaults to postgres when unset", () => {
+    const dir = join(tmpdir(), `supatype-admin-pgpass-default-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+    try {
+      expect(composePostgresPassword(dir)).toBe("postgres")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("gotrueJwtAud", () => {
+  it("reads GOTRUE_JWT_AUD from .env", () => {
+    const dir = join(tmpdir(), `supatype-admin-aud-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(join(dir, ".env"), "GOTRUE_JWT_AUD=custom-aud\n", "utf8")
+    try {
+      expect(gotrueJwtAud(dir)).toBe("custom-aud")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("defaults to authenticated", () => {
+    const dir = join(tmpdir(), `supatype-admin-aud-default-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+    try {
+      expect(gotrueJwtAud(dir)).toBe("authenticated")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("GOTRUE_NIL_INSTANCE_ID", () => {
+  it("is the nil UUID GoTrue uses for lookup", () => {
+    expect(GOTRUE_NIL_INSTANCE_ID).toBe("00000000-0000-0000-0000-000000000000")
+  })
+})
+
+describe("resolveAuthConfirmedAtColumn", () => {
+  it("prefers email_confirmed_at when both columns exist", async () => {
+    const column = await resolveAuthConfirmedAtColumn(async () => ({
+      rows: [{ column_name: "email_confirmed_at" }],
+      rowCount: 1,
+      command: "SELECT",
+      oid: 0,
+      fields: [],
+    }))
+    expect(column).toBe("email_confirmed_at")
+  })
+
+  it("falls back to confirmed_at for postgres init schema", async () => {
+    const column = await resolveAuthConfirmedAtColumn(async () => ({
+      rows: [{ value: "confirmed_at" }],
+      rowCount: 1,
+      command: "SELECT",
+      oid: 0,
+      fields: [],
+    }))
+    expect(column).toBe("confirmed_at")
+  })
+})
+
 describe("init admin seed in .env", () => {
   it("writes SUPATYPE_ADMIN_* when scaffold options include credentials", () => {
     const dir = join(tmpdir(), `supatype-init-admin-${Date.now()}`)

package/tests/binary-cache-cloud-overrides.test.ts

@@ -98,7 +98,7 @@ describe("VERSION_PIN_LOCAL + resolveBinary", () => {
 
   it("throws when versions.engine is local without overrides.engine", async () => {
     const cfg = baseConfig()
-    cfg.versions.engine = VERSION_PIN_LOCAL
+    cfg.versions!.engine = VERSION_PIN_LOCAL
     await expect(resolveBinary("engine", cfg)).rejects.toThrow(/overrides\.engine/)
   })
 
@@ -106,7 +106,7 @@ describe("VERSION_PIN_LOCAL + resolveBinary", () => {
     const fakeBin = join(tmp, "supatype-engine-local")
     writeFileSync(fakeBin, "#")
     const cfg = baseConfig({ engine: fakeBin })
-    cfg.versions.engine = VERSION_PIN_LOCAL
+    cfg.versions!.engine = VERSION_PIN_LOCAL
     const p = await resolveBinary("engine", cfg)
     expect(p.replace(/\\/g, "/")).toContain("supatype-engine-local")
   })

package/tests/binary-download-lock.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it, beforeEach, afterEach } from "vitest"
+import { existsSync, mkdirSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import {
+  tryAcquireDownloadLock,
+  releaseDownloadLock,
+  isDownloadInProgress,
+  clearDownloadLock,
+} from "../src/binary-download-lock.js"
+import { cachePath } from "../src/binary-cache.js"
+
+const VERSION = "9.9.9-test"
+
+describe("binary-download-lock", () => {
+  let dir: string
+
+  beforeEach(() => {
+    dir = cachePath("deno", VERSION)
+    if (existsSync(dir)) rmSync(dir, { recursive: true, force: true })
+    mkdirSync(dir, { recursive: true })
+  })
+
+  afterEach(() => {
+    clearDownloadLock("deno", VERSION)
+    if (existsSync(dir)) rmSync(dir, { recursive: true, force: true })
+  })
+
+  it("acquires and releases a download lock", () => {
+    expect(tryAcquireDownloadLock("deno", VERSION)).toBe(true)
+    expect(isDownloadInProgress("deno", VERSION)).toBe(true)
+    releaseDownloadLock("deno", VERSION)
+    expect(isDownloadInProgress("deno", VERSION)).toBe(false)
+  })
+
+  it("rejects a second acquire while the lock is held", () => {
+    expect(tryAcquireDownloadLock("deno", VERSION)).toBe(true)
+    expect(tryAcquireDownloadLock("deno", VERSION)).toBe(false)
+    releaseDownloadLock("deno", VERSION)
+  })
+})

package/tests/cli-help.test.ts

@@ -4,12 +4,15 @@
  */
 import { describe, it, expect } from "vitest"
 import { spawnSync } from "node:child_process"
-import { resolve, dirname } from "node:path"
+import { readFileSync } from "node:fs"
+import { resolve, dirname, join } from "node:path"
 import { fileURLToPath } from "node:url"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const CLI_BIN = resolve(__dirname, "../bin/supatype.js")
-const DIST_CLI = resolve(__dirname, "../dist/cli.js")
+const PACKAGE_VERSION = (
+  JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf8")) as { version: string }
+).version
 
 function runCli(args: string[]): { stdout: string; stderr: string; exitCode: number } {
   const result = spawnSync(process.execPath, [CLI_BIN, ...args], {
@@ -51,10 +54,10 @@ describe("CLI binary (requires built dist/)", () => {
     }
   })
 
-  it("--version prints a semver string", () => {
+  it("--version prints package.json version", () => {
     const { stdout, exitCode } = runCli(["--version"])
     expect(exitCode).toBe(0)
-    expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+/)
+    expect(stdout.trim()).toBe(PACKAGE_VERSION)
   })
 
   it("self-update --help describes the command", () => {