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

package/src/cli.ts

@@ -1,7 +1,9 @@
 import { Command } from "commander"
-import { ENGINE_VERSION } from "./engine-version.js"
 import { registerInit } from "./commands/init.js"
 import { registerDev } from "./commands/dev.js"
+import { registerCache } from "./commands/cache.js"
+import { registerUpdate } from "./commands/update.js"
+import { registerPg } from "./commands/pg.js"
 import { registerPush } from "./commands/push.js"
 import { registerDiff } from "./commands/diff.js"
 import { registerPull } from "./commands/pull.js"
@@ -20,16 +22,22 @@ import { registerLogs } from "./commands/logs.js"
 import { registerAdmin } from "./commands/admin.js"
 import { registerFunctions } from "./commands/functions.js"
 import { registerPlugins } from "./commands/plugins.js"
-import { showUpdateNotification } from "./engine/update-notify.js"
+import { registerTypes } from "./commands/types.js"
+import { registerMigrateFromV1 } from "./commands/migrate-from-v1.js"
+import { registerSelfUpdate } from "./commands/self-update.js"
 
 export function run(): void {
   const program = new Command()
     .name("supatype")
     .description("Supatype — schema-first Postgres API")
-    .version(ENGINE_VERSION)
+    .version("0.1.0")
 
   registerInit(program)
   registerDev(program)
+  registerCache(program)
+  registerSelfUpdate(program)
+  registerUpdate(program)
+  registerPg(program)
   registerPush(program)
   registerDiff(program)
   registerPull(program)
@@ -48,11 +56,8 @@ export function run(): void {
   registerAdmin(program)
   registerFunctions(program)
   registerPlugins(program)
-
-  // After command execution, show update notification (non-blocking)
-  program.hook("postAction", async () => {
-    await showUpdateNotification()
-  })
+  registerTypes(program)
+  registerMigrateFromV1(program)
 
   program.parse()
 }

package/src/commands/admin.ts

@@ -8,6 +8,7 @@ import { createInterface } from "node:readline"
 import { randomBytes, scrypt } from "node:crypto"
 import { promisify } from "node:util"
 import { loadConfig } from "../config.js"
+import { connectionString } from "../project-config.js"
 import { signJwt } from "../jwt.js"
 
 const scryptAsync = promisify(scrypt)
@@ -33,7 +34,7 @@ export function registerAdmin(program: Command): void {
       }) => {
         const cwd = process.cwd()
         const config = loadConfig(cwd)
-        const connection = opts.connection ?? config.connection
+        const connection = opts.connection ?? connectionString(config)
 
         const email = opts.email ?? (await prompt("Admin email: "))
         if (!email || !email.includes("@")) {
@@ -146,7 +147,7 @@ export function registerAdmin(program: Command): void {
       async (opts: { email: string; role: string; connection?: string }) => {
         const cwd = process.cwd()
         const config = loadConfig(cwd)
-        const connection = opts.connection ?? config.connection
+        const connection = opts.connection ?? connectionString(config)
 
         const pg = await importPg()
         const pool = new pg.Pool({ connectionString: connection, max: 2 })
@@ -194,7 +195,7 @@ export function registerAdmin(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)
 
       const pg = await importPg()
       const pool = new pg.Pool({ connectionString: connection, max: 2 })

package/src/commands/app.ts

@@ -1,25 +1,45 @@
 import type { Command } from "commander"
-import { readFileSync, writeFileSync, existsSync } from "node:fs"
+import { existsSync, mkdirSync } from "node:fs"
 import { resolve } from "node:path"
-import { APP_COMPOSE_MARKER, KONG_APP_MARKER } from "./init.js"
+import { localKongBaseUrl } from "../local-gateway.js"
+import { updateAppConfigInProject } from "../app-config.js"
 
 export function registerApp(program: Command): void {
   const appCmd = program
     .command("app")
-    .description("Manage your application container in the Supatype stack")
+    .description("Manage application routing intent in supatype.config.ts")
 
   appCmd
-    .command("add")
-    .description("Add your application to the docker-compose stack at /")
-    .option("--dockerfile <path>", "Path to your Dockerfile", "./Dockerfile")
-    .option("--port <port>", "Port your app listens on", "3000")
-    .action((opts: { dockerfile: string; port: string }) => {
-      addApp(process.cwd(), opts.dockerfile, opts.port)
-    })
+    .command("add [dir]")
+    .description("Configure app routing: --static for a built site, or proxy to a dev server")
+    .option("--static", "Serve a static directory at / (default: ./public, or [dir] argument)")
+    .option("--port <port>", "Port your app listens on (proxy mode)", "3000")
+    .option("--upstream <url>", "Explicit upstream URL (proxy mode; defaults to localhost:<port>)")
+    .option("--dockerfile <path>", "(deprecated) ignored — use supatype.config.ts")
+    .action(
+      (
+        dir: string | undefined,
+        opts: {
+          static?: boolean
+          port: string
+          upstream?: string
+          dockerfile?: string
+        },
+      ) => {
+        if (opts.static) {
+          addStaticApp(process.cwd(), resolveStaticDir(dir))
+          return
+        }
+        if (opts.dockerfile) {
+          console.warn("[supatype] --dockerfile is deprecated and ignored.")
+        }
+        addProxyApp(process.cwd(), opts.port, opts.upstream)
+      },
+    )
 
   appCmd
     .command("remove")
-    .description("Remove your application from the docker-compose stack")
+    .description("Set app.mode=none in supatype.config.ts")
     .action(() => {
       removeApp(process.cwd())
     })
@@ -27,235 +47,51 @@ export function registerApp(program: Command): void {
 
 // ─── Implementation ───────────────────────────────────────────────────────────
 
-function addApp(cwd: string, dockerfile: string, port: string): void {
-  const composePath = resolve(cwd, "docker-compose.yml")
-  if (!existsSync(composePath)) {
-    console.error("docker-compose.yml not found. Run: supatype init")
-    process.exit(1)
-  }
-
-  let compose = readFileSync(composePath, "utf8")
-  if (!compose.includes(APP_COMPOSE_MARKER)) {
-    console.error("App service slot not found in docker-compose.yml. Is this a supatype project?")
-    process.exit(1)
-  }
-
-  if (isAppActive(compose)) {
-    console.error("App service is already configured. Run: supatype app remove first.")
-    process.exit(1)
-  }
-
-  compose = uncommentServiceBlock(compose, APP_COMPOSE_MARKER, { dockerfile, port })
-  writeFileSync(composePath, compose, "utf8")
-  console.log("  updated  docker-compose.yml")
-
-  const kongPath = resolve(cwd, ".supatype/kong.yml")
-  if (existsSync(kongPath)) {
-    let kong = readFileSync(kongPath, "utf8")
-    if (kong.includes(KONG_APP_MARKER)) {
-      kong = uncommentKongBlock(kong, KONG_APP_MARKER, port)
-      writeFileSync(kongPath, kong, "utf8")
-      console.log("  updated  .supatype/kong.yml")
-    }
-  }
-
-  console.log(`\nApp service added (port ${port}). Your app will be available at http://localhost:8000/\n`)
-  console.log("Run: supatype dev")
+function resolveStaticDir(dir?: string): string {
+  const trimmed = dir?.trim()
+  return trimmed && trimmed.length > 0 ? trimmed : "./public"
 }
 
-function removeApp(cwd: string): void {
-  const composePath = resolve(cwd, "docker-compose.yml")
-  if (!existsSync(composePath)) {
-    console.error("docker-compose.yml not found.")
-    process.exit(1)
+function addStaticApp(cwd: string, staticDir: string): void {
+  const abs = resolve(cwd, staticDir)
+  if (!existsSync(abs)) {
+    mkdirSync(abs, { recursive: true })
+    console.log(`  created  ${staticDir}/`)
   }
-
-  let compose = readFileSync(composePath, "utf8")
-  if (!isAppActive(compose)) {
-    console.error("No active app service found.")
+  try {
+    const configPath = updateAppConfigInProject(cwd, { mode: "static", staticDir })
+    console.log(`  updated  ${configPath}`)
+    console.log(`\nStatic app directory: ${staticDir}`)
+    console.log(`Build your frontend into ${staticDir}/, then:`)
+    console.log(`  supatype self-host compose render`)
+    console.log(`  supatype self-host compose up -d`)
+    console.log(`\nYour app will be served at ${localKongBaseUrl()}/\n`)
+  } catch (err) {
+    console.error((err as Error).message)
     process.exit(1)
   }
-
-  compose = recommentServiceBlock(compose, APP_COMPOSE_MARKER)
-  writeFileSync(composePath, compose, "utf8")
-  console.log("  updated  docker-compose.yml")
-
-  const kongPath = resolve(cwd, ".supatype/kong.yml")
-  if (existsSync(kongPath)) {
-    let kong = readFileSync(kongPath, "utf8")
-    if (!kong.includes(KONG_APP_MARKER)) {
-      // Active route — re-comment it
-      kong = recommentKongBlock(kong)
-    }
-    writeFileSync(kongPath, kong, "utf8")
-    console.log("  updated  .supatype/kong.yml")
-  }
-
-  console.log("\nApp service removed.\n")
-}
-
-// ─── Block manipulation helpers ───────────────────────────────────────────────
-
-/** Returns true if the docker-compose has an active (uncommented) app: service. */
-function isAppActive(compose: string): boolean {
-  return /^  app:/m.test(compose)
-}
-
-/**
- * Finds the commented app service block after the marker line and uncomments it,
- * substituting the dockerfile path and port.
- */
-function uncommentServiceBlock(
-  compose: string,
-  marker: string,
-  opts: { dockerfile: string; port: string },
-): string {
-  const lines = compose.split("\n")
-  const markerIdx = lines.findIndex((l) => l === marker)
-  if (markerIdx === -1) return compose
-
-  const result: string[] = []
-  let i = 0
-
-  while (i < lines.length) {
-    if (i === markerIdx) {
-      // Skip the marker line itself, then uncomment the block
-      i++
-      while (i < lines.length) {
-        const line = lines[i]!
-        // End of block: empty line followed by a non-commented service-level line
-        if (line === "" && i + 1 < lines.length && !/^  #/.test(lines[i + 1]!)) {
-          result.push(line)
-          i++
-          break
-        }
-        if (/^  # /.test(line)) {
-          // Uncomment: replace "  # " prefix with "  "
-          let uncommented = line.replace(/^  # /, "  ")
-          // Substitute placeholders
-          uncommented = uncommented.replace("./Dockerfile", opts.dockerfile)
-          uncommented = uncommented.replace(/- "3000:3000"/, `- "${opts.port}:${opts.port}"`)
-          result.push(uncommented)
-        } else if (line === "" || /^  #─/.test(line)) {
-          // Skip remaining marker-style comment lines
-        } else {
-          result.push(line)
-        }
-        i++
-      }
-    } else {
-      result.push(lines[i]!)
-      i++
-    }
-  }
-
-  return result.join("\n")
-}
-
-/**
- * Finds the active app: service block and re-comments it, restoring the marker.
- */
-function recommentServiceBlock(compose: string, marker: string): string {
-  const lines = compose.split("\n")
-  const appIdx = lines.findIndex((l) => l === "  app:")
-  if (appIdx === -1) return compose
-
-  const result: string[] = []
-  let i = 0
-
-  while (i < lines.length) {
-    if (i === appIdx) {
-      result.push(marker)
-      // Re-comment lines until we hit an empty line or the volumes: section
-      while (i < lines.length) {
-        const line = lines[i]!
-        if (line === "" || /^volumes:/.test(line) || /^  \w/.test(line)) {
-          result.push(line)
-          i++
-          break
-        }
-        // Re-comment: "  X..." → "  # X..."
-        result.push(line.replace(/^  /, "  # "))
-        i++
-      }
-    } else {
-      result.push(lines[i]!)
-      i++
-    }
-  }
-
-  return result.join("\n")
 }
 
-/**
- * Uncomments the Kong app route block after the marker.
- */
-function uncommentKongBlock(kong: string, marker: string, port: string): string {
-  const lines = kong.split("\n")
-  const markerIdx = lines.findIndex((l) => l === marker)
-  if (markerIdx === -1) return kong
-
-  const result: string[] = []
-  let i = 0
-
-  while (i < lines.length) {
-    if (i === markerIdx) {
-      i++ // skip marker
-      while (i < lines.length) {
-        const line = lines[i]!
-        if (line === "" && (i + 1 >= lines.length || !/^  #/.test(lines[i + 1]!))) {
-          result.push(line)
-          i++
-          break
-        }
-        if (/^  # /.test(line)) {
-          let uncommented = line.replace(/^  # /, "  ")
-          uncommented = uncommented.replace(":3000", `:${port}`)
-          result.push(uncommented)
-        } else {
-          result.push(line)
-        }
-        i++
-      }
-    } else {
-      result.push(lines[i]!)
-      i++
-    }
+function addProxyApp(cwd: string, port: string, upstream?: string): void {
+  const upstreamUrl = upstream?.trim() || `http://localhost:${port}`
+  try {
+    const configPath = updateAppConfigInProject(cwd, { mode: "proxy", upstream: upstreamUrl })
+    console.log(`  updated  ${configPath}`)
+    console.log(`\nApp upstream set to ${upstreamUrl}. The app will be available at ${localKongBaseUrl()}/\n`)
+    console.log("Run: supatype self-host compose render")
+  } catch (err) {
+    console.error((err as Error).message)
+    process.exit(1)
   }
-
-  return result.join("\n")
 }
 
-/**
- * Finds the active Kong app route and re-comments it, restoring the marker.
- */
-function recommentKongBlock(kong: string): string {
-  const lines = kong.split("\n")
-  // Find "  - name: app" (the active route)
-  const appIdx = lines.findIndex((l) => /^  - name: app$/.test(l))
-  if (appIdx === -1) return kong
-
-  const result: string[] = []
-  let i = 0
-
-  while (i < lines.length) {
-    if (i === appIdx) {
-      result.push(KONG_APP_MARKER)
-      while (i < lines.length) {
-        const line = lines[i]!
-        if (line === "" || (i > appIdx && /^  - /.test(line))) {
-          result.push(line)
-          i++
-          break
-        }
-        result.push(line.replace(/^  /, "  # "))
-        i++
-      }
-    } else {
-      result.push(lines[i]!)
-      i++
-    }
+function removeApp(cwd: string): void {
+  try {
+    const configPath = updateAppConfigInProject(cwd, { mode: "none" })
+    console.log(`  updated  ${configPath}`)
+    console.log("\nApp routing disabled (app.mode=none).\n")
+  } catch (err) {
+    console.error((err as Error).message)
+    process.exit(1)
   }
-
-  return result.join("\n")
 }

package/src/commands/cache.ts

@@ -0,0 +1,117 @@
+/**
+ * supatype cache — list and clean cached component binaries.
+ */
+
+import type { Command } from "commander"
+import { existsSync, readdirSync, rmSync, statSync } from "node:fs"
+import { join } from "node:path"
+import { cacheRoot, type Component } from "../binary-cache.js"
+
+const COMPONENTS: Component[] = ["engine", "server", "postgres", "deno"]
+
+export function registerCache(program: Command): void {
+  const cache = program
+    .command("cache")
+    .description("Manage cached component binaries")
+
+  cache
+    .command("list")
+    .description("List cached component binaries and their sizes")
+    .action(() => {
+      const root = cacheRoot()
+      if (!existsSync(root)) {
+        console.log("Cache is empty.")
+        return
+      }
+
+      let totalBytes = 0
+      let found = false
+
+      for (const component of COMPONENTS) {
+        const compDir = join(root, component)
+        if (!existsSync(compDir)) continue
+
+        const versions = readdirSync(compDir).filter(
+          (v) => statSync(join(compDir, v)).isDirectory(),
+        )
+        for (const version of versions) {
+          const vDir = join(compDir, version)
+          const size = dirSize(vDir)
+          totalBytes += size
+          found = true
+          console.log(`  ${component}@${version}  ${formatBytes(size)}`)
+        }
+      }
+
+      if (!found) {
+        console.log("Cache is empty.")
+        return
+      }
+
+      console.log(`\nTotal: ${formatBytes(totalBytes)}`)
+      console.log(`Cache root: ${root}`)
+    })
+
+  cache
+    .command("clean [component] [version]")
+    .description(
+      "Remove cached binaries. Optionally specify a component and/or version.\n" +
+        "Examples:\n" +
+        "  supatype cache clean           # remove everything\n" +
+        "  supatype cache clean engine    # remove all engine versions\n" +
+        "  supatype cache clean engine 0.4.2",
+    )
+    .action((component?: string, version?: string) => {
+      const root = cacheRoot()
+      if (!existsSync(root)) {
+        console.log("Cache is already empty.")
+        return
+      }
+
+      const targets = component ? [component as Component] : COMPONENTS
+
+      for (const comp of targets) {
+        const compDir = join(root, comp)
+        if (!existsSync(compDir)) continue
+
+        if (version) {
+          const vDir = join(compDir, version)
+          if (!existsSync(vDir)) {
+            console.log(`  ${comp}@${version} not cached.`)
+            continue
+          }
+          rmSync(vDir, { recursive: true, force: true })
+          console.log(`  removed  ${comp}@${version}`)
+        } else {
+          rmSync(compDir, { recursive: true, force: true })
+          console.log(`  removed  ${comp} (all versions)`)
+        }
+      }
+
+      console.log("Done.")
+    })
+}
+
+function dirSize(dir: string): number {
+  let total = 0
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        total += dirSize(full)
+      } else {
+        total += statSync(full).size
+      }
+    }
+  } catch {
+    // Skip unreadable entries.
+  }
+  return total
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`
+}

package/src/commands/cloud.ts

@@ -9,7 +9,7 @@ interface CloudConfig {
   projectSlug?: string
 }
 
-function loadCloudConfig(cwd: string): CloudConfig | null {
+export function loadCloudConfig(cwd: string): CloudConfig | null {
   const configPath = resolve(cwd, ".supatype/cloud.json")
   if (!existsSync(configPath)) return null
   return JSON.parse(readFileSync(configPath, "utf8")) as CloudConfig
@@ -41,6 +41,49 @@ async function cloudFetch<T>(config: CloudConfig, method: string, path: string,
   return json.data as T
 }
 
+/**
+ * Push schema AST to the linked cloud project (control plane `/api/v1/.../deploy`).
+ * Invoked by `supatype deploy` by default when `.supatype/cloud.json` is present.
+ */
+export async function deploySchemaToLinkedProject(
+  cwd: string,
+  environment: string,
+): Promise<void> {
+  const config = loadCloudConfig(cwd)
+  if (!config?.projectSlug) {
+    console.error("Not linked to a cloud project. Run: supatype link")
+    process.exit(1)
+  }
+
+  console.log(`Deploying schema to ${config.projectSlug} (${environment})...`)
+
+  const { loadConfig: loadAppConfig, loadSchemaAst } = await import("../config.js")
+  const { schemaPathFromProject } = await import("../project-config.js")
+
+  const appConfig = loadAppConfig(cwd)
+  const ast = loadSchemaAst(schemaPathFromProject(appConfig, cwd), cwd)
+
+  const { createHash } = await import("node:crypto")
+  const schemaHash = createHash("sha256").update(JSON.stringify(ast)).digest("hex").slice(0, 16)
+
+  const deployment = await cloudFetch<{
+    id: string; status: string; errorMessage?: string
+  }>(config, "POST", `/projects/${config.projectSlug}/deploy`, {
+    environment,
+    schemaHash,
+    ast,
+  })
+
+  if (deployment.status === "success") {
+    console.log(`\nDeployment successful (${deployment.id})`)
+  } else if (deployment.status === "failed") {
+    console.error(`\nDeployment failed: ${deployment.errorMessage}`)
+    process.exit(1)
+  } else {
+    console.log(`\nDeployment ${deployment.status} (${deployment.id})`)
+  }
+}
+
 function prompt(question: string): Promise<string> {
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   return new Promise((resolve) => {
@@ -59,7 +102,7 @@ export function registerCloud(program: Command): void {
     .command("link")
     .description("Link this local project to a Supatype cloud project")
     .option("--project <slug>", "Project slug to link to")
-    .option("--api-url <url>", "Control plane API URL", "https://api.supatype.io")
+    .option("--api-url <url>", "Control plane API URL", "https://api.supatype.com")
     .option("--token <token>", "Authentication token")
     .action(async (opts: { project?: string; apiUrl: string; token?: string }) => {
       const cwd = process.cwd()
@@ -102,60 +145,6 @@ export function registerCloud(program: Command): void {
       console.log(`Config saved to .supatype/cloud.json\n`)
     })
 
-  // ── Deploy ─────────────────────────────────────────────────────────────────
-  program
-    .command("deploy")
-    .description("Deploy schema to the linked cloud project")
-    .option("--environment <name>", "Target environment", "production")
-    .action(async (opts: { environment: string }) => {
-      const cwd = process.cwd()
-      const config = loadCloudConfig(cwd)
-      if (!config?.projectSlug) {
-        console.error("Not linked to a cloud project. Run: supatype link")
-        process.exit(1)
-      }
-
-      console.log(`Deploying to ${config.projectSlug} (${opts.environment})...`)
-
-      // Load schema AST
-      const { loadConfig: loadAppConfig, loadSchemaAst } = await import("../config.js")
-      const { ensureEngine, invokeEngine } = await import("../engine.js")
-
-      const appConfig = loadAppConfig(cwd)
-      const ast = loadSchemaAst(appConfig.schema, cwd)
-
-      // Generate migration SQL locally using the engine
-      await ensureEngine()
-      const migrateResult = invokeEngine(
-        ["migrate", "--format", "sql"],
-        JSON.stringify(ast),
-      )
-      if (migrateResult.exitCode !== 0) {
-        console.error("Failed to generate migration:", migrateResult.stderr || migrateResult.stdout)
-        process.exit(1)
-      }
-
-      const { createHash } = await import("node:crypto")
-      const schemaHash = createHash("sha256").update(JSON.stringify(ast)).digest("hex").slice(0, 16)
-
-      const deployment = await cloudFetch<{
-        id: string; status: string; errorMessage?: string
-      }>(config, "POST", `/projects/${config.projectSlug}/deploy`, {
-        environment: opts.environment,
-        schemaHash,
-        migrationSql: migrateResult.stdout,
-      })
-
-      if (deployment.status === "success") {
-        console.log(`\nDeployment successful (${deployment.id})`)
-      } else if (deployment.status === "failed") {
-        console.error(`\nDeployment failed: ${deployment.errorMessage}`)
-        process.exit(1)
-      } else {
-        console.log(`\nDeployment ${deployment.status} (${deployment.id})`)
-      }
-    })
-
   // ── Projects ───────────────────────────────────────────────────────────────
   const projectsCmd = program
     .command("projects")
@@ -315,7 +304,7 @@ function getCloudConfigOrExit(): CloudConfig {
   let config = loadCloudConfig(cwd)
   if (!config) {
     const token = process.env["SUPATYPE_TOKEN"]
-    const apiUrl = process.env["SUPATYPE_API_URL"] ?? "https://api.supatype.io"
+    const apiUrl = process.env["SUPATYPE_API_URL"] ?? "https://api.supatype.com"
     if (!token) {
       console.error("Not connected to Supatype Cloud. Run: supatype link, or set SUPATYPE_TOKEN.")
       process.exit(1)