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

package/src/commands/cloud.ts

@@ -7,9 +7,11 @@ interface CloudConfig {
   apiUrl: string
   token: string
   projectSlug?: string
+  /** Organisation UUID — required for schema routes (`X-Org-Id`). */
+  orgId?: 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
@@ -25,12 +27,16 @@ function saveCloudConfig(cwd: string, config: CloudConfig): void {
 }
 
 async function cloudFetch<T>(config: CloudConfig, method: string, path: string, body?: unknown): Promise<T> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.token}`,
+  }
+  if (config.orgId) {
+    headers["X-Org-Id"] = config.orgId
+  }
   const res = await fetch(`${config.apiUrl}/api/v1${path}`, {
     method,
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${config.token}`,
-    },
+    headers,
     ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
   })
 
@@ -41,6 +47,50 @@ async function cloudFetch<T>(config: CloudConfig, method: string, path: string,
   return json.data as T
 }
 
+/** True when `.supatype/cloud.json` exists with a linked project slug. */
+export function isCloudLinked(cwd: string): boolean {
+  const cfg = loadCloudConfig(cwd)
+  return Boolean(cfg?.projectSlug && cfg.token)
+}
+
+/**
+ * Push schema AST to the linked cloud project (`POST /api/v1/projects/:ref/schema/push`).
+ * Credentials stay server-side; only AST is sent.
+ */
+export async function pushSchemaToLinkedProject(cwd: string, opts?: { force?: boolean }): Promise<void> {
+  const config = loadCloudConfig(cwd)
+  if (!config?.projectSlug) {
+    console.error("Not linked to a cloud project. Run: supatype link")
+    process.exit(1)
+  }
+  if (!config.orgId) {
+    console.error(
+      "Missing orgId in .supatype/cloud.json. Re-run: supatype link --project <slug> (after cloud login).",
+    )
+    process.exit(1)
+  }
+
+  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)
+
+  console.log(`Pushing schema to cloud project ${config.projectSlug}...`)
+
+  const result = await cloudFetch<{ message?: string }>(config, "POST", `/projects/${config.projectSlug}/schema/push`, {
+    ast,
+    force: opts?.force ?? true,
+  })
+
+  console.log(result.message ?? "Schema push completed.")
+}
+
+/** @deprecated Use pushSchemaToLinkedProject — kept for deploy command alias */
+export async function deploySchemaToLinkedProject(cwd: string, _environment: string): Promise<void> {
+  await pushSchemaToLinkedProject(cwd)
+}
+
 function prompt(question: string): Promise<string> {
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   return new Promise((resolve) => {
@@ -59,7 +109,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()
@@ -73,9 +123,10 @@ export function registerCloud(program: Command): void {
 
       if (opts.project) {
         config.projectSlug = opts.project
+        const one = await cloudFetch<{ slug: string; orgId: string }>(config, "GET", `/projects/${opts.project}`)
+        config.orgId = one.orgId
       } else {
-        // List projects and let user choose
-        const projects = await cloudFetch<Array<{ slug: string; name: string; status: string; tier: string }>>(
+        const projects = await cloudFetch<Array<{ slug: string; name: string; status: string; tier: string; orgId: string }>>(
           config, "GET", "/projects",
         )
         if (projects.length === 0) {
@@ -94,7 +145,9 @@ export function registerCloud(program: Command): void {
           console.error("Invalid selection.")
           process.exit(1)
         }
-        config.projectSlug = projects[idx]!.slug
+        const picked = projects[idx]!
+        config.projectSlug = picked.slug
+        config.orgId = picked.orgId
       }
 
       saveCloudConfig(cwd, config)
@@ -102,60 +155,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 +314,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)

package/src/commands/db.ts

@@ -6,6 +6,8 @@
 
 import type { Command } from "commander"
 import { loadConfig } from "../config.js"
+import { connectionString } from "../project-config.js"
+import { loadCloudConfig } from "./cloud.js"
 
 export function registerDb(program: Command): void {
   const db = program
@@ -21,16 +23,13 @@ export function registerDb(program: Command): void {
     .action(async (opts: { transaction?: boolean; env?: string }) => {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
+      const cloudCfg = loadCloudConfig(cwd)
+      const localConn = connectionString(config)
 
-      // The connection string is stored in the project config or fetched from cloud
-      if (config.connection) {
-        if (opts.transaction) {
-          // Convert session URL to transaction pool URL (port 6432)
-          const txUrl = config.connection.replace(/:5432\//, ":6432/")
-          console.log(txUrl)
-        } else {
-          console.log(config.connection)
-        }
+      // If no cloud project linked, show the local connection string.
+      if (!cloudCfg?.projectSlug) {
+        const connStr = opts.transaction ? localConn.replace(/:5432\//, ":6432/") : localConn
+        console.log(connStr)
         console.log()
         console.log("Session mode (port 5432): for interactive tools (psql, DataGrip, TablePlus)")
         console.log("Transaction mode (port 6432): for application servers and serverless functions")
@@ -38,58 +37,49 @@ export function registerDb(program: Command): void {
       }
 
       // If linked to a cloud project, fetch from the API
-      if (config.projectRef) {
-        const apiUrl = config.apiUrl || "https://api.supatype.io"
-        const envName = opts.env || "production"
-
-        try {
-          const res = await fetch(
-            `${apiUrl}/platform/v1/projects/${config.projectRef}/environments`,
-            {
-              headers: {
-                Authorization: `Bearer ${config.accessToken || process.env["SUPATYPE_ACCESS_TOKEN"] || ""}`,
-              },
+      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
+      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
+      const envName = opts.env || "production"
+
+      try {
+        const res = await fetch(
+          `${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/environments`,
+          {
+            headers: {
+              Authorization: `Bearer ${token}`,
             },
-          )
-
-          if (!res.ok) {
-            console.error(`Failed to fetch project info: ${res.status}`)
-            process.exitCode = 1
-            return
-          }
-
-          const { data } = (await res.json()) as { data: Array<{ name: string; databaseUrl?: string }> }
-          const env = data.find((e) => e.name === envName)
-
-          if (!env) {
-            console.error(`Environment "${envName}" not found`)
-            process.exitCode = 1
-            return
-          }
-
-          const connStr = env.databaseUrl || "Connection string not available"
-          if (opts.transaction) {
-            console.log(connStr.replace(/:5432\//, ":6432/"))
-          } else {
-            console.log(connStr)
-          }
-
-          console.log()
-          console.log("Session mode (port 5432): for interactive tools (psql, DataGrip, TablePlus)")
-          console.log("Transaction mode (port 6432): for application servers and serverless functions")
-        } catch (err) {
-          console.error("Failed to fetch connection string:", (err as Error).message)
+          },
+        )
+
+        if (!res.ok) {
+          console.error(`Failed to fetch project info: ${res.status}`)
           process.exitCode = 1
+          return
         }
-        return
-      }
 
-      console.error(
-        "No connection configured. Either:\n" +
-        "  • Set 'connection' in supatype.config.ts\n" +
-        "  • Link to a cloud project: npx supatype link --project <ref>",
-      )
-      process.exitCode = 1
+        const { data } = (await res.json()) as { data: Array<{ name: string; databaseUrl?: string }> }
+        const env = data.find((e) => e.name === envName)
+
+        if (!env) {
+          console.error(`Environment "${envName}" not found`)
+          process.exitCode = 1
+          return
+        }
+
+        const connStr = env.databaseUrl || "Connection string not available"
+        if (opts.transaction) {
+          console.log(connStr.replace(/:5432\//, ":6432/"))
+        } else {
+          console.log(connStr)
+        }
+
+        console.log()
+        console.log("Session mode (port 5432): for interactive tools (psql, DataGrip, TablePlus)")
+        console.log("Transaction mode (port 6432): for application servers and serverless functions")
+      } catch (err) {
+        console.error("Failed to fetch connection string:", (err as Error).message)
+        process.exitCode = 1
+      }
     })
 
   // supatype db reset-password
@@ -99,24 +89,25 @@ export function registerDb(program: Command): void {
     .option("--env <name>", "Environment name", "production")
     .action(async (opts: { env?: string }) => {
       const cwd = process.cwd()
-      const config = loadConfig(cwd)
+      const cloudCfg = loadCloudConfig(cwd)
 
-      if (!config.projectRef) {
-        console.error("Not linked to a cloud project. Run: npx supatype link --project <ref>")
+      if (!cloudCfg?.projectSlug) {
+        console.error("Not linked to a cloud project. Run: supatype link --project <ref>")
         process.exitCode = 1
         return
       }
 
-      const apiUrl = config.apiUrl || "https://api.supatype.io"
+      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
+      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
       const envName = opts.env || "production"
 
       try {
         const res = await fetch(
-          `${apiUrl}/platform/v1/projects/${config.projectRef}/environments/${envName}/reset-db-password`,
+          `${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/environments/${envName}/reset-db-password`,
           {
             method: "POST",
             headers: {
-              Authorization: `Bearer ${config.accessToken || process.env["SUPATYPE_ACCESS_TOKEN"] || ""}`,
+              Authorization: `Bearer ${token}`,
               "Content-Type": "application/json",
             },
           },

package/src/commands/deploy.ts

@@ -1,6 +1,7 @@
 /**
  * Deploy commands:
- *   supatype deploy              — push schema + build & deploy static site
+ *   supatype deploy              — Supatype Cloud by default (linked via supatype link), else platform projectRef; use --local for engine + DB
+ *   supatype deploy --local      — push schema via local engine + optional static app to .supatype/static
  *   supatype deploy --app-only   — only build & deploy the static site
  *   supatype deploy --schema-only — only push schema changes
  *   supatype deploy --skip-build — deploy existing build output (no build step)
@@ -14,7 +15,9 @@ import type { Command } from "commander"
 import { existsSync, readdirSync, statSync, createReadStream } from "node:fs"
 import { join } from "node:path"
 import { loadConfig, loadSchemaAst } from "../config.js"
-import { ensureEngine, invokeEngine } from "../engine.js"
+import { connectionString, schemaPathFromProject } from "../project-config.js"
+import { deploySchemaToLinkedProject, loadCloudConfig, pushSchemaToLinkedProject } from "./cloud.js"
+import { ensureEngine, engineRequest, type DiffResult } from "../engine-client.js"
 import { resolveAppConfig, validateStaticMode, validateBuildOutput, detectPackageManager } from "../app/framework.js"
 import { TIER_LIMITS, type Tier } from "./deploy-types.js"
 import { spawnSync } from "node:child_process"
@@ -22,13 +25,19 @@ import { spawnSync } from "node:child_process"
 export function registerDeploy(program: Command): void {
   const deploy = program
     .command("deploy")
-    .description("Build and deploy your application")
+    .description(
+      "Deploy schema and app — Supatype Cloud by default when linked (`supatype link`); pass --local for engine + your database",
+    )
+    .option("--local", "Use local schema engine and database_url from config (skip cloud control plane)")
+    .option("--environment <name>", "Cloud environment when using linked project", "production")
     .option("--app-only", "Skip schema push, only deploy the static site")
     .option("--schema-only", "Skip app build, only push schema changes")
     .option("--skip-build", "Deploy existing build output without building")
     .option("--preview", "Deploy to a temporary preview URL")
     .option("--yes", "Skip confirmation prompts")
     .action(async (opts: {
+      local?: boolean
+      environment?: string
       appOnly?: boolean
       schemaOnly?: boolean
       skipBuild?: boolean
@@ -37,54 +46,77 @@ export function registerDeploy(program: Command): void {
     }) => {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
-
-      // Step 1: Schema push (unless --app-only or --skip-build)
-      if (!opts.appOnly && !opts.skipBuild) {
-        console.log("=== Schema Push ===")
-        await ensureEngine()
-
-        const ast = loadSchemaAst(config.schema, cwd)
-        const diffResult = invokeEngine(
-          ["diff", "--connection", config.connection, "--format", "json"],
-          JSON.stringify(ast),
-        )
-        if (diffResult.exitCode !== 0) {
-          console.error("Schema diff failed:", diffResult.stderr || diffResult.stdout)
-          process.exit(1)
+      const cloudCfg = loadCloudConfig(cwd)
+
+      let schemaDone = false
+
+      // Default: cloud — .supatype/cloud.json → control plane schema deploy
+      if (
+        !opts.local &&
+        cloudCfg?.projectSlug &&
+        !opts.appOnly &&
+        !opts.skipBuild
+      ) {
+        await deploySchemaToLinkedProject(cwd, opts.environment ?? "production")
+        schemaDone = true
+        if (opts.schemaOnly) {
+          return
         }
+      }
 
-        const diff = JSON.parse(diffResult.stdout)
-        const ops = diff.operations ?? []
+      // Step 1: Schema push (unless --app-only or --skip-build, or already done via cloud.json)
+      if (!opts.appOnly && !opts.skipBuild && !schemaDone) {
+        const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
 
-        if (ops.length > 0) {
-          console.log(`${ops.length} schema change(s) to apply.`)
-          const migrateResult = invokeEngine(
-            ["migrate", "--connection", config.connection],
-            JSON.stringify(ast),
-          )
-          if (migrateResult.exitCode !== 0) {
-            console.error("Migration failed:", migrateResult.stderr)
-            process.exit(1)
+        if (opts.local) {
+          console.log("=== Schema Push (local) ===")
+          await ensureEngine()
+
+          const diff = await engineRequest<DiffResult>("/diff", {
+            ast,
+            database_url: connectionString(config),
+            schema: "public",
+          })
+
+          const ops = diff.operations ?? []
+
+          if (ops.length > 0) {
+            console.log(`${ops.length} schema change(s) to apply.`)
+            await engineRequest("/push", {
+              ast,
+              database_url: connectionString(config),
+              schema: "public",
+              force: true,
+            })
+            console.log("Schema changes applied.")
+          } else {
+            console.log("Schema is up to date.")
           }
-          console.log("Schema changes applied.")
+        } else if (cloudCfg?.projectSlug) {
+          console.log("=== Schema Push (cloud) ===")
+          await pushSchemaToLinkedProject(cwd, { force: opts.yes ?? true })
         } else {
-          console.log("Schema is up to date.")
+          console.error(
+            "Not linked to Supatype Cloud. Run: supatype link\n" +
+              "Or deploy against your own database: supatype deploy --local",
+          )
+          process.exit(1)
         }
       }
 
       // Step 2: App build & deploy (unless --schema-only)
       if (!opts.schemaOnly) {
-        if (!config.app) {
+        if (!config.build) {
           if (opts.appOnly) {
-            console.error("No app configuration found in supatype.config.ts")
+            console.error("No build section found in supatype.config.ts")
             process.exit(1)
           }
-          // No app config — just skip app deployment silently
+          // No build config — skip app deployment silently
           return
         }
 
         console.log("\n=== App Build & Deploy ===")
-        const appConfig = resolveAppConfig(config.app, cwd)
+        const appConfig = resolveAppConfig(config.build, cwd)
 
         // Validate static mode
         const staticError = validateStaticMode(appConfig.framework, appConfig.directory)
@@ -107,10 +139,10 @@ export function registerDeploy(program: Command): void {
           }
 
           // Inject Supatype URLs if project is linked
-          if (config.projectRef) {
-            buildEnv["NEXT_PUBLIC_SUPATYPE_URL"] = config.apiUrl || `https://${config.projectRef}.supatype.io`
-            buildEnv["VITE_SUPATYPE_URL"] = buildEnv["NEXT_PUBLIC_SUPATYPE_URL"]
-            buildEnv["PUBLIC_SUPATYPE_URL"] = buildEnv["NEXT_PUBLIC_SUPATYPE_URL"]
+          if (cloudCfg?.projectSlug) {
+            buildEnv["NEXT_PUBLIC_SUPATYPE_URL"] = cloudCfg.apiUrl || `https://${cloudCfg.projectSlug}.supatype.dev`
+            buildEnv["VITE_SUPATYPE_URL"] = buildEnv["NEXT_PUBLIC_SUPATYPE_URL"]!
+            buildEnv["PUBLIC_SUPATYPE_URL"] = buildEnv["NEXT_PUBLIC_SUPATYPE_URL"]!
             // NEVER inject service_role key — only anon key is safe for client-side
           }
 
@@ -151,20 +183,22 @@ export function registerDeploy(program: Command): void {
           process.exit(1)
         }
 
-        // Deploy
-        if (config.projectRef) {
-          // Cloud deployment — upload to API
-          await deployToCloud(config, appConfig.outputDirectory, opts.preview ?? false)
+        // Deploy (--local never uploads to cloud, even if linked)
+        if (cloudCfg?.projectSlug && !opts.local) {
+          await deployToCloud(
+            { projectRef: cloudCfg.projectSlug, apiUrl: cloudCfg.apiUrl, accessToken: cloudCfg.token },
+            appConfig.outputDirectory,
+            opts.preview ?? false,
+          )
         } else {
-          // Self-host — copy to serving directory
           deploySelfHost(appConfig.outputDirectory, cwd)
         }
 
         console.log("\nDeployment complete!")
-        if (config.projectRef) {
+        if (cloudCfg?.projectSlug && !opts.local) {
           const url = opts.preview
-            ? `https://preview-${Date.now().toString(36)}.${config.projectRef}.supatype.io`
-            : `https://${config.projectRef}.supatype.io`
+            ? `https://preview-${Date.now().toString(36)}.${cloudCfg.projectSlug}.supatype.dev`
+            : `https://${cloudCfg.projectSlug}.supatype.dev`
           console.log(`URL: ${url}`)
         }
       }
@@ -175,16 +209,16 @@ export function registerDeploy(program: Command): void {
     .command("rollback")
     .description("Roll back to the previous static site deployment")
     .action(async () => {
-      const config = loadConfig(process.cwd())
-      if (!config.projectRef) {
+      const cloudCfg = loadCloudConfig(process.cwd())
+      if (!cloudCfg?.projectSlug) {
         console.error("Not linked to a cloud project. Rollback is only available for cloud deployments.")
         process.exit(1)
       }
 
-      const apiUrl = config.apiUrl || "https://api.supatype.io"
-      const token = config.accessToken || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
+      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
+      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
 
-      const res = await fetch(`${apiUrl}/platform/v1/projects/${config.projectRef}/deployments/rollback`, {
+      const res = await fetch(`${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/deployments/rollback`, {
         method: "POST",
         headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
       })
@@ -204,16 +238,16 @@ export function registerDeploy(program: Command): void {
     .command("status")
     .description("Show current deployment status")
     .action(async () => {
-      const config = loadConfig(process.cwd())
-      if (!config.projectRef) {
+      const cloudCfg = loadCloudConfig(process.cwd())
+      if (!cloudCfg?.projectSlug) {
         console.error("Not linked to a cloud project.")
         process.exit(1)
       }
 
-      const apiUrl = config.apiUrl || "https://api.supatype.io"
-      const token = config.accessToken || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
+      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
+      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
 
-      const res = await fetch(`${apiUrl}/platform/v1/projects/${config.projectRef}/deployments/current`, {
+      const res = await fetch(`${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/deployments/current`, {
         headers: { Authorization: `Bearer ${token}` },
       })
 
@@ -244,17 +278,17 @@ export function registerDeploy(program: Command): void {
     .command("logs [version]")
     .description("Show build logs for a deployment")
     .action(async (version?: string) => {
-      const config = loadConfig(process.cwd())
-      if (!config.projectRef) {
+      const cloudCfg = loadCloudConfig(process.cwd())
+      if (!cloudCfg?.projectSlug) {
         console.error("Not linked to a cloud project.")
         process.exit(1)
       }
 
-      const apiUrl = config.apiUrl || "https://api.supatype.io"
-      const token = config.accessToken || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
+      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
+      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
 
       const versionPath = version ? `/${version}` : "/current"
-      const res = await fetch(`${apiUrl}/platform/v1/projects/${config.projectRef}/deployments${versionPath}/logs`, {
+      const res = await fetch(`${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/deployments${versionPath}/logs`, {
         headers: { Authorization: `Bearer ${token}` },
       })
 
@@ -273,7 +307,7 @@ async function deployToCloud(
   outputDir: string,
   isPreview: boolean,
 ): Promise<void> {
-  const apiUrl = config.apiUrl || "https://api.supatype.io"
+  const apiUrl = config.apiUrl || "https://api.supatype.com"
   const token = config.accessToken || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
 
   console.log("Uploading build artifacts...")