@supatype/cli 0.1.1 → 0.1.2

package/src/rest-cache-admin.ts

@@ -0,0 +1,135 @@
+/**
+ * Admin REST cache API client for CLI commands.
+ */
+
+import { readEnvValue } from "./env-file.js"
+import { resolveProjectApiUrl } from "./resolve-api-url.js"
+
+export interface RestCacheEntrySummary {
+  key: string
+  table?: string
+  scope?: string
+  method?: string
+  path?: string
+  raw_query?: string
+  ttl_seconds: number
+  size_bytes: number
+  cached_at?: string
+}
+
+export interface RestCacheListResponse {
+  entries: RestCacheEntrySummary[]
+  cursor: string
+}
+
+export interface RestCacheDetail extends RestCacheEntrySummary {
+  status_code: number
+  content_type?: string
+  body_preview?: string
+  body_json?: unknown
+}
+
+function serviceRoleKey(cwd: string): string {
+  const key =
+    readEnvValue(cwd, "SUPATYPE_SERVICE_ROLE_KEY", "").trim() ||
+    readEnvValue(cwd, "SERVICE_ROLE_KEY", "").trim()
+  if (!key) {
+    throw new Error("SERVICE_ROLE_KEY not found in .env — run supatype dev or supatype keys")
+  }
+  return key.trim()
+}
+
+function adminHeaders(cwd: string): Record<string, string> {
+  const key = serviceRoleKey(cwd)
+  return {
+    Authorization: `Bearer ${key}`,
+    apikey: key,
+    "Content-Type": "application/json",
+  }
+}
+
+function formatCacheApiError(
+  operation: string,
+  status: number,
+  body: string,
+  baseUrl: string,
+): string {
+  const trimmed = body.trim()
+  if (status === 404) {
+    return (
+      `${operation} failed (404): ${trimmed || "not found"}\n` +
+      `  API: ${baseUrl}/admin/v1/cache\n` +
+      "  Start the stack with `supatype dev`, or check SUPATYPE_URL / PUBLIC_SUPATYPE_URL in .env."
+    )
+  }
+  if (status === 403 && trimmed.includes("rest_cache_not_available")) {
+    return "REST server cache is not available on this plan or deployment."
+  }
+  if (status === 503 && trimmed.includes("valkey")) {
+    return "Valkey is not configured — server-side REST cache requires Valkey (supatype dev with docker)."
+  }
+  return `${operation} failed (${status}): ${trimmed || "(empty body)"}`
+}
+
+function normalizeListResponse(data: RestCacheListResponse): RestCacheListResponse {
+  return {
+    entries: data.entries ?? [],
+    cursor: data.cursor ?? "0",
+  }
+}
+
+export async function listRestCacheEntries(
+  cwd: string,
+  opts?: { table?: string | undefined; cursor?: string | undefined; limit?: number | undefined },
+): Promise<RestCacheListResponse> {
+  const baseUrl = resolveProjectApiUrl(cwd)
+  const params = new URLSearchParams()
+  if (opts?.table) params.set("table", opts.table)
+  if (opts?.cursor) params.set("cursor", opts.cursor)
+  if (opts?.limit !== undefined) params.set("limit", String(opts.limit))
+  const qs = params.toString()
+  const url = `${baseUrl}/admin/v1/cache${qs ? `?${qs}` : ""}`
+  const res = await fetch(url, { headers: adminHeaders(cwd) })
+  if (!res.ok) {
+    const body = await res.text()
+    throw new Error(formatCacheApiError("list cache", res.status, body, baseUrl))
+  }
+  const data = (await res.json()) as RestCacheListResponse
+  return normalizeListResponse(data)
+}
+
+export async function getRestCacheEntry(cwd: string, key: string): Promise<RestCacheDetail> {
+  const baseUrl = resolveProjectApiUrl(cwd)
+  const enc = Buffer.from(key, "utf8").toString("base64url")
+  const url = `${baseUrl}/admin/v1/cache/entries/${encodeURIComponent(enc)}`
+  const res = await fetch(url, { headers: adminHeaders(cwd) })
+  if (!res.ok) {
+    const body = await res.text()
+    throw new Error(formatCacheApiError("get cache entry", res.status, body, baseUrl))
+  }
+  return res.json() as Promise<RestCacheDetail>
+}
+
+export async function deleteRestCacheEntry(cwd: string, key: string): Promise<void> {
+  const baseUrl = resolveProjectApiUrl(cwd)
+  const enc = Buffer.from(key, "utf8").toString("base64url")
+  const url = `${baseUrl}/admin/v1/cache/entries/${encodeURIComponent(enc)}`
+  const res = await fetch(url, { method: "DELETE", headers: adminHeaders(cwd) })
+  if (!res.ok) {
+    const body = await res.text()
+    throw new Error(formatCacheApiError("delete cache entry", res.status, body, baseUrl))
+  }
+}
+
+export async function flushRestCache(cwd: string, table?: string): Promise<void> {
+  const baseUrl = resolveProjectApiUrl(cwd)
+  const params = new URLSearchParams()
+  if (table) params.set("table", table)
+  const qs = params.toString()
+  const url = `${baseUrl}/admin/v1/cache${qs ? `?${qs}` : ""}`
+  const res = await fetch(url, { method: "DELETE", headers: adminHeaders(cwd) })
+  if (!res.ok) {
+    const body = await res.text()
+    throw new Error(formatCacheApiError("flush cache", res.status, body, baseUrl))
+  }
+}

package/src/scripts/postinstall.ts

@@ -1,57 +1,20 @@
 /**
- * Postinstall script — downloads component binaries on first install.
+ * Postinstall script — @supatype/cli global/project install.
  *
- * Components: supatype-engine, supatype-server, supatype-pg (Postgres), deno.
- * Binaries are cached in ~/.supatype/cache/{component}/{version}/.
- *
- * Failures are non-fatal: an installation message is printed and the user
- * can run `supatype update` manually to retry.
+ * Host binaries (engine, server, postgres, deno) are downloaded on demand:
+ * - native provider: first supatype dev / supatype update
+ * - docker provider: Compose images on first supatype dev
  */
 
-import { download, currentPlatform, fetchAllLatestVersions, type Component } from "../binary-cache.js"
-
 async function main() {
-  const platform = currentPlatform()
-
-  let versions: Record<Component, string>
-  try {
-    console.log("[supatype] Fetching latest component versions...")
-    versions = await fetchAllLatestVersions()
-  } catch (err) {
-    console.error(`[supatype] Failed to fetch latest versions: ${(err as Error).message}`)
-    console.error("[supatype] Run 'supatype update' to download component binaries.")
-    return
-  }
-
-  console.log(`[supatype] Downloading component binaries for ${platform.os}/${platform.arch}...`)
-
-  const components = Object.entries(versions) as [Component, string][]
-
-  let anyFailed = false
-  for (const [component, version] of components) {
-    try {
-      await download(component, version, platform)
-    } catch (err) {
-      console.error(`[supatype] Failed to download ${component} v${version}: ${(err as Error).message}`)
-      anyFailed = true
-    }
-  }
-
-  if (anyFailed) {
-    // npm hides postinstall output unless --foreground-scripts, so don't rely on
-    // this being seen: the CLI re-attempts the download (with retry) on first use.
-    console.error(
-      "[supatype] Some component binaries failed to download. " +
-        "They will be re-downloaded automatically on first use; " +
-        "run 'supatype update' to retry now.",
-    )
-  } else {
-    console.log("[supatype] All component binaries downloaded successfully.")
-  }
+  console.log(
+    "[supatype] CLI installed. " +
+      "Runtime components download automatically on first use " +
+      "(supatype dev or supatype update).",
+  )
 }
 
 main().catch((err) => {
-  // Non-fatal — postinstall failures should not break npm install.
   console.error("[supatype] Postinstall failed:", err)
   process.exit(0)
 })

package/src/self-host-compose.ts

@@ -292,9 +292,7 @@ ${studioService}
     ? `      - "80:8000"
       - "443:8443"`
     : `      - "\${SUPATYPE_KONG_PORT:-18473}:8000"`
-  const kongTlsDependsOn = tlsEnabled ? "\n      - valkey" : ""
-  const valkeyBlock = tlsEnabled
-    ? `
+  const valkeyBlock = `
   valkey:
     image: \${SUPATYPE_VALKEY_IMAGE:-valkey/valkey:8-alpine}
     command: ["valkey-server", "--appendonly", "yes"]
@@ -303,23 +301,18 @@ ${studioService}
     volumes:
       - valkey-data:/data
 `
-    : ""
+  const kongValkeyDepends = "\n      - valkey"
   const tlsHintComment = tlsEnabled
     ? ""
     : `  # HTTPS is off. To enable automatic TLS (Let's Encrypt) for production, set in supatype.config.ts:
   #   server: { mode: "standalone", domain: "your.domain", tls: { email: "you@example.com" } }
   # then re-run \`supatype self-host compose up -d\`. Kong publishes :80/:443 and provisions certs automatically.
 `
-  const volumesBlock = tlsEnabled
-    ? `volumes:
+  const volumesBlock = `volumes:
   db-data:
   minio-data:
   valkey-data:
 `
-    : `volumes:
-  db-data:
-  minio-data:
-`
 
   return `# Generated by supatype self-host compose
 # Kong → supatype-server (unified gateway) → internal PostgREST / storage / etc.
@@ -431,6 +424,7 @@ ${serverPorts}    volumes:
       SUPATYPE_DENO_FUNCTIONS_DIR: /project/functions
       SUPATYPE_FUNCTIONS_WORKER_URL: http://functions-worker:8001
       SUPATYPE_CONTROL_PLANE_URL: http://control-plane:8080
+      SUPATYPE_VALKEY_ADDR: valkey:6379
 ${appEnv}
       GOTRUE_API_HOST: 0.0.0.0
       GOTRUE_API_PORT: 9999
@@ -450,6 +444,8 @@ ${devLocal ? "      STUDIO_OPEN_DEV: \"1\"\n" : ""}
     depends_on:
       db:
         condition: service_healthy
+      valkey:
+        condition: service_started
       postgrest:
         condition: service_started
       storage:
@@ -492,7 +488,7 @@ ${kongTlsEnv}    volumes:
     ports:
 ${kongPorts}
     depends_on:
-${kongDependsOn}${kongTlsDependsOn}
+${kongDependsOn}${kongValkeyDepends}
 
 ${volumesBlock}`
 }
@@ -594,7 +590,21 @@ export function runDockerCompose(
     ? { ...process.env, COMPOSE_PROGRESS: "quiet" }
     : process.env
   const stdio = options?.quiet ? "pipe" : "inherit"
-  const result = spawnSync("docker", composeArgs, { stdio, cwd: projectRoot, env })
+  const result = spawnSync("docker", composeArgs, {
+    stdio,
+    cwd: projectRoot,
+    env,
+    ...(options?.quiet ? { encoding: "utf8" as const } : {}),
+  })
+  if (options?.quiet && result.status !== 0) {
+    const detail = [result.stderr, result.stdout]
+      .filter((s): s is string => typeof s === "string" && s.trim() !== "")
+      .join("\n")
+      .trim()
+    if (detail) {
+      console.error(`[supatype] docker compose: ${detail}`)
+    }
+  }
   return result.status ?? 1
 }
 

package/src/studio-dev-server.ts

@@ -2,7 +2,8 @@ import { existsSync } from "node:fs"
 import { join, resolve } from "node:path"
 import { ProcessManager } from "./process-manager.js"
 
-const STUDIO_PORT = 3002
+/** Vite dev server port when `overrides.studio` is set. */
+export const STUDIO_DEV_PORT = 3002
 
 export interface StudioDevServerOptions {
   cwd: string
@@ -15,8 +16,8 @@ export interface StudioDevServerOptions {
    */
   proxyTarget: string
   /**
-   * Public Supatype URL the browser uses. Compose dev: Kong on the host.
-   * Native dev: Vite dev server (same origin as Studio).
+   * Browser API base URL. Must match the Vite dev origin (`http://localhost:3002`)
+   * so fetches hit the Vite proxy (SUPATYPE_PROXY_TARGET) and avoid CORS.
    */
   viteSupatypeUrl: string
   /** Vite `base` — `/studio/` when behind Kong at `/studio/`; `/` for native dev on :3002. */
@@ -35,7 +36,7 @@ export function startStudioViteDevServer(opts: StudioDevServerOptions): ProcessM
   const basePath = opts.basePath ?? "/"
   return new ProcessManager(
     process.execPath,
-    [viteJs, "--port", String(STUDIO_PORT), "--strictPort", "--host"],
+    [viteJs, "--port", String(STUDIO_DEV_PORT), "--strictPort", "--host"],
     {
       label: "studio",
       pidDir: opts.pidDir,

package/src/ui/README.md

@@ -1,17 +1,21 @@
 # CLI terminal UI (`packages/cli/src/ui/`)
 
-Shared output layer for `supatype` commands (not `supatype dev` TUI).
+Shared Ink-based design system for the Supatype CLI.
 
 | Module | Use for |
 |--------|---------|
-| `messages.ts` | `info` / `warn` / `error` (Clack log in TTY; `[supatype]` in CI), `file`, `step`, `plain` |
-| `fatal.ts` | `fatalError`, `reportCliFatal` — branded fatals + global catch helper |
-| `confirm.ts` | Yes/no prompts (Clack in TTY; respects `--yes` / non-TTY) |
-| `progress.ts` | `withSpinner` for long async work |
-| `prompts.ts` | Logo, Clack wizard helpers, `promptText` |
+| `theme.ts` | Brand + semantic colours (Ink + plain ANSI) |
+| `messages.ts` | `info` / `warn` / `error` / `success`, `file`, `step`, `plain` |
+| `fatal.ts` | `fatalError`, `reportCliFatal` |
+| `confirm.ts` | Yes/no prompts (Ink overlay in dev, Ink flow in TTY) |
+| `progress.ts` | `withSpinner` + `runCommandChrome` for one-shot commands |
+| `runtime/command-chrome.ts` | Ink shell (logo, logs, spinner) — applied globally via `wrapProgramActionsWithChrome` in `cli.ts` |
+| `prompts.ts` | Logo, `promptText`, `promptPassword`, `ensureNotCancelled` |
+| `clack.ts` | Clack-compatible `p.*` API + `runClackFlow()` for wizards |
+| `flows/` | Ink flow shell + prompt fields |
+| `dev/DevDashboard.tsx` | `supatype dev` task list + log pane + prompt overlay |
 | `next-steps.ts` | Bulleted follow-up commands |
-| `brand.ts` | ANSI colours + logo styling (shared with dev TUI) |
 
-**`supatype dev`** keeps its own alt-screen TUI (`dev-tui.ts`). Do not route dev logs through Clack.
+**Convention:** interactive wizards use `runClackFlow(async (p) => …)` (`init`, `link`, `add domain`); one-shot commands get branded chrome automatically in `cli.ts` via `wrapProgramActionsWithChrome`. **`supatype dev`** keeps a persistent Ink dashboard (excluded from auto-wrap).
 
-**Convention:** interactive multi-step flows use Clack (`init`, `add`, `link`); one-shot commands use `info` + optional `withSpinner`.
+**Plain profile:** when `!isInteractive()` (CI, pipes), helpers fall back to `[supatype]`-prefixed lines.

package/src/ui/brand.ts

@@ -1,12 +1,6 @@
 /**
  * Shared ANSI styling for Supatype CLI output and the dev TUI.
+ * @deprecated Prefer `theme.ts` for new code — re-exports kept for dev-logo / task colors.
  */
 
-export const RESET = "\x1b[0m"
-export const DIM = "\x1b[2m"
-export const BOLD = "\x1b[1m"
-export const BRAND_COLOR = "\x1b[35m"
-
-export function brandStyle(text: string): string {
-  return `${BRAND_COLOR}${BOLD}${text}${RESET}`
-}
+export { BOLD, BRAND_COLOR, brandStyle, DIM, RESET } from "./theme.js"

package/src/ui/clack-api.ts

@@ -0,0 +1,123 @@
+import type { FlowController } from "./flows/types.js"
+import type { DevSelectOption } from "./runtime/dev-prompt-queue.js"
+import { CLACK_CANCEL } from "./runtime/cancel.js"
+
+export interface ClackTextOptions {
+  message: string
+  defaultValue?: string
+  placeholder?: string
+  validate?: (value: string) => string | undefined
+}
+
+export interface ClackSelectOptions<T extends string = string> {
+  message: string
+  options: DevSelectOption<T>[]
+  initialValue?: T
+}
+
+export interface ClackConfirmOptions {
+  message: string
+  initialValue?: boolean
+}
+
+export interface ClackPasswordOptions {
+  message: string
+}
+
+export interface ClackSpinner {
+  start(message: string): void
+  stop(message: string): void
+}
+
+export interface ClackApi {
+  intro(message: string): void
+  outro(message: string): void
+  note(message: string): void
+  cancel(message: string): never
+  text(options: ClackTextOptions): Promise<string | typeof CLACK_CANCEL>
+  password(options: ClackPasswordOptions): Promise<string | typeof CLACK_CANCEL>
+  select<T extends string>(options: ClackSelectOptions<T>): Promise<T | typeof CLACK_CANCEL>
+  confirm(options: ClackConfirmOptions): Promise<boolean | typeof CLACK_CANCEL>
+  spinner(): ClackSpinner
+  log: {
+    info(message: string): void
+    warn(message: string): void
+    error(message: string): void
+    success(message: string): void
+  }
+}
+
+export function createClackApi(controller: FlowController): ClackApi {
+  return {
+    intro(message) {
+      controller.appendLog("plain", message)
+    },
+    outro(message) {
+      controller.appendLog("success", message)
+    },
+    note(message) {
+      for (const line of message.split("\n")) {
+        if (line.trim()) controller.appendPlain(line)
+      }
+    },
+    cancel(message): never {
+      controller.appendLog("warn", message)
+      process.exit(0)
+    },
+    async text(options) {
+      return controller.waitForPrompt<string>({
+        kind: "text",
+        message: options.message,
+        ...(options.defaultValue !== undefined ? { defaultValue: options.defaultValue } : {}),
+        ...(options.placeholder !== undefined ? { placeholder: options.placeholder } : {}),
+        ...(options.validate !== undefined ? { validate: options.validate } : {}),
+      })
+    },
+    async password(options) {
+      return controller.waitForPrompt<string>({
+        kind: "password",
+        message: options.message,
+      })
+    },
+    async select<T extends string>(options: ClackSelectOptions<T>) {
+      return controller.waitForPrompt<T>({
+        kind: "select",
+        message: options.message,
+        options: options.options,
+        ...(options.initialValue !== undefined ? { initialValue: options.initialValue } : {}),
+      })
+    },
+    async confirm(options) {
+      return controller.waitForPrompt<boolean>({
+        kind: "confirm",
+        message: options.message,
+        initialValue: options.initialValue ?? false,
+      })
+    },
+    spinner() {
+      return {
+        start(message: string) {
+          controller.setSpinner(message)
+        },
+        stop(message: string) {
+          controller.setSpinner(null)
+          controller.appendLog("success", message)
+        },
+      }
+    },
+    log: {
+      info(message) {
+        controller.appendLog("info", message)
+      },
+      warn(message) {
+        controller.appendLog("warn", message)
+      },
+      error(message) {
+        controller.appendLog("error", message)
+      },
+      success(message) {
+        controller.appendLog("success", message)
+      },
+    },
+  }
+}

package/src/ui/clack.ts

@@ -0,0 +1,153 @@
+/**
+ * Clack-compatible prompt API backed by Ink.
+ * Use inside `runClackFlow()` for multi-step wizards, or via `confirm()` / `promptText()` helpers.
+ */
+
+import { getActiveDevSession } from "../dev-session.js"
+import { createClackApi, type ClackApi } from "./clack-api.js"
+import { isInteractive } from "./interactive.js"
+import { CLACK_CANCEL, isCancel } from "./runtime/cancel.js"
+import { enqueueDevPrompt } from "./runtime/dev-prompt-queue.js"
+import { runClackFlow as mountClackFlow } from "./runtime/run-clack-flow.js"
+import type { DevSelectOption } from "./runtime/dev-prompt-queue.js"
+
+export { CLACK_CANCEL, isCancel }
+export type { ClackApi } from "./clack-api.js"
+
+import { getActiveFlowApi, setActiveFlowApi } from "./runtime/flow-session.js"
+
+function inDevTui(): boolean {
+  const session = getActiveDevSession()
+  return Boolean(session?.isTui() && session.isInkMounted())
+}
+
+async function devOrFlow<T>(
+  spec: Parameters<typeof enqueueDevPrompt>[0],
+  flowFn: (api: ClackApi) => Promise<T>,
+): Promise<T | typeof CLACK_CANCEL> {
+  if (inDevTui()) {
+    return enqueueDevPrompt(spec) as Promise<T | typeof CLACK_CANCEL>
+  }
+  const api = getActiveFlowApi()
+  if (api) {
+    return flowFn(api)
+  }
+  return mountClackFlow(async (flowApi) => flowFn(flowApi))
+}
+
+export async function runClackFlow<T>(run: (api: ClackApi) => Promise<T>): Promise<T> {
+  return mountClackFlow(async (api) => {
+    setActiveFlowApi(api)
+    try {
+      return await run(api)
+    } finally {
+      setActiveFlowApi(null)
+    }
+  })
+}
+
+export { getActiveFlowApi } from "./runtime/flow-session.js"
+
+export const p: ClackApi = {
+  intro(message) {
+    const api = getActiveFlowApi()
+    if (api) api.intro(message)
+    else console.log(`\n${message}\n`)
+  },
+  outro(message) {
+    const api = getActiveFlowApi()
+    if (api) api.outro(message)
+    else console.log(`\n${message}\n`)
+  },
+  note(message) {
+    const api = getActiveFlowApi()
+    if (api) api.note(message)
+    else {
+      for (const line of message.split("\n")) {
+        if (line.trim()) console.log(`  ${line}`)
+      }
+    }
+  },
+  cancel(message): never {
+    const api = getActiveFlowApi()
+    if (api) {
+      api.cancel(message)
+    }
+    console.log(message)
+    process.exit(0)
+  },
+  async text(options) {
+    return devOrFlow(
+      {
+        kind: "text",
+        message: options.message,
+        ...(options.defaultValue !== undefined ? { defaultValue: options.defaultValue } : {}),
+        ...(options.placeholder !== undefined ? { placeholder: options.placeholder } : {}),
+        ...(options.validate !== undefined ? { validate: options.validate } : {}),
+      },
+      (api) => api.text(options),
+    )
+  },
+  async password(options) {
+    return devOrFlow({ kind: "password", message: options.message }, (api) => api.password(options))
+  },
+  async select<T extends string>(options: { message: string; options: DevSelectOption<T>[]; initialValue?: T }) {
+    return devOrFlow(
+      {
+        kind: "select",
+        message: options.message,
+        options: options.options,
+        ...(options.initialValue !== undefined ? { initialValue: options.initialValue as string | boolean } : {}),
+      },
+      (api) => api.select(options),
+    )
+  },
+  async confirm(options) {
+    return devOrFlow(
+      {
+        kind: "confirm",
+        message: options.message,
+        initialValue: options.initialValue ?? false,
+      },
+      (api) => api.confirm(options),
+    )
+  },
+  spinner() {
+    const api = getActiveFlowApi()
+    if (api) return api.spinner()
+    return {
+      start(message: string) {
+        console.log(`${message}...`)
+      },
+      stop(message: string) {
+        console.log(message)
+      },
+    }
+  },
+  log: {
+    info(message) {
+      const api = getActiveFlowApi()
+      if (api) api.log.info(message)
+      else if (isInteractive()) console.log(message)
+      else console.log(`[supatype] ${message}`)
+    },
+    warn(message) {
+      const api = getActiveFlowApi()
+      if (api) api.log.warn(message)
+      else console.warn(`[supatype] ${message}`)
+    },
+    error(message) {
+      const api = getActiveFlowApi()
+      if (api) api.log.error(message)
+      else console.error(`[supatype] ${message}`)
+    },
+    success(message) {
+      const api = getActiveFlowApi()
+      if (api) api.log.success(message)
+      else console.log(`[supatype] ${message}`)
+    },
+  },
+}
+
+/** @deprecated Use `p` from this module inside `runClackFlow`. */
+export { p as clack }

package/src/ui/components/FlowSpinner.tsx

@@ -0,0 +1,15 @@
+import React from "react"
+import { Box, Text } from "ink"
+import Spinner from "ink-spinner"
+import { theme } from "../theme.js"
+
+export function FlowSpinner({ message }: { message: string }): React.ReactElement {
+  return (
+    <Box marginBottom={1}>
+      <Text color={theme.brand}>
+        <Spinner type="dots" />
+        {` ${message}`}
+      </Text>
+    </Box>
+  )
+}