spine-framework 0.1.12 → 0.1.14

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/bin/spine-framework.cjs

@@ -24,21 +24,7 @@ for (let i = 0; i < args.length; i++) {
   if (args[i] === '--service-role-key' && args[i + 1])  childEnv.SUPABASE_SERVICE_ROLE_KEY = args[++i]
 }
 
-// On Node < 22, supabase-js Realtime crashes if WebSocket is not globally available.
-// Polyfill it via a small inline require so every createClient() call across all
-// _shared modules finds a valid WebSocket constructor at module load time.
-const wsPolyfillPath = resolve(pkgRoot, 'node_modules/ws')
-const wsPolyfillExists = fs.existsSync(wsPolyfillPath)
-if (wsPolyfillExists && !childEnv.SUPABASE_WS_PATCHED) {
-  const major = parseInt(process.version.replace('v', '').split('.')[0], 10)
-  if (major < 22) {
-    const wsShimPath = resolve(pkgRoot, 'bin/ws-shim.cjs')
-    childEnv.NODE_OPTIONS = `--require ${wsShimPath}${childEnv.NODE_OPTIONS ? ' ' + childEnv.NODE_OPTIONS : ''}`
-    childEnv.SUPABASE_WS_PATCHED = '1'
-  }
-}
-
-const entry = resolve(pkgRoot, '.framework/cli/index.ts')
+const entry = resolve(pkgRoot, 'bin/ws-shim.ts')
 
 // Find tsx: prefer consuming project's copy, fall back to our own
 const tsxPaths = [

package/bin/ws-shim.ts

@@ -0,0 +1,10 @@
+// Entry point for the CLI on Node < 22.
+// Sets globalThis.WebSocket before any supabase-js module is imported,
+// preventing the "Node.js 20 detected without native WebSocket" crash.
+import { WebSocket } from 'ws'
+if (typeof globalThis.WebSocket === 'undefined') {
+  ;(globalThis as any).WebSocket = WebSocket
+}
+
+// Now import the real CLI — all supabase createClient() calls happen after this point
+await import('../.framework/cli/index.ts')

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "private": false,
   "description": "Spine — enterprise application framework built on Supabase + Netlify + React",
   "type": "module",