spine-framework 0.1.13 → 0.1.15

package/.framework/cli/commands/init.ts

@@ -5,106 +5,34 @@
  * @layer cli
  * @stability stable
  *
- * `spine-framework init` — Bootstrap a fresh Spine installation.
+ * `spine-framework init` — Write .env and scaffold the custom/ workspace.
  *
- * Runs the foundation schema (000_foundation.sql) and seed data (001_seed.sql)
- * against the configured Supabase project, then scaffolds the custom/ workspace
- * if it doesn't already exist.
+ * Intentionally does NOT touch the database — run `spine-framework migrate`
+ * after init to apply SQL migrations via a direct Postgres connection.
  *
  * **Usage:**
  * ```bash
- * # Fresh install (agent provides credentials from Supabase dashboard)
  * spine-framework init --url https://xyz.supabase.co --anon-key eyJ... --service-role-key eyJ...
- *
- * # Already have .env configured
- * spine-framework init
- *
- * # DB only, no filesystem changes
- * spine-framework init --skip-scaffold
+ * spine-framework migrate --db-password <password>
  * ```
- *
- * When --url/--anon-key/--service-role-key are provided, init writes .env before
- * running migrations — so it works on a completely fresh checkout with no prior config.
  */
 
 import type { Command } from 'commander'
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { existsSync, mkdirSync, writeFileSync } from 'fs'
 import { resolve, dirname } from 'path'
 import { fileURLToPath } from 'url'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 const PROJECT_ROOT = resolve(__dirname, '../../../')
-const MIGRATIONS_DIR = resolve(__dirname, '../../migrations')
 
 interface InitOptions {
-  skipScaffold: boolean
   dryRun: boolean
   url?: string
   anonKey?: string
   serviceRoleKey?: string
 }
 
-async function runMigration(filename: string, dryRun: boolean): Promise<boolean> {
-  const filePath = resolve(MIGRATIONS_DIR, filename)
-  if (!existsSync(filePath)) {
-    console.error(`  ❌ Migration file not found: ${filename}`)
-    return false
-  }
-
-  const sql = readFileSync(filePath, 'utf8')
-
-  if (dryRun) {
-    console.log(`  [dry-run] Would execute: ${filename} (${sql.length} chars)`)
-    return true
-  }
-
-  // Use the Supabase SQL endpoint to execute raw DDL.
-  // This works on blank projects (no exec_sql RPC needed).
-  const supabaseUrl = process.env.SUPABASE_URL
-  const serviceKey = process.env.SUPABASE_SERVICE_ROLE_KEY
-
-  if (!supabaseUrl || !serviceKey) {
-    console.error(`  ❌ Missing SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY`)
-    return false
-  }
-
-  // Use the Supabase /pg/query endpoint for raw SQL execution
-  const pgResponse = await fetch(`${supabaseUrl}/pg/query`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'apikey': serviceKey,
-      'Authorization': `Bearer ${serviceKey}`,
-    },
-    body: JSON.stringify({ query: sql })
-  })
-
-  if (pgResponse.ok) return true
-
-  // Second fallback: use the Supabase Management API SQL endpoint
-  // Extract project ref from URL (e.g. https://abcdef.supabase.co → abcdef)
-  const projectRef = supabaseUrl.replace('https://', '').split('.')[0]
-
-  const mgmtResponse = await fetch(
-    `https://api.supabase.com/v1/projects/${projectRef}/database/query`,
-    {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${serviceKey}`,
-      },
-      body: JSON.stringify({ query: sql })
-    }
-  )
-
-  if (mgmtResponse.ok) return true
-
-  const text = await mgmtResponse.text()
-  console.error(`  ❌ Migration ${filename} failed: ${text}`)
-  return false
-}
-
 function scaffoldCustomWorkspace(dryRun: boolean): void {
   const dirs = [
     'custom/apps',
@@ -128,22 +56,6 @@ function scaffoldCustomWorkspace(dryRun: boolean): void {
   }
 }
 
-async function checkAlreadyInitialized(): Promise<boolean> {
-  try {
-    const supabaseUrl = process.env.SUPABASE_URL
-    const serviceKey = process.env.SUPABASE_SERVICE_ROLE_KEY
-    if (!supabaseUrl || !serviceKey) return false
-    const res = await fetch(
-      `${supabaseUrl}/rest/v1/apps?slug=eq.spine-core&select=slug&limit=1`,
-      { headers: { apikey: serviceKey, Authorization: `Bearer ${serviceKey}` } }
-    )
-    const rows = await res.json() as any[]
-    return Array.isArray(rows) && rows.length > 0
-  } catch {
-    return false
-  }
-}
-
 function writeEnvFile(url: string, anonKey: string, serviceRoleKey: string, dryRun: boolean): void {
   const envPath = resolve(PROJECT_ROOT, '.env')
   const envContent = [
@@ -176,93 +88,36 @@ function writeEnvFile(url: string, anonKey: string, serviceRoleKey: string, dryR
 async function initCommand(options: InitOptions): Promise<void> {
   console.log('\n🚀 Spine Framework — Init\n')
 
-  // Step 0: Write .env if credentials were provided via flags
+  // Step 1: Write .env
   if (options.url && options.anonKey && options.serviceRoleKey) {
-    console.log('🔑 Step 0: Writing environment configuration...')
+    console.log('🔑 Step 1: Writing environment configuration...')
     writeEnvFile(options.url, options.anonKey, options.serviceRoleKey, options.dryRun)
-  } else if (!process.env.SUPABASE_URL || !process.env.SUPABASE_SERVICE_ROLE_KEY) {
+  } else if (!process.env.SUPABASE_URL) {
     console.error('❌ No Supabase credentials found.')
-    console.error('   Provide them via flags:')
     console.error('   spine-framework init --url <url> --anon-key <key> --service-role-key <key>')
-    console.error('   Or set SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY in .env')
     process.exit(1)
+  } else {
+    console.log('  ✓ Using existing .env credentials')
   }
 
-  // Check if already initialized
-  const alreadyInit = await checkAlreadyInitialized()
-  if (alreadyInit) {
-    console.log('  ⚠️  Database already initialized (spine-core app exists)')
-    console.log('  Skipping schema migration. Use "spine-framework migrations" to manage updates.\n')
-
-    if (!options.skipScaffold) {
-      console.log('📁 Checking workspace scaffold...')
-      scaffoldCustomWorkspace(options.dryRun)
-    }
-
-    console.log('\n✅ Init complete (already initialized)')
-    return
-  }
-
-  // Step 1: Foundation schema
-  console.log('📦 Step 1: Applying foundation schema (000_foundation.sql)...')
-  const foundationOk = await runMigration('000_foundation.sql', options.dryRun)
-  if (!foundationOk && !options.dryRun) {
-    console.error('\n❌ Init failed at foundation schema. Check your Supabase connection.')
-    process.exit(1)
-  }
-  console.log('  ✓ Foundation schema applied')
-
-  // Step 2: Seed data
-  console.log('\n🌱 Step 2: Applying seed data (001_seed.sql)...')
-  const seedOk = await runMigration('001_seed.sql', options.dryRun)
-  if (!seedOk && !options.dryRun) {
-    console.error('\n❌ Init failed at seed data.')
-    process.exit(1)
-  }
-  console.log('  ✓ Seed data applied')
-
-  // Step 3: Record migration versions
-  if (!options.dryRun) {
-    console.log('\n📝 Step 3: Recording migration versions...')
-    const supabaseUrl = process.env.SUPABASE_URL!
-    const serviceKey = process.env.SUPABASE_SERVICE_ROLE_KEY!
-    await fetch(`${supabaseUrl}/rest/v1/schema_migrations`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'apikey': serviceKey,
-        'Authorization': `Bearer ${serviceKey}`,
-        'Prefer': 'resolution=merge-duplicates',
-      },
-      body: JSON.stringify([
-        { version: '000_foundation', applied_at: new Date().toISOString() },
-        { version: '001_seed', applied_at: new Date().toISOString() },
-      ])
-    })
-    console.log('  ✓ Migration versions recorded')
-  }
-
-  // Step 4: Scaffold custom workspace
-  if (!options.skipScaffold) {
-    console.log('\n📁 Step 4: Scaffolding custom workspace...')
-    scaffoldCustomWorkspace(options.dryRun)
-  }
+  // Step 2: Scaffold custom workspace
+  console.log('\n📁 Step 2: Scaffolding custom workspace...')
+  scaffoldCustomWorkspace(options.dryRun)
 
-  console.log('\n✅ Spine initialized successfully!')
-  console.log('\n   Next steps:')
-  console.log('   1. spine-framework install-app <app-slug>   # Install an app')
-  console.log('   2. spine-framework create-app my-app        # Or scaffold a new one')
-  console.log('   3. npm run assemble && netlify dev          # Start developing')
+  console.log('\n✅ Project initialized!')
+  console.log('\n   Next: apply database migrations:')
+  console.log('   spine-framework migrate --db-password <your-db-password>')
+  console.log('\n   Find your DB password at:')
+  console.log('   https://supabase.com/dashboard/project/_/settings/database')
 }
 
 export function registerInitCommands(program: Command) {
   program
     .command('init')
-    .description('Initialize a fresh Spine installation (schema + seed + scaffold)')
-    .option('--url <url>', 'Supabase project URL (writes .env if provided)')
+    .description('Write .env and scaffold the custom/ workspace (no DB changes)')
+    .option('--url <url>', 'Supabase project URL')
     .option('--anon-key <key>', 'Supabase anon key')
     .option('--service-role-key <key>', 'Supabase service role key')
-    .option('--skip-scaffold', 'Skip creating custom/ workspace directories', false)
     .option('--dry-run', 'Show what would happen without making changes', false)
     .action(async (opts) => {
       try {

package/.framework/cli/commands/migrate.ts

@@ -0,0 +1,134 @@
+/// <reference types="node" />
+/**
+ * @module cli/commands/migrate
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine-framework migrate` — Apply SQL migrations to a Supabase project
+ * via a direct Postgres connection.
+ *
+ * Requires --db-password (the Supabase database password).
+ * Get it from: https://supabase.com/dashboard/project/_/settings/database
+ *
+ * **Usage:**
+ * ```bash
+ * spine-framework migrate --db-password <password>
+ * spine-framework migrate --db-password <password> --dry-run
+ * ```
+ */
+
+import type { Command } from 'commander'
+import { existsSync, readdirSync, readFileSync } from 'fs'
+import { resolve, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const MIGRATIONS_DIR = resolve(__dirname, '../../migrations')
+
+interface MigrateOptions {
+  dbPassword: string
+  dryRun: boolean
+}
+
+async function migrateCommand(options: MigrateOptions): Promise<void> {
+  console.log('\n🗄️  Spine Framework — Migrate\n')
+
+  const supabaseUrl = process.env.SUPABASE_URL
+  if (!supabaseUrl) {
+    console.error('❌ SUPABASE_URL not set. Run `spine-framework init` first.')
+    process.exit(1)
+  }
+
+  // Derive connection string from Supabase URL
+  // Format: https://<ref>.supabase.co → postgres://postgres.<ref>:<password>@aws-0-<region>.pooler.supabase.com:5432/postgres
+  // Use direct connection (port 5432) via the db.<ref>.supabase.co host
+  const projectRef = supabaseUrl.replace('https://', '').split('.')[0]
+  const connectionString = `postgresql://postgres:${options.dbPassword}@db.${projectRef}.supabase.co:5432/postgres`
+
+  if (!existsSync(MIGRATIONS_DIR)) {
+    console.error(`❌ Migrations directory not found: ${MIGRATIONS_DIR}`)
+    process.exit(1)
+  }
+
+  const files = readdirSync(MIGRATIONS_DIR)
+    .filter(f => f.endsWith('.sql'))
+    .sort()
+
+  if (files.length === 0) {
+    console.log('  No migration files found.')
+    return
+  }
+
+  console.log(`  Found ${files.length} migration file(s)\n`)
+
+  if (options.dryRun) {
+    for (const file of files) {
+      console.log(`  [dry-run] Would apply: ${file}`)
+    }
+    return
+  }
+
+  // Dynamically import pg to avoid loading it at module init time
+  const { default: pg } = await import('pg')
+  const client = new pg.Client({ connectionString })
+
+  try {
+    await client.connect()
+    console.log('  ✓ Connected to database\n')
+  } catch (err: any) {
+    console.error(`❌ Could not connect to database: ${err.message}`)
+    console.error('   Check your --db-password and that the project is active.')
+    process.exit(1)
+  }
+
+  let applied = 0
+  let failed = 0
+
+  for (const file of files) {
+    const sql = readFileSync(resolve(MIGRATIONS_DIR, file), 'utf8')
+    process.stdout.write(`  Applying ${file}... `)
+    try {
+      await client.query(sql)
+      console.log('✓')
+      applied++
+    } catch (err: any) {
+      console.log('❌')
+      console.error(`     ${err.message}`)
+      failed++
+      // Continue applying remaining migrations
+    }
+  }
+
+  await client.end()
+
+  console.log(`\n  ${applied} applied, ${failed} failed`)
+
+  if (failed > 0) {
+    console.error('\n❌ Some migrations failed. Check errors above.')
+    process.exit(1)
+  }
+
+  console.log('\n✅ All migrations applied successfully!')
+  console.log('\n   Next steps:')
+  console.log('   1. spine-framework install-app <app-slug>')
+  console.log('   2. npm run assemble && netlify dev')
+}
+
+export function registerMigrateCommands(program: Command) {
+  program
+    .command('migrate')
+    .description('Apply SQL migrations via direct Postgres connection')
+    .requiredOption('--db-password <password>', 'Supabase database password (from dashboard → Settings → Database)')
+    .option('--dry-run', 'Show what would happen without making changes', false)
+    .action(async (opts) => {
+      try {
+        await migrateCommand(opts)
+      } catch (err: any) {
+        console.error('Error:', err.message)
+        if (process.env.SPINE_CLI_DEBUG) console.error(err.stack)
+        process.exit(1)
+      }
+    })
+}

package/.framework/cli/index.ts

@@ -66,6 +66,7 @@ const [
   { registerInstallAppCommands },
   { registerStatusCommands },
   { registerUninstallAppCommands },
+  { registerMigrateCommands },
 ] = await Promise.all([
   import('./commands/auth.ts'),
   import('./commands/pipelines.ts'),
@@ -82,6 +83,7 @@ const [
   import('./commands/install-app.ts'),
   import('./commands/status.ts'),
   import('./commands/uninstall-app.ts'),
+  import('./commands/migrate.ts'),
 ])
 
 registerAuthCommands(program)
@@ -99,6 +101,7 @@ registerInitCommands(program)
 registerInstallAppCommands(program)
 registerStatusCommands(program)
 registerUninstallAppCommands(program)
+registerMigrateCommands(program)
 
 program.parseAsync(process.argv).catch((err) => {
   console.error('Error:', err.message)

package/dist/cli/commands/init.d.ts

@@ -4,26 +4,16 @@
  * @layer cli
  * @stability stable
  *
- * `spine-framework init` — Bootstrap a fresh Spine installation.
+ * `spine-framework init` — Write .env and scaffold the custom/ workspace.
  *
- * Runs the foundation schema (000_foundation.sql) and seed data (001_seed.sql)
- * against the configured Supabase project, then scaffolds the custom/ workspace
- * if it doesn't already exist.
+ * Intentionally does NOT touch the database — run `spine-framework migrate`
+ * after init to apply SQL migrations via a direct Postgres connection.
  *
  * **Usage:**
  * ```bash
- * # Fresh install (agent provides credentials from Supabase dashboard)
  * spine-framework init --url https://xyz.supabase.co --anon-key eyJ... --service-role-key eyJ...
- *
- * # Already have .env configured
- * spine-framework init
- *
- * # DB only, no filesystem changes
- * spine-framework init --skip-scaffold
+ * spine-framework migrate --db-password <password>
  * ```
- *
- * When --url/--anon-key/--service-role-key are provided, init writes .env before
- * running migrations — so it works on a completely fresh checkout with no prior config.
  */
 import type { Command } from 'commander';
 export declare function registerInitCommands(program: Command): void;

package/dist/cli/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/init.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAoOxC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAkBpD"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/init.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AA8FxC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAiBpD"}

package/dist/cli/commands/migrate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module cli/commands/migrate
+ * @audience installer
+ * @layer cli
+ * @stability stable
+ *
+ * `spine-framework migrate` — Apply SQL migrations to a Supabase project
+ * via a direct Postgres connection.
+ *
+ * Requires --db-password (the Supabase database password).
+ * Get it from: https://supabase.com/dashboard/project/_/settings/database
+ *
+ * **Usage:**
+ * ```bash
+ * spine-framework migrate --db-password <password>
+ * spine-framework migrate --db-password <password> --dry-run
+ * ```
+ */
+import type { Command } from 'commander';
+export declare function registerMigrateCommands(program: Command): void;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/cli/commands/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../../.framework/cli/commands/migrate.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAkGxC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QAevD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "private": false,
   "description": "Spine — enterprise application framework built on Supabase + Netlify + React",
   "type": "module",
@@ -90,7 +90,8 @@
     "jsonwebtoken": "^9.0.3",
     "jwt-decode": "^4.0.0",
     "tsx": "^4.21.0",
-    "ws": "^8.21.0"
+    "ws": "^8.21.0",
+    "pg": "^8.13.0"
   },
   "peerDependencies": {
     "@netlify/functions": "^2.0.0",