@supatype/cli 0.1.2 → 0.1.4

package/src/config.ts

@@ -158,7 +158,7 @@ process.stdout.write(JSON.stringify(config))
     }
 
     const failure = result.stderr || result.stdout
-    if (!failure.includes("ERR_PACKAGE_PATH_NOT_EXPORTED")) {
+    if (!shouldStripCliImportOnLoadFailure(failure)) {
       throw new Error(`Failed to load ${candidate}:\n${failure}`)
     }
 
@@ -169,6 +169,18 @@ process.stdout.write(JSON.stringify(config))
   return null
 }
 
+/** When @supatype/cli is not installed yet (e.g. during `supatype init`), strip its import. */
+function shouldStripCliImportOnLoadFailure(failure: string): boolean {
+  if (failure.includes("ERR_PACKAGE_PATH_NOT_EXPORTED")) return true
+  if (!failure.includes("@supatype/cli")) return false
+  return (
+    failure.includes("ERR_MODULE_NOT_FOUND") ||
+    failure.includes("MODULE_NOT_FOUND") ||
+    failure.includes("Cannot find module '@supatype/cli'") ||
+    failure.includes('Cannot find package \'@supatype/cli\'')
+  )
+}
+
 function loadTsConfigWithoutCliImport(
   configPath: string,
   cwd: string,

package/src/dev-compose.ts

@@ -768,10 +768,6 @@ export async function runDevCompose(cwd: string, config: SupatypeProjectConfig,
     console.error("[supatype] Initial schema push failed:", (e as Error).message),
   )
 
-  await ensureFirstAdminUserForProject(cwd, config, {
-    compose: { project, composePath: paths.composePath },
-  })
-
   if (localServerImage !== undefined) {
     console.log("[supatype] Recreating server with local image...")
     const recreateStatus = runDockerCompose(
@@ -792,6 +788,10 @@ export async function runDevCompose(cwd: string, config: SupatypeProjectConfig,
   console.log("[supatype] Waiting for storage API...")
   await waitStorageApiReady(kongPort, serviceRoleKey, 90)
 
+  await ensureFirstAdminUserForProject(cwd, config, {
+    compose: { project, composePath: paths.composePath },
+  })
+
   writeLocalEnvironment(cwd, {
     target: "local",
     apiUrl: `http://localhost:${kongPort}`,

package/src/dev-log-bus.ts

@@ -3,7 +3,7 @@
  */
 
 import type { DevReadyPanel } from "./dev-ready-panel.js"
-import { devReadyPanelRowCount } from "./dev-ready-panel.js"
+import { devReadyPanelCompactRowCount, devReadyPanelRowCount } from "./dev-ready-panel.js"
 
 export type DevLogLevel = "log" | "warn" | "error"
 
@@ -79,9 +79,11 @@ export class DevLogBus {
     return this.readyPanel
   }
 
-  readyPanelRowCount(): number {
+  readyPanelRowCount(compact = false): number {
     if (!this.readyPanel) return 0
-    return devReadyPanelRowCount(this.readyPanel)
+    return compact
+      ? devReadyPanelCompactRowCount(this.readyPanel)
+      : devReadyPanelRowCount(this.readyPanel)
   }
 
   append(taskId: string, line: string, level: DevLogLevel = "log"): void {

package/src/dev-ready-panel.ts

@@ -34,6 +34,23 @@ export function devReadyPanelRowCount(panel: DevReadyPanel): number {
   return rows
 }
 
+/** Shorter panel when the terminal is too small for every service row. */
+export function devReadyPanelCompactRowCount(panel: DevReadyPanel): number {
+  let rows = 2 // border
+  rows += 1 // title
+  rows += 2 // gateway + studio summary
+  for (const hint of panel.hints ?? []) {
+    if (hint.trim()) rows += 1
+  }
+  if (panel.anonKey) {
+    rows += 1
+    rows += 1
+    if (panel.serviceRoleKey) rows += 1
+  }
+  rows += 1 // marginBottom
+  return rows
+}
+
 function formatStreamBlock(panel: DevReadyPanel): string {
   const lines = [`[supatype] ${panel.title}`]
   for (const link of panel.links) {

package/src/init-project-detect.ts

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs"
+import { join } from "node:path"
+
+const VITE_CONFIG_NAMES = [
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.cjs",
+] as const
+
+const SUPATYPE_CONFIG_NAMES = [
+  "supatype.config.ts",
+  "supatype.config.js",
+  "supatype.config.mjs",
+] as const
+
+export interface DetectedProjectSetup {
+  /** Directory has files other than `.git`. */
+  hasExistingFiles: boolean
+  hasSupatypeConfig: boolean
+  hasVite: boolean
+  hasViteConfig: boolean
+  viteDevUrl: string
+  staticDir: string
+  /** Human-readable bullets for the init wizard. */
+  summaryLines: string[]
+}
+
+function hasPackageVite(cwd: string): boolean {
+  const pkgPath = join(cwd, "package.json")
+  if (!existsSync(pkgPath)) return false
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
+      dependencies?: Record<string, string>
+      devDependencies?: Record<string, string>
+    }
+    return Boolean(pkg.devDependencies?.["vite"] ?? pkg.dependencies?.["vite"])
+  } catch {
+    return false
+  }
+}
+
+function readVitePort(cwd: string): number {
+  for (const name of VITE_CONFIG_NAMES) {
+    const path = join(cwd, name)
+    if (!existsSync(path)) continue
+    const src = readFileSync(path, "utf8")
+    const portMatch = src.match(/port:\s*(\d+)/)
+    if (portMatch?.[1]) {
+      const port = Number.parseInt(portMatch[1], 10)
+      if (Number.isInteger(port) && port > 0) return port
+    }
+  }
+  return 5173
+}
+
+function detectStaticDir(cwd: string): string {
+  if (existsSync(join(cwd, "dist", "index.html"))) return "./dist"
+  if (existsSync(join(cwd, "public", "index.html"))) return "./public"
+  if (existsSync(join(cwd, "dist"))) return "./dist"
+  if (existsSync(join(cwd, "public"))) return "./public"
+  return "./public"
+}
+
+/** Inspect `cwd` before init prompts — Vite, static dir, existing Supatype config. */
+export function detectProjectSetup(cwd: string): DetectedProjectSetup {
+  let entries: string[] = []
+  try {
+    entries = readdirSync(cwd).filter((entry) => entry !== ".git")
+  } catch {
+    entries = []
+  }
+
+  const hasExistingFiles = entries.length > 0
+  const hasViteConfig = VITE_CONFIG_NAMES.some((name) => existsSync(join(cwd, name)))
+  const hasVite = hasViteConfig || hasPackageVite(cwd)
+  const viteDevUrl = `http://127.0.0.1:${readVitePort(cwd)}`
+  const staticDir = detectStaticDir(cwd)
+  const hasSupatypeConfig = SUPATYPE_CONFIG_NAMES.some((name) => existsSync(join(cwd, name)))
+
+  const summaryLines: string[] = []
+  if (hasSupatypeConfig) summaryLines.push("supatype.config already present")
+  if (hasViteConfig) summaryLines.push(`Vite config found (${viteDevUrl})`)
+  else if (hasVite) summaryLines.push(`Vite dependency in package.json (${viteDevUrl})`)
+  if (existsSync(join(cwd, staticDir.replace(/^\.\//, "")))) {
+    summaryLines.push(`static assets in ${staticDir}`)
+  }
+  if (existsSync(join(cwd, "package.json"))) summaryLines.push("package.json present")
+
+  return {
+    hasExistingFiles,
+    hasSupatypeConfig,
+    hasVite,
+    hasViteConfig,
+    viteDevUrl,
+    staticDir,
+    summaryLines,
+  }
+}

package/src/type-extractor.ts

@@ -265,6 +265,58 @@ function getPropertyName(name: ts.PropertyName): string | null {
   return null
 }
 
+/**
+ * Known @supatype/types intersection mixins and the field source text they contribute.
+ * Used when a mixin type can't be resolved from the local alias registry
+ * (it comes from the external @supatype/types package, not a local file).
+ */
+const KNOWN_MIXIN_SOURCES: Record<string, string> = {
+  Timestamps: "{ created_at: ServerDefault<Date>; updated_at: ServerDefault<Date> }",
+  SoftDelete: "{ deleted_at: Optional<Date> }",
+  Publishable: "{ published_at: Optional<Date> }",
+}
+
+function synthesizeTypeLiteralMembers(source: string): ts.TypeElement[] {
+  const synth = ts.createSourceFile(
+    "__synth__.ts",
+    `type __T__ = ${source}`,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  )
+  const decl = synth.statements[0]
+  if (!decl || !ts.isTypeAliasDeclaration(decl) || !ts.isTypeLiteralNode(decl.type)) return []
+  return [...decl.type.members]
+}
+
+function mergeIntersectionParts(
+  parts: readonly ts.TypeNode[],
+  sourceFile: ts.SourceFile,
+  resolveCtx: ResolveContext,
+  depth: number,
+): ts.TypeLiteralNode | null {
+  const allMembers: ts.TypeElement[] = []
+  for (const part of parts) {
+    const resolved = unwrapModelFields(part, sourceFile, resolveCtx, depth + 1)
+    if (resolved) {
+      allMembers.push(...resolved.members)
+      continue
+    }
+    // Fall back to known @supatype/types intersection mixins (Timestamps, SoftDelete, Publishable)
+    if (ts.isTypeReferenceNode(part) && ts.isIdentifier(part.typeName)) {
+      const typeName = applyImportRename(part.typeName.text, sourceFile, resolveCtx.renameMap)
+      const mixinSource = KNOWN_MIXIN_SOURCES[typeName]
+      if (mixinSource) {
+        allMembers.push(...synthesizeTypeLiteralMembers(mixinSource))
+        continue
+      }
+    }
+    // Unresolvable parts are skipped — the model still extracts with whatever fields were found
+  }
+  if (allMembers.length === 0) return null
+  return ts.factory.createTypeLiteralNode(allMembers)
+}
+
 function unwrapModelFields(
   typeNode: ts.TypeNode,
   sourceFile: ts.SourceFile,
@@ -274,6 +326,11 @@ function unwrapModelFields(
   if (depth > 16) return null
   if (ts.isTypeLiteralNode(typeNode)) return typeNode
 
+  // Handle intersection types: `{ …fields } & Timestamps`, `{ …fields } & SoftDelete`, etc.
+  if (ts.isIntersectionTypeNode(typeNode)) {
+    return mergeIntersectionParts(typeNode.types, sourceFile, resolveCtx, depth)
+  }
+
   if (needsChecker(typeNode)) {
     const resolved = resolveTypeNode(typeNode, sourceFile, resolveCtx)
     if (ts.isTypeLiteralNode(resolved)) return resolved

package/src/ui/dev/DevDashboard.tsx

@@ -22,6 +22,9 @@ const TASK_COL_WIDTH = 22
 const MIN_WIDTH = 60
 const MIN_HEIGHT = 14
 const TAGLINE = "local development"
+const CHROME_ABOVE_LOG = 2 // separator + keybindings
+const CHROME_BELOW_LOG = 2 // footer separator + focused line
+const MIN_LOG_ROWS = 3
 
 function truncate(text: string, width: number): string {
   if (width <= 0) return ""
@@ -97,10 +100,15 @@ export function DevDashboard({ bus }: DevDashboardProps): React.ReactElement {
   const focusedId = bus.getFocusedTaskId()
   const taskIds = bus.getTaskOrder()
   const readyPanel = bus.getReadyPanel()
-  const readyRows = readyPanel ? bus.readyPanelRowCount() : 0
   const logoRows = logoRowCount() + 1 // figlet + tagline
-  const chromeRows = logoRows + readyRows + 2 // separator + keybindings line
-  const logHeight = Math.max(4, rows - chromeRows - (promptOpen ? 6 : 0) - 1)
+  const promptRows = promptOpen ? 6 : 0
+  const fullReadyRows = readyPanel ? bus.readyPanelRowCount(false) : 0
+  const availableForPanel =
+    rows - logoRows - CHROME_ABOVE_LOG - CHROME_BELOW_LOG - MIN_LOG_ROWS - promptRows
+  const useCompactPanel = readyPanel !== null && fullReadyRows > availableForPanel
+  const readyRows = readyPanel ? bus.readyPanelRowCount(useCompactPanel) : 0
+  const chromeRows = logoRows + readyRows + CHROME_ABOVE_LOG + CHROME_BELOW_LOG + promptRows
+  const logHeight = Math.max(0, rows - chromeRows)
   const logWidth = cols - TASK_COL_WIDTH - 1
 
   useInput((input, key) => {
@@ -148,7 +156,9 @@ export function DevDashboard({ bus }: DevDashboardProps): React.ReactElement {
   return (
     <Box flexDirection="column" width={cols} height={rows}>
       <LogoWordmark maxWidth={cols} tagline={TAGLINE} />
-      {readyPanel ? <DevReadyPanelView panel={readyPanel} width={cols} /> : null}
+      {readyPanel ? (
+        <DevReadyPanelView panel={readyPanel} width={cols} compact={useCompactPanel} />
+      ) : null}
       <Text dimColor>{"─".repeat(cols)}</Text>
       <Text dimColor>
         {truncate(" ↑/k ↓/j task  u/d scroll  g/G top/bottom  Ctrl+C quit", cols)}

package/src/ui/dev/DevReadyPanelView.tsx

@@ -21,12 +21,70 @@ function panelInnerWidth(outerWidth: number): number {
   return Math.max(20, outerWidth - 4)
 }
 
+function ServiceLinkRow({
+  label,
+  url,
+  innerWidth,
+  labelWidth,
+}: {
+  label: string
+  url: string
+  innerWidth: number
+  labelWidth: number
+}): React.ReactElement {
+  return (
+    <Text wrap="truncate">
+      <Text dimColor>{truncate(label.padEnd(labelWidth), labelWidth)}</Text>
+      <Text color={theme.info}>{truncate(url, Math.max(8, innerWidth - labelWidth))}</Text>
+    </Text>
+  )
+}
+
+function CompactLinks({ panel, innerWidth }: { panel: DevReadyPanel; innerWidth: number }): React.ReactElement {
+  const gateway = panel.links.find((link) => link.label === "API")?.url ?? panel.links[0]?.url ?? ""
+  const studio =
+    panel.links.find((link) => link.label === "Studio")?.url ??
+    panel.links[panel.links.length - 1]?.url ??
+    ""
+  const otherPaths = panel.links
+    .filter((link) => link.label !== "API" && link.label !== "Studio")
+    .map((link) => {
+      const prefix = `${link.url.split("://")[0] ?? "http"}://`
+      const path = link.url.slice(link.url.indexOf("://") + 3)
+      const slash = path.indexOf("/")
+      return slash >= 0 ? path.slice(slash) : link.url
+    })
+    .join(", ")
+
+  return (
+    <>
+      <Text wrap="truncate">
+        <Text dimColor>{"Gateway".padEnd(14)}</Text>
+        <Text color={theme.info}>{truncate(gateway, innerWidth - 14)}</Text>
+      </Text>
+      {otherPaths ? (
+        <Text dimColor wrap="truncate">
+          {truncate(`Also: ${otherPaths}`, innerWidth)}
+        </Text>
+      ) : null}
+      {studio ? (
+        <Text wrap="truncate">
+          <Text dimColor>{"Studio".padEnd(14)}</Text>
+          <Text color={theme.info}>{truncate(studio, innerWidth - 14)}</Text>
+        </Text>
+      ) : null}
+    </>
+  )
+}
+
 export function DevReadyPanelView({
   panel,
   width,
+  compact = false,
 }: {
   panel: DevReadyPanel
   width: number
+  compact?: boolean
 }): React.ReactElement {
   const innerWidth = panelInnerWidth(width)
   const labelWidth = 14
@@ -34,6 +92,8 @@ export function DevReadyPanelView({
   return (
     <Box
       flexDirection="column"
+      flexShrink={0}
+      width={width}
       marginBottom={1}
       borderStyle="round"
       borderColor={theme.brand}
@@ -42,23 +102,30 @@ export function DevReadyPanelView({
       <Text bold color={theme.brand}>
         {truncate(panel.title, innerWidth)}
       </Text>
-      {panel.links.map((link) => (
-        <Box key={`${link.label}-${link.url}`}>
-          <Text dimColor>{truncate(link.label.padEnd(labelWidth), labelWidth)}</Text>
-          <Text color={theme.info}>{truncate(link.url, innerWidth - labelWidth)}</Text>
-        </Box>
-      ))}
+      {compact ? (
+        <CompactLinks panel={panel} innerWidth={innerWidth} />
+      ) : (
+        panel.links.map((link) => (
+          <ServiceLinkRow
+            key={`${link.label}-${link.url}`}
+            label={link.label}
+            url={link.url}
+            innerWidth={innerWidth}
+            labelWidth={labelWidth}
+          />
+        ))
+      )}
       {panel.hints?.map((hint) => (
-        <Text key={hint} dimColor>
+        <Text key={hint} dimColor wrap="truncate">
           {truncate(hint, innerWidth)}
         </Text>
       ))}
       {panel.anonKey ? (
         <>
           <Text dimColor>API keys (local dev)</Text>
-          <Text dimColor>{`anon ${shortenKey(panel.anonKey, innerWidth - 5)}`}</Text>
+          <Text dimColor wrap="truncate">{`anon ${shortenKey(panel.anonKey, innerWidth - 5)}`}</Text>
           {panel.serviceRoleKey ? (
-            <Text dimColor>{`svc  ${shortenKey(panel.serviceRoleKey, innerWidth - 5)}`}</Text>
+            <Text dimColor wrap="truncate">{`svc  ${shortenKey(panel.serviceRoleKey, innerWidth - 5)}`}</Text>
           ) : null}
         </>
       ) : null}

package/src/ui/flows/FlowApp.tsx

@@ -36,6 +36,8 @@ export function FlowApp({ bind }: FlowAppProps): React.ReactElement {
       },
       waitForPrompt<T>(spec: ActiveFlowPrompt): Promise<T> {
         return new Promise<T>((resolve) => {
+          setLogLines([])
+          setSpinner(null)
           setPrompt(spec)
           setPromptResolver(() => (value: unknown) => {
             setPrompt(null)
@@ -51,7 +53,7 @@ export function FlowApp({ bind }: FlowAppProps): React.ReactElement {
   return (
     <Box flexDirection="column" paddingX={1}>
       <FlowLogoHeader />
-      <FlowLogPane lines={logLines} />
+      {prompt ? null : <FlowLogPane lines={logLines} />}
       {spinner ? <FlowSpinnerLine message={spinner} /> : null}
       {prompt && promptResolver ? (
         <PromptPanel>

package/src/ui/flows/prompt-fields.tsx

@@ -46,10 +46,16 @@ export function ConfirmPrompt({ spec, onSubmit }: ConfirmPromptProps): React.Rea
   const [value, setValue] = useState(spec.initialValue)
 
   useInput((input, key) => {
+    if (input === "y" || input === "Y") {
+      onSubmit(true)
+      return
+    }
+    if (input === "n" || input === "N") {
+      onSubmit(false)
+      return
+    }
     if (key.leftArrow || input === "h") setValue(false)
     if (key.rightArrow || input === "l") setValue(true)
-    if (input === "y" || input === "Y") setValue(true)
-    if (input === "n" || input === "N") setValue(false)
     if (key.return) onSubmit(value)
   })
 
@@ -60,19 +66,19 @@ export function ConfirmPrompt({ spec, onSubmit }: ConfirmPromptProps): React.Rea
       </Text>
       <Text>
         {value ? (
-          <Text color={theme.success} bold>
+          <Text color={theme.brand} bold>
             Yes
           </Text>
         ) : (
-          <Text>Yes</Text>
+          <Text dimColor>Yes</Text>
         )}
-        <Text> / </Text>
+        <Text dimColor> / </Text>
         {!value ? (
-          <Text color={theme.success} bold>
+          <Text color={theme.brand} bold>
             No
           </Text>
         ) : (
-          <Text>No</Text>
+          <Text dimColor>No</Text>
         )}
         <Text dimColor> — y/n, ←/→, enter</Text>
       </Text>

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

@@ -1,8 +1,9 @@
 import React, { useRef } from "react"
-import { render } from "ink"
+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>
@@ -37,16 +38,28 @@ export async function runClackFlow<T>(run: (api: ClackApi) => Promise<T>): Promi
       <RunClackFlowRoot
         run={run as (api: ClackApi) => Promise<unknown>}
         onComplete={(value) => {
-          instance.unmount()
+          teardownInk(instance)
           resolve(value as T)
         }}
         onError={(err) => {
-          instance.unmount()
+          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/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/config.test.ts

@@ -179,6 +179,25 @@ describe("loadConfig()", () => {
     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()", () => {