@supatype/cli 0.1.0-alpha.6 → 0.1.0-alpha.8

package/src/commands/diff.ts

@@ -1,14 +1,8 @@
 import type { Command } from "commander"
 import { loadConfig, loadSchemaAst } from "../config.js"
-import { ensureEngine, invokeEngine } from "../engine.js"
-
-interface DiffResult {
-  operations: Array<{
-    kind: string
-    risk: "safe" | "cautious" | "destructive"
-    description: string
-  }>
-}
+import { connectionString, schemaPathFromProject } from "../project-config.js"
+import { ensureEngine, engineRequest, type DiffResult } from "../engine-client.js"
+import { printDiffWarnings } from "../diff-output.js"
 
 export function registerDiff(program: Command): void {
   program
@@ -18,43 +12,51 @@ export function registerDiff(program: Command): void {
     .action(async (opts: { connection?: string }) => {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
-      const connection = opts.connection ?? config.connection
+      const connection = opts.connection ?? connectionString(config)
 
       await ensureEngine()
 
       console.log("Loading schema...")
-      const ast = loadSchemaAst(config.schema, cwd)
-
-      const result = invokeEngine(
-        ["diff", "--connection", connection, "--format", "json"],
-        JSON.stringify(ast),
-      )
-      if (result.exitCode !== 0) {
-        console.error(result.stderr || result.stdout)
-        process.exit(1)
-      }
+      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+
+      const diff = await engineRequest<DiffResult>("/diff", {
+        ast,
+        database_url: connection,
+        schema: "public",
+      })
 
-      const diff = JSON.parse(result.stdout) as DiffResult
       const ops = diff.operations ?? []
+      printDiffWarnings(diff)
 
       if (ops.length === 0) {
         console.log("No changes.")
         return
       }
 
-      const symbol = { safe: "+", cautious: "~", destructive: "!" }
-      const legend = { safe: "safe", cautious: "cautious", destructive: "DESTRUCTIVE" }
+      const symbol: Record<NonNullable<DiffResult["operations"][number]["risk"]>, string> = {
+        safe: "+",
+        warn: "~",
+        cautious: "~",
+        danger: "!",
+        destructive: "!",
+      }
+      const legend: typeof symbol = {
+        safe: "safe",
+        warn: "caution",
+        cautious: "caution",
+        danger: "DANGER",
+        destructive: "DANGER",
+      }
 
       console.log(`\n${ops.length} change(s):\n`)
       for (const op of ops) {
-        console.log(
-          `  [${symbol[op.risk]}] ${op.description}  (${legend[op.risk]})`,
-        )
+        const r = op.risk ?? "safe"
+        console.log(`  [${symbol[r]}] ${op.description}  (${legend[r]})`)
       }
 
-      const destructive = ops.filter((o) => o.risk === "destructive").length
-      if (destructive > 0) {
-        console.log(`\n  ${destructive} destructive operation(s). Run with --yes to skip confirmation.`)
+      const dangerous = ops.filter((o) => o.risk === "danger").length
+      if (dangerous > 0) {
+        console.log(`\n  ${dangerous} dangerous operation(s). Review before pushing.`)
       }
       console.log()
     })

package/src/commands/engine.ts

@@ -1,133 +1,30 @@
 /**
  * Engine management commands:
- *   supatype engine version      — show pinned, cached, and latest versions
- *   supatype engine update-check — check for newer engine versions
- *   supatype engine prune        — remove old cached engine versions
+ *   supatype engine status  — check if the engine container is reachable
  */
 
 import type { Command } from "commander"
-import { ENGINE_VERSION } from "../engine-version.js"
-import { detectPlatform } from "../engine/platform.js"
-import {
-  hasCachedBinary,
-  listCachedVersions,
-  pruneCacheExcept,
-  saveUpdateCheck,
-} from "../engine/cache.js"
-import { checkLatestVersion } from "../engine/resolve.js"
+import { engineHealth } from "../engine-client.js"
 
 export function registerEngine(program: Command): void {
   const engine = program
     .command("engine")
-    .description("Manage the Supatype engine binary")
+    .description("Manage the Supatype schema engine")
 
-  // supatype engine version
   engine
-    .command("version")
-    .description("Show engine version information")
+    .command("status")
+    .description("Check if the schema engine container is reachable")
     .action(async () => {
-      const platform = detectPlatform()
-      const cached = hasCachedBinary(ENGINE_VERSION, platform)
-      const cachedVersions = listCachedVersions()
+      const url = process.env["SUPATYPE_ENGINE_URL"] ?? "http://localhost:7500"
+      console.log(`Checking engine at ${url}...`)
 
-      console.log(`Engine: v${ENGINE_VERSION} (pinned)`)
-      console.log(
-        `Cache:  ${cached ? `v${ENGINE_VERSION} ✓` : "not downloaded"}`,
-      )
-
-      if (cachedVersions.length > 1) {
-        const others = cachedVersions.filter((v) => v !== ENGINE_VERSION)
-        console.log(`Other cached versions: ${others.join(", ")}`)
-      }
-
-      // Check latest
-      try {
-        const latest = await checkLatestVersion()
-        if (latest) {
-          await saveUpdateCheck(latest.version)
-          if (latest.version !== ENGINE_VERSION) {
-            console.log(
-              `Latest: v${latest.version} — update available, run: npm update @supatype/cli`,
-            )
-          } else {
-            console.log(`Latest: v${latest.version} (up to date)`)
-          }
-        }
-      } catch {
-        console.log("Latest: unable to check (offline?)")
-      }
-    })
-
-  // supatype engine update-check
-  engine
-    .command("update-check")
-    .description("Check if a newer engine version is available")
-    .action(async () => {
-      const latest = await checkLatestVersion()
-
-      if (!latest) {
-        console.error(
-          "Could not check for updates. Check your internet connection.",
-        )
-        process.exitCode = 1
-        return
-      }
-
-      await saveUpdateCheck(latest.version)
-
-      if (latest.version !== ENGINE_VERSION) {
-        console.log(
-          `Supatype engine v${latest.version} is available (current: v${ENGINE_VERSION}).`,
-        )
-        console.log(`Run: npm update @supatype/cli`)
+      const healthy = await engineHealth()
+      if (healthy) {
+        console.log("Engine is reachable and healthy.")
       } else {
-        console.log(`Engine v${ENGINE_VERSION} is up to date.`)
-      }
-    })
-
-  // supatype engine prune
-  engine
-    .command("prune")
-    .description("Remove all cached engine versions except the current one")
-    .action(() => {
-      const { removed, bytesFreed } = pruneCacheExcept(ENGINE_VERSION)
-
-      if (removed.length === 0) {
-        console.log("Nothing to prune — only the current version is cached.")
-        return
-      }
-
-      const mb = (bytesFreed / (1024 * 1024)).toFixed(1)
-      console.log(`Removed ${removed.length} cached version(s): ${removed.join(", ")}`)
-      console.log(`Space reclaimed: ${mb}MB`)
-    })
-
-  // supatype engine versions (list all released versions)
-  engine
-    .command("versions")
-    .description("List all released engine versions")
-    .action(async () => {
-      const { fetchJson } = await import("../engine/download.js")
-      const { CDN_BASE_URL } = await import("../engine-version.js")
-
-      interface VersionEntry {
-        version: string
-        date: string
-      }
-
-      const versions = await fetchJson<VersionEntry[]>(
-        `${CDN_BASE_URL}/versions.json`,
-      )
-
-      if (!versions || versions.length === 0) {
-        console.log("No released versions found.")
-        return
-      }
-
-      console.log("Released engine versions:")
-      for (const v of versions) {
-        const current = v.version === ENGINE_VERSION ? " (current)" : ""
-        console.log(`  v${v.version}  ${v.date}${current}`)
+        console.error("Engine is not reachable.")
+        console.error("Make sure the engine container is running (supatype dev or docker compose up).")
+        process.exitCode = 1
       }
     })
 }

package/src/commands/functions.ts

@@ -8,12 +8,23 @@ import {
   writeFileSync,
   unlinkSync,
 } from "node:fs"
-import { resolve, join, basename, relative } from "node:path"
+import { resolve, join, basename, relative, isAbsolute } from "node:path"
 import { spawnSync, execSync } from "node:child_process"
+import { localKongBaseUrl } from "../local-gateway.js"
+import { loadConfig } from "../config.js"
+import { ensureBinary } from "../ensure-binary.js"
+import {
+  functionsPathCandidatesFromProject,
+  preferredFunctionsPathFromProject,
+} from "../project-config.js"
+import {
+  discoverTsFunctionsInDir,
+  generateFunctionsRouterSource,
+} from "../functions-router-gen.js"
+import { selfHostComposePaths } from "../self-host-compose.js"
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
-const FUNCTIONS_DIR = "supatype/functions"
 const SHARED_DIR = "_shared"
 const ENV_LOCAL = ".env.local"
 const ENV_PRODUCTION = ".env.production"
@@ -36,9 +47,9 @@ export function registerFunctions(program: Command): void {
     .command("serve")
     .description("Start a local Deno server that serves all functions with hot reload")
     .option("--port <port>", "Port to serve on", "54321")
-    .option("--env-file <path>", "Path to env file", `${FUNCTIONS_DIR}/${ENV_LOCAL}`)
-    .action((opts: { port: string; envFile: string }) => {
-      serve(process.cwd(), opts)
+    .option("--env-file <path>", "Path to env file", ENV_LOCAL)
+    .action(async (opts: { port: string; envFile: string }) => {
+      await serve(process.cwd(), opts)
     })
 
   fnCmd
@@ -111,7 +122,8 @@ export function registerFunctions(program: Command): void {
 // ─── Scaffold ────────────────────────────────────────────────────────────────
 
 function scaffoldFunction(cwd: string, name: string): void {
-  const fnDir = resolve(cwd, FUNCTIONS_DIR, name)
+  const functionsDir = resolveFunctionsDir(cwd, "write")
+  const fnDir = resolve(functionsDir, name)
   if (existsSync(fnDir)) {
     console.error(`Function "${name}" already exists at ${relative(cwd, fnDir)}`)
     process.exit(1)
@@ -120,7 +132,7 @@ function scaffoldFunction(cwd: string, name: string): void {
   mkdirSync(fnDir, { recursive: true })
 
   const indexContent = `// ${name} — Supatype Edge Function
-// Docs: https://supatype.dev/docs/edge-functions
+// Docs: https://supatype.com/docs/edge-functions
 
 export default async function handler(req: Request): Promise<Response> {
   const { method, url } = req
@@ -144,7 +156,7 @@ export default async function handler(req: Request): Promise<Response> {
   writeFileSync(join(fnDir, "index.ts"), indexContent, "utf8")
 
   // Ensure _shared directory exists
-  const sharedDir = resolve(cwd, FUNCTIONS_DIR, SHARED_DIR)
+  const sharedDir = resolve(functionsDir, SHARED_DIR)
   if (!existsSync(sharedDir)) {
     mkdirSync(sharedDir, { recursive: true })
     writeFileSync(
@@ -155,7 +167,7 @@ export default async function handler(req: Request): Promise<Response> {
   }
 
   // Ensure .env.local exists
-  const envLocalPath = resolve(cwd, FUNCTIONS_DIR, ENV_LOCAL)
+  const envLocalPath = resolve(functionsDir, ENV_LOCAL)
   if (!existsSync(envLocalPath)) {
     writeFileSync(
       envLocalPath,
@@ -164,7 +176,8 @@ export default async function handler(req: Request): Promise<Response> {
     )
   }
 
-  console.log(`Created function: ${FUNCTIONS_DIR}/${name}/index.ts`)
+  const functionsDirLabel = relativeFunctionsDir(cwd, functionsDir)
+  console.log(`Created function: ${functionsDirLabel}/${name}/index.ts`)
   console.log()
   console.log("  Local dev:    npx supatype functions serve")
   console.log(`  Invoke:       npx supatype functions invoke ${name}`)
@@ -179,8 +192,36 @@ interface DiscoveredFunction {
   absPath: string
 }
 
+function resolveFunctionsDir(cwd: string, mode: "read" | "write"): string {
+  try {
+    const cfg = loadConfig(cwd)
+    if (mode === "write") {
+      return preferredFunctionsPathFromProject(cfg, cwd)
+    }
+    const candidates = functionsPathCandidatesFromProject(cfg, cwd)
+    return candidates.find(dir => existsSync(dir)) ?? candidates[0] ?? resolve(cwd, "functions")
+  } catch {
+    // Keep commands usable even if config cannot be loaded yet.
+    const modern = resolve(cwd, "functions")
+    const legacy = resolve(cwd, "supatype/functions")
+    if (mode === "write") return existsSync(legacy) ? legacy : modern
+    return existsSync(modern) ? modern : legacy
+  }
+}
+
+function relativeFunctionsDir(cwd: string, functionsDir: string): string {
+  const rel = relative(cwd, functionsDir)
+  return rel.length > 0 ? rel : "."
+}
+
+function resolveEnvFilePath(cwd: string, functionsDir: string, envFile: string): string {
+  if (isAbsolute(envFile)) return envFile
+  if (envFile.includes("/") || envFile.includes("\\")) return resolve(cwd, envFile)
+  return resolve(functionsDir, envFile)
+}
+
 function discoverFunctions(cwd: string): DiscoveredFunction[] {
-  const functionsDir = resolve(cwd, FUNCTIONS_DIR)
+  const functionsDir = resolveFunctionsDir(cwd, "read")
   if (!existsSync(functionsDir)) return []
 
   const entries = readdirSync(functionsDir)
@@ -210,26 +251,29 @@ function discoverFunctions(cwd: string): DiscoveredFunction[] {
 
 // ─── Serve (local dev) ──────────────────────────────────────────────────────
 
-function serve(cwd: string, opts: { port: string; envFile: string }): void {
-  const fns = discoverFunctions(cwd)
-  if (fns.length === 0) {
-    console.error(`No functions found in ${FUNCTIONS_DIR}/`)
+async function serve(cwd: string, opts: { port: string; envFile: string }): Promise<void> {
+  const config = loadConfig(cwd)
+  const functionsDir = resolveFunctionsDir(cwd, "read")
+  const functionsDirLabel = relativeFunctionsDir(cwd, functionsDir)
+  const routes = discoverTsFunctionsInDir(functionsDir)
+  if (routes.length === 0) {
+    console.error(`No functions found in ${functionsDirLabel}/`)
     console.error("Create one with: npx supatype functions new <name>")
     process.exit(1)
   }
 
-  console.log(`Discovered ${fns.length} function(s):`)
-  for (const fn of fns) {
+  console.log(`Discovered ${routes.length} function(s):`)
+  for (const fn of routes) {
     console.log(`  /${fn.name}  →  ${relative(cwd, fn.entrypoint)}`)
   }
   console.log()
 
   // Generate a Deno entry script that routes requests to the correct function
-  const routerScript = generateLocalRouter(fns, cwd)
-  const routerPath = resolve(cwd, FUNCTIONS_DIR, ".serve-router.ts")
+  const routerPath = resolve(functionsDir, ".serve-router.ts")
+  const routerScript = generateFunctionsRouterSource(routerPath, routes)
   writeFileSync(routerPath, routerScript, "utf8")
 
-  const envFilePath = resolve(cwd, opts.envFile)
+  const envFilePath = resolveEnvFilePath(cwd, functionsDir, opts.envFile)
   const envArgs: string[] = []
   if (existsSync(envFilePath)) {
     envArgs.push("--env-file", envFilePath)
@@ -238,8 +282,16 @@ function serve(cwd: string, opts: { port: string; envFile: string }): void {
   console.log(`Serving functions at http://localhost:${opts.port}/functions/v1/`)
   console.log("Watching for changes...\n")
 
+  let denoBin: string
+  try {
+    denoBin = await ensureBinary("deno", config)
+  } catch (err) {
+    console.error(`[supatype] Could not provision Deno v${config.versions.deno}: ${(err as Error).message}`)
+    process.exit(1)
+  }
+
   const result = spawnSync(
-    "deno",
+    denoBin,
     [
       "run",
       "--allow-net",
@@ -255,7 +307,9 @@ function serve(cwd: string, opts: { port: string; envFile: string }): void {
       env: {
         ...process.env,
         PORT: opts.port,
-        SUPATYPE_URL: process.env["SUPATYPE_URL"] ?? `http://localhost:8000`,
+        SUPATYPE_DENO_FUNCTIONS_DIR: functionsDir,
+        SUPATYPE_SHARED_ENV_FILE: resolve(functionsDir, ENV_LOCAL),
+        SUPATYPE_URL: process.env["SUPATYPE_URL"] ?? localKongBaseUrl(),
         SUPATYPE_ANON_KEY: process.env["SUPATYPE_ANON_KEY"] ?? "",
         SUPATYPE_SERVICE_ROLE_KEY: process.env["SUPATYPE_SERVICE_ROLE_KEY"] ?? "",
       },
@@ -267,61 +321,10 @@ function serve(cwd: string, opts: { port: string; envFile: string }): void {
 
   if (result.status !== 0) {
     console.error("Function server exited with errors.")
-    console.error("Make sure Deno is installed: https://deno.land/manual/getting_started/installation")
     process.exit(result.status ?? 1)
   }
 }
 
-function generateLocalRouter(fns: DiscoveredFunction[], cwd: string): string {
-  const imports = fns.map(
-    (fn, i) => `import handler_${i} from "./${relative(resolve(cwd, FUNCTIONS_DIR), fn.entrypoint).replace(/\\/g, "/")}"`,
-  )
-
-  const routes = fns.map(
-    (fn, i) => `  "${fn.name}": handler_${i},`,
-  )
-
-  return `// Auto-generated local function router — do not edit
-${imports.join("\n")}
-
-const handlers: Record<string, (req: Request) => Response | Promise<Response>> = {
-${routes.join("\n")}
-}
-
-const port = parseInt(Deno.env.get("PORT") ?? "54321", 10)
-
-Deno.serve({ port }, async (req: Request): Promise<Response> => {
-  const url = new URL(req.url)
-  const pathParts = url.pathname.replace(/^\\/functions\\/v1\\//, "").split("/")
-  const fnName = pathParts[0] ?? ""
-
-  if (!fnName || !handlers[fnName]) {
-    return new Response(JSON.stringify({
-      error: "not_found",
-      message: fnName ? \`Function "\${fnName}" not found\` : "No function specified",
-      available: Object.keys(handlers),
-    }), { status: 404, headers: { "Content-Type": "application/json" } })
-  }
-
-  try {
-    const start = performance.now()
-    const response = await handlers[fnName]!(req)
-    const duration = (performance.now() - start).toFixed(1)
-    console.log(\`\${req.method} /functions/v1/\${fnName} → \${response.status} (\${duration}ms)\`)
-    return response
-  } catch (err) {
-    console.error(\`Error in function "\${fnName}":\`, err)
-    return new Response(JSON.stringify({
-      error: "function_error",
-      message: err instanceof Error ? err.message : "Unknown error",
-    }), { status: 500, headers: { "Content-Type": "application/json" } })
-  }
-})
-
-console.log(\`Edge function server running on http://localhost:\${port}/functions/v1/\`)
-`
-}
-
 // ─── Deploy ──────────────────────────────────────────────────────────────────
 
 async function deploy(cwd: string, opts: { only?: string; dryRun?: boolean }): Promise<void> {
@@ -331,10 +334,12 @@ async function deploy(cwd: string, opts: { only?: string; dryRun?: boolean }): P
     : allFns
 
   if (fns.length === 0) {
+    const functionsDir = resolveFunctionsDir(cwd, "read")
+    const functionsDirLabel = relativeFunctionsDir(cwd, functionsDir)
     if (opts.only) {
-      console.error(`Function "${opts.only}" not found in ${FUNCTIONS_DIR}/`)
+      console.error(`Function "${opts.only}" not found in ${functionsDirLabel}/`)
     } else {
-      console.error(`No functions found in ${FUNCTIONS_DIR}/`)
+      console.error(`No functions found in ${functionsDirLabel}/`)
     }
     process.exit(1)
   }
@@ -348,50 +353,27 @@ async function deploy(cwd: string, opts: { only?: string; dryRun?: boolean }): P
     return
   }
 
-  // Check if this is a self-hosted deployment or cloud
-  const isSelfHosted = detectSelfHosted(cwd)
-
-  if (isSelfHosted) {
+  const composePath = selfHostComposePaths(cwd).composePath
+  if (existsSync(composePath)) {
     await deploySelfHosted(cwd, fns)
-  } else {
-    await deployCloud(cwd, fns)
+    return
   }
-}
 
-function detectSelfHosted(cwd: string): boolean {
-  return existsSync(resolve(cwd, "deploy/docker-compose.yml"))
+  await deployCloud(cwd, fns)
 }
 
 async function deploySelfHosted(cwd: string, fns: DiscoveredFunction[]): Promise<void> {
-  console.log("Self-hosted deployment detected.\n")
-  console.log("Bundling functions...\n")
-
-  const bundleDir = resolve(cwd, "deploy/functions")
-  mkdirSync(bundleDir, { recursive: true })
+  console.log("Self-host Compose deployment.\n")
+  console.log("Functions are served from your project functions/ directory (no bundle step).\n")
 
   for (const fn of fns) {
-    const start = Date.now()
-    const outFile = join(bundleDir, `${fn.name}.js`)
-
-    // Bundle with Deno
-    const result = spawnSync("deno", ["bundle", fn.entrypoint, outFile], {
-      stdio: "pipe",
-      cwd,
-    })
-
-    if (result.status !== 0) {
-      const stderr = result.stderr?.toString() ?? ""
-      console.error(`  ${fn.name} ✗ bundle failed`)
-      if (stderr) console.error(`    ${stderr.trim()}`)
-      continue
-    }
-
-    const duration = Date.now() - start
-    console.log(`  ${fn.name} ✓ deployed (${duration}ms)`)
+    console.log(`  ${fn.name}  →  ${relative(cwd, fn.entrypoint)}`)
   }
 
-  console.log(`\nDeployed ${fns.length} function(s) to deploy/functions/`)
-  console.log("The supatype-functions container will pick up changes automatically.")
+  console.log(`\n${fns.length} function(s) ready on disk.`)
+  console.log("Restart the functions-worker container to load changes:")
+  console.log("  supatype self-host compose restart functions-worker")
+  console.log("\nKong → supatype-server → functions-worker (per-project worker).")
 }
 
 async function deployCloud(cwd: string, fns: DiscoveredFunction[]): Promise<void> {
@@ -450,7 +432,7 @@ async function deployCloud(cwd: string, fns: DiscoveredFunction[]): Promise<void
   }
 
   console.log(`\nDeployed ${fns.length} function(s)`)
-  console.log(`Invoke: https://${linked.ref}.supatype.io/functions/v1/<name>`)
+  console.log(`Invoke: https://${linked.ref}.supatype.dev/functions/v1/<name>`)
 }
 
 function readFunctionSource(fn: DiscoveredFunction): string {
@@ -642,7 +624,7 @@ async function invoke(
     const { getLinkedProject, getCloudToken } = await loadCloudHelpers()
     const linked = getLinkedProject(cwd)
     if (linked) {
-      url = `https://${linked.ref}.supatype.io/functions/v1/${name}`
+      url = `https://${linked.ref}.supatype.dev/functions/v1/${name}`
       const token = getCloudToken()
       if (token && opts.auth) {
         headers["Authorization"] = `Bearer ${token}`
@@ -708,7 +690,7 @@ async function envList(cwd: string): Promise<void> {
 
   if (!linked) {
     // Show local env vars
-    const envPath = resolve(cwd, FUNCTIONS_DIR, ENV_LOCAL)
+    const envPath = resolve(resolveFunctionsDir(cwd, "read"), ENV_LOCAL)
     if (!existsSync(envPath)) {
       console.log("No environment variables configured.")
       return
@@ -780,7 +762,7 @@ async function envSet(cwd: string, keyvalue: string): Promise<void> {
 
   if (!linked) {
     // Set in local env file
-    const envPath = resolve(cwd, FUNCTIONS_DIR, ENV_LOCAL)
+    const envPath = resolve(resolveFunctionsDir(cwd, "write"), ENV_LOCAL)
     let content = existsSync(envPath) ? readFileSync(envPath, "utf8") : ""
 
     // Replace existing or append
@@ -832,7 +814,7 @@ async function envUnset(cwd: string, key: string): Promise<void> {
   const linked = getLinkedProject(cwd)
 
   if (!linked) {
-    const envPath = resolve(cwd, FUNCTIONS_DIR, ENV_LOCAL)
+    const envPath = resolve(resolveFunctionsDir(cwd, "read"), ENV_LOCAL)
     if (!existsSync(envPath)) {
       console.error("No local env file found.")
       process.exit(1)
@@ -913,7 +895,7 @@ async function loadCloudHelpers(): Promise<CloudHelpers> {
     },
 
     getCloudApiUrl(): string {
-      return process.env["SUPATYPE_API_URL"] ?? "https://api.supatype.io"
+      return process.env["SUPATYPE_API_URL"] ?? "https://api.supatype.com"
     },
   }
 }

package/src/commands/generate.ts

@@ -1,6 +1,10 @@
 import type { Command } from "commander"
+import { mkdirSync, writeFileSync } from "node:fs"
+import { resolve, dirname } from "node:path"
 import { loadConfig, loadSchemaAst } from "../config.js"
-import { ensureEngine, invokeEngine } from "../engine.js"
+import { schemaPathFromProject } from "../project-config.js"
+import { ensureEngine, engineRequest } from "../engine-client.js"
+import { generateClientAugmentation } from "../augmentation-generator.js"
 
 export function registerGenerate(program: Command): void {
   program
@@ -10,22 +14,31 @@ export function registerGenerate(program: Command): void {
     .action(async (opts: { connection?: string }) => {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
-      const connection = opts.connection ?? config.connection
+      const schemaPath = schemaPathFromProject(config, cwd)
+      const outputTypesPath = config.output?.types ?? "types/database.ts"
+      const outputClientPath = config.output?.client ?? "supatype/generated/index.d.ts"
 
       await ensureEngine()
       console.log("Loading schema...")
-      const ast = loadSchemaAst(config.schema, cwd)
+      const ast = loadSchemaAst(schemaPath, cwd)
 
-      const args = ["generate", "--connection", connection]
-      if (config.output?.types) args.push("--types", config.output.types)
-      if (config.output?.client) args.push("--client", config.output.client)
+      const result = await engineRequest<{ code?: string; message?: string }>("/generate", { ast, lang: "typescript" })
 
-      const result = invokeEngine(args, JSON.stringify(ast))
-      if (result.exitCode !== 0) {
-        console.error(result.stderr || result.stdout)
+      const typesCode = result.code ?? result.message
+      if (typesCode === undefined) {
+        console.error("Engine returned no output.")
         process.exit(1)
       }
 
-      console.log(result.stdout || "Types generated.")
+      const outPath = resolve(cwd, outputTypesPath)
+      mkdirSync(dirname(outPath), { recursive: true })
+      writeFileSync(outPath, typesCode, "utf8")
+      console.log(`Types written to ${outputTypesPath}`)
+
+      const augmentationOutPath = resolve(cwd, outputClientPath)
+      const augmentationCode = generateClientAugmentation(ast)
+      mkdirSync(dirname(augmentationOutPath), { recursive: true })
+      writeFileSync(augmentationOutPath, augmentationCode, "utf8")
+      console.log(`Client augmentation written to ${outputClientPath}`)
     })
 }