spine-framework 0.3.17 → 0.3.19

package/.framework/cli/bin.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'
+import { fileURLToPath } from 'url'
+import { dirname, resolve } from 'path'
+import { spawnSync } from 'child_process'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const tsEntry = resolve(__dirname, 'index.ts')
+
+// Find tsx relative to this package or globally
+const result = spawnSync('npx', ['--yes', 'tsx', tsEntry, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  shell: true,
+})
+
+process.exit(result.status ?? 0)

package/.framework/cli/commands/create-app.ts

@@ -28,7 +28,7 @@ import { adminDb } from '../../functions/_shared/index.ts'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
-const PROJECT_ROOT = process.cwd()
+const PROJECT_ROOT = resolve(__dirname, '../../../')
 
 function toTitleCase(slug: string): string {
   return slug.split('-').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join(' ')

package/.framework/cli/commands/dev.ts

@@ -5,81 +5,177 @@
  * @layer cli
  * @stability stable
  *
- * `spine-framework dev` command — assemble and start the Netlify dev server.
+ * `spine dev` command — unified development server for Spine.
+ * Handles assembly, integrity verification, and Vite dev server startup.
+ *
+ * **Commands:**
+ * | Subcommand        | Description                                           |
+ * |-------------------|-------------------------------------------------------|
+ * | `dev`             | Start dev server with assembly and integrity check    |
+ * | `dev --no-verify` | Skip integrity verification (faster)                  |
+ * | `dev --port 3002` | Use custom port (default: 3001)                       |
+ * | `dev --watch`     | Watch v2-custom for changes and auto-reassemble         |
+ * | `dev --no-watch`  | Disable file watching (manual rebuild only)           |
  *
  * **What happens:**
- * 1. Runs `npm run assemble` to merge framework + custom apps
- * 2. Starts `netlify dev` (which runs Vite + Netlify Functions)
+ * 1. Runs `assemble:v2` to merge v2-core + v2-custom
+ * 2. Runs `verify` to check core integrity (unless --no-verify)
+ * 3. Starts Vite dev server on port 3001 (or --port)
+ * 4. Watches v2-custom/ for changes (--watch by default)
+ * 5. Fast incremental reassembly on custom code changes
  *
  * **Usage:**
  * ```bash
- * spine-framework dev
- * spine-framework dev --no-assemble   # skip assembly step
+ * spine dev
+ * spine dev --port 3002
+ * spine dev --no-verify
  * ```
  *
- * @seeAlso scripts/assemble.sh (assembly script)
- * @seeAlso netlify.toml (Netlify dev configuration)
+ * @seeAlso scripts/assemble-v2.sh (assembly script)
+ * @seeAlso scripts/verify-integrity.sh (verification script)
+ * @seeAlso vite.config.ts (Vite configuration)
  */
 
 import type { Command } from 'commander'
-import { spawn } from 'child_process'
+import { spawn, execSync } from 'child_process'
 import { resolve, dirname } from 'path'
 import { fileURLToPath } from 'url'
-import { existsSync } from 'fs'
+import { watch, existsSync, statSync, readdirSync } from 'fs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
-const PROJECT_ROOT = process.cwd()
+const PROJECT_ROOT = resolve(__dirname, '../../../')
 
 // ─── COMMAND REGISTRATION ──────────────────────────────────────────────────
 
 export function registerDevCommands(program: Command) {
   program
     .command('dev')
-    .description('Assemble and start the Netlify dev server')
-    .option('--no-assemble', 'Skip the assembly step')
+    .description('Start Spine development server')
+    .option('--no-verify', 'Skip integrity verification')
+    .option('--port <port>', 'Dev server port', '3001')
+    .option('--host', 'Expose to network', false)
+    .option('--no-watch', 'Disable file watching')
+    .option('--watch-delay <ms>', 'Debounce delay for reassembly', '500')
     .action(async (opts) => {
       console.log('\n🚀 Starting Spine dev server...\n')
 
       try {
         // Step 1: Assembly
-        if (opts.assemble !== false) {
-          console.log('📦 Step 1: Assembling...')
-          const assemblyExitCode = await runCommand('npm', ['run', 'assemble'], PROJECT_ROOT)
+        console.log('📦 Step 1: Assembling v2-core + v2-custom...')
+        const assemblyExitCode = await runCommand(
+          'bash',
+          [resolve(PROJECT_ROOT, 'scripts/assemble-v2.sh')],
+          PROJECT_ROOT
+        )
+
+        if (assemblyExitCode !== 0) {
+          console.error('\n❌ Assembly failed. Please check the errors above.')
+          process.exit(1)
+        }
+        console.log('✓ Assembly complete\n')
 
-          if (assemblyExitCode !== 0) {
-            console.error('\n❌ Assembly failed. Please check the errors above.')
-            process.exit(1)
+        // Step 2: Integrity verification (unless skipped)
+        if (opts.verify !== false) {
+          console.log('🔒 Step 2: Verifying core integrity...')
+          const verifyExitCode = await runCommand(
+            'bash',
+            [resolve(PROJECT_ROOT, 'scripts/verify-integrity.sh')],
+            PROJECT_ROOT
+          )
+
+          if (verifyExitCode !== 0) {
+            console.warn('\n⚠️  Integrity check failed. Continuing anyway (--no-verify to skip)\n')
+          } else {
+            console.log('✓ Integrity verified\n')
           }
-          console.log('✓ Assembly complete\n')
         } else {
-          console.log('⏭️  Step 1: Skipping assembly (--no-assemble)\n')
+          console.log('⏭️  Step 2: Skipping integrity verification (--no-verify)\n')
         }
 
-        // Step 2: Start netlify dev
-        console.log('🌐 Step 2: Starting netlify dev...')
+        // Step 3: Start Vite
+        console.log(`🌐 Step 3: Starting Vite dev server on port ${opts.port}...`)
         console.log('   (Press Ctrl+C to stop)\n')
 
-        const netlifyBin = resolve(PROJECT_ROOT, 'node_modules/.bin/netlify')
-        const cmd = existsSync(netlifyBin) ? netlifyBin : 'netlify'
+        const vite = spawn(
+          resolve(PROJECT_ROOT, 'node_modules/.bin/vite'),
+          [
+            '--config', resolve(PROJECT_ROOT, 'vite.config.ts'),
+            '--port', opts.port,
+            ...(opts.host ? ['--host'] : [])
+          ],
+          {
+            cwd: PROJECT_ROOT,
+            stdio: 'inherit',
+            env: { ...process.env, SPINE_DEV: 'true' }
+          }
+        )
+
+        // Step 4: Watch v2-custom for changes (unless disabled)
+        let watcher: ReturnType<typeof watch> | null = null
+        if (opts.watch !== false) {
+          const watchDelay = parseInt(opts.watchDelay) || 500
+          const customDir = resolve(PROJECT_ROOT, 'v2-custom')
 
-        const netlify = spawn(cmd, ['dev'], {
-          cwd: PROJECT_ROOT,
-          stdio: 'inherit',
-          env: { ...process.env }
-        })
+          if (existsSync(customDir)) {
+            console.log(`👁️  Step 4: Watching v2-custom/ for changes...`)
+            console.log(`   (Changes trigger fast reassembly after ${watchDelay}ms debounce)\n`)
+
+            let reassemblyTimeout: NodeJS.Timeout | null = null
+
+            watcher = watch(customDir, { recursive: true }, (eventType, filename) => {
+              // Ignore node_modules, .git, and temp files
+              if (!filename || filename.includes('node_modules') || filename.startsWith('.')) {
+                return
+              }
+
+              console.log(`\n📝 Change detected in v2-custom/${filename}`)
 
-        netlify.on('exit', (code) => {
+              // Debounce reassembly
+              if (reassemblyTimeout) {
+                clearTimeout(reassemblyTimeout)
+              }
+
+              reassemblyTimeout = setTimeout(async () => {
+                console.log('🔧 Running fast reassembly...')
+                try {
+                  const start = Date.now()
+                  await fastReassemble(PROJECT_ROOT)
+                  const duration = Date.now() - start
+                  console.log(`✓ Reassembly complete (${duration}ms)\n`)
+                } catch (err: any) {
+                  console.error(`✗ Reassembly failed: ${err.message}\n`)
+                }
+              }, watchDelay)
+            })
+          } else {
+            console.log('⏭️  Step 4: v2-custom/ not found, skipping watch mode\n')
+          }
+        } else {
+          console.log('⏭️  Step 4: File watching disabled (--no-watch)\n')
+        }
+
+        vite.on('exit', (code) => {
+          if (watcher) {
+            watcher.close()
+          }
           process.exit(code || 0)
         })
 
+        // Handle Ctrl+C gracefully
         process.on('SIGINT', () => {
-          console.log('\n\n🛑 Shutting down...')
-          netlify.kill('SIGTERM')
+          console.log('\n\n🛑 Shutting down dev server...')
+          if (watcher) {
+            watcher.close()
+          }
+          vite.kill('SIGTERM')
         })
 
         process.on('SIGTERM', () => {
-          netlify.kill('SIGTERM')
+          if (watcher) {
+            watcher.close()
+          }
+          vite.kill('SIGTERM')
         })
 
       } catch (err: any) {
@@ -111,3 +207,89 @@ function runCommand(command: string, args: string[], cwd: string): Promise<numbe
     })
   })
 }
+
+/**
+ * Fast incremental reassembly of v2-custom files only.
+ * Uses rsync if available, falls back to selective copy.
+ */
+async function fastReassemble(projectRoot: string): Promise<void> {
+  const customDir = resolve(projectRoot, 'v2-custom')
+  const srcDest = resolve(projectRoot, 'src/v2-assembled')
+  const funcsDest = resolve(projectRoot, 'functions')
+
+  // Check if rsync is available
+  let hasRsync = false
+  try {
+    execSync('which rsync', { stdio: 'pipe' })
+    hasRsync = true
+  } catch {
+    hasRsync = false
+  }
+
+  // Reassemble custom frontend files
+  const customSrcDir = resolve(customDir, 'src')
+  if (existsSync(customSrcDir)) {
+    const destDir = srcDest
+
+    if (hasRsync) {
+      // Use rsync for efficient incremental sync
+      execSync(
+        `rsync -av --delete "${customSrcDir}/" "${destDir}/"`,
+        { stdio: 'pipe', cwd: projectRoot }
+      )
+    } else {
+      // Fallback: copy files that have changed
+      copyChangedFiles(customSrcDir, destDir)
+    }
+  }
+
+  // Reassemble custom function files
+  const customFuncsDir = resolve(customDir, 'functions')
+  if (existsSync(customFuncsDir)) {
+    if (hasRsync) {
+      execSync(
+        `rsync -av --delete "${customFuncsDir}/" "${funcsDest}/"`,
+        { stdio: 'pipe', cwd: projectRoot }
+      )
+    } else {
+      copyChangedFiles(customFuncsDir, funcsDest)
+    }
+  }
+}
+
+/**
+ * Copy only files that have changed (mtime comparison).
+ * Fallback when rsync is not available.
+ */
+function copyChangedFiles(src: string, dest: string): void {
+  const files = readdirSync(src, { withFileTypes: true })
+
+  for (const entry of files) {
+    const srcPath = resolve(src, entry.name)
+    const destPath = resolve(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      if (!existsSync(destPath)) {
+        // Create directory
+        const { mkdirSync } = require('fs')
+        mkdirSync(destPath, { recursive: true })
+      }
+      // Recurse
+      copyChangedFiles(srcPath, destPath)
+    } else {
+      // Check if file needs copying
+      const srcStat = statSync(srcPath)
+      let needsCopy = true
+
+      if (existsSync(destPath)) {
+        const destStat = statSync(destPath)
+        needsCopy = srcStat.mtime > destStat.mtime
+      }
+
+      if (needsCopy) {
+        const { copyFileSync } = require('fs')
+        copyFileSync(srcPath, destPath)
+      }
+    }
+  }
+}

package/.framework/cli/index.ts

@@ -19,13 +19,6 @@
  * | items       | commands/items.ts          |
  * | agents      | commands/agents.ts         |
  * | migrations  | commands/migrations.ts     |
- * | init        | commands/init.ts           |
- * | install-app | commands/install-app.ts    |
- * | update-app  | commands/update-app.ts     |
- * | publish     | commands/publish.ts        |
- * | status      | commands/status.ts         |
- * | claim       | commands/claim.ts          |
- * | uninstall   | commands/uninstall-app.ts  |
  *
  * **Usage:**
  * ```bash
@@ -42,6 +35,7 @@
  * @seeAlso functions/_shared/index.ts (core functions exposed to CLI)
  */
 
+import './env-loader.ts'
 import { Command } from 'commander'
 
 const program = new Command()
@@ -52,75 +46,43 @@ program
   .version('2.0.0')
   .option('--account <id>', 'Override the account ID for this command')
 
-// Commands that do NOT need DB/env — safe to run on a fresh install
-const { registerInitCommands }    = await import('./commands/init.ts')
-const { registerMigrateCommands } = await import('./commands/migrate.ts')
-registerInitCommands(program)
-registerMigrateCommands(program)
+const [
+  { registerAuthCommands },
+  { registerPipelineCommands },
+  { registerItemCommands },
+  { registerAgentCommands },
+  { registerMigrationCommands },
+  { registerDoctorCommands },
+  { registerDevCommands },
+  { registerTestCommands },
+  { registerSystemCommands },
+  { registerGenerateCommands },
+  { registerCreateAppCommands },
+] = await Promise.all([
+  import('./commands/auth.ts'),
+  import('./commands/pipelines.ts'),
+  import('./commands/items.ts'),
+  import('./commands/agents.ts'),
+  import('./commands/migrations.ts'),
+  import('./commands/doctor.ts'),
+  import('./commands/dev.ts'),
+  import('./commands/test.ts'),
+  import('./commands/system.ts'),
+  import('./commands/generate.ts'),
+  import('./commands/create-app.ts'),
+])
 
-// All other commands require SUPABASE_URL to be set — only load if not init/migrate
-const subcommand = process.argv[2]
-const noDbCommands = ['init', 'migrate', '--help', '-h', '--version', '-V', undefined]
-
-if (!noDbCommands.includes(subcommand)) {
-  await import('./env-loader.ts')
-
-  const [
-    { registerAuthCommands },
-    { registerPipelineCommands },
-    { registerItemCommands },
-    { registerAgentCommands },
-    { registerMigrationCommands },
-    { registerDoctorCommands },
-    { registerDevCommands },
-    { registerTestCommands },
-    { registerSystemCommands },
-    { registerGenerateCommands },
-    { registerCreateAppCommands },
-    { registerInstallAppCommands },
-    { registerUpdateAppCommands },
-    { registerPublishCommands },
-    { registerStatusCommands },
-    { registerClaimCommands },
-    { registerUninstallAppCommands },
-  ] = await Promise.all([
-    import('./commands/auth.ts'),
-    import('./commands/pipelines.ts'),
-    import('./commands/items.ts'),
-    import('./commands/agents.ts'),
-    import('./commands/migrations.ts'),
-    import('./commands/doctor.ts'),
-    import('./commands/dev.ts'),
-    import('./commands/test.ts'),
-    import('./commands/system.ts'),
-    import('./commands/generate.ts'),
-    import('./commands/create-app.ts'),
-    import('./commands/install-app.ts'),
-    import('./commands/update-app.ts'),
-    import('./commands/publish.ts'),
-    import('./commands/status.ts'),
-    import('./commands/claim.ts'),
-    import('./commands/uninstall-app.ts'),
-  ])
-
-  registerAuthCommands(program)
-  registerPipelineCommands(program)
-  registerItemCommands(program)
-  registerAgentCommands(program)
-  registerMigrationCommands(program)
-  registerDoctorCommands(program)
-  registerDevCommands(program)
-  registerTestCommands(program)
-  registerSystemCommands(program)
-  registerGenerateCommands(program)
-  registerCreateAppCommands(program)
-  registerInstallAppCommands(program)
-  registerUpdateAppCommands(program)
-  registerPublishCommands(program)
-  registerStatusCommands(program)
-  registerClaimCommands(program)
-  registerUninstallAppCommands(program)
-}
+registerAuthCommands(program)
+registerPipelineCommands(program)
+registerItemCommands(program)
+registerAgentCommands(program)
+registerMigrationCommands(program)
+registerDoctorCommands(program)
+registerDevCommands(program)
+registerTestCommands(program)
+registerSystemCommands(program)
+registerGenerateCommands(program)
+registerCreateAppCommands(program)
 
 program.parseAsync(process.argv).catch((err) => {
   console.error('Error:', err.message)

package/.framework/functions/_shared/app-manifest.ts

@@ -16,8 +16,8 @@
  * @seeAlso 015_simplify_apps_table.sql (database structure)
  */
 
-import { readFileSync, readdirSync, existsSync } from 'fs'
-import { resolve, join } from 'path'
+import { readFileSync } from 'fs'
+import { resolve } from 'path'
 
 export interface AppManifest {
   name: string
@@ -168,17 +168,10 @@ export function mergeWithManifest(dbRecord: any): any {
  * @returns Array of discovered app slugs and their paths
  */
 export function discoverManifests(): Array<{slug: string, path: string}> {
-  const appsDir = resolve(process.cwd(), 'custom/apps')
-  if (!existsSync(appsDir)) return []
-
-  const results: Array<{slug: string, path: string}> = []
-  for (const entry of readdirSync(appsDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue
-    if (entry.name === 'lib' || entry.name.startsWith('.')) continue
-    const manifestPath = join('custom/apps', entry.name, 'manifest.json')
-    if (existsSync(resolve(process.cwd(), manifestPath))) {
-      results.push({ slug: entry.name, path: manifestPath })
-    }
-  }
-  return results
+  // In production, this would scan the filesystem
+  // For now, return known manifests based on the plan
+  return [
+    { slug: 'cortex', path: 'custom/apps/cortex/manifest.json' },
+    { slug: 'customer-portal', path: 'custom/apps/customer-portal/manifest.json' }
+  ]
 }

package/.framework/functions/_shared/db.ts

@@ -15,14 +15,14 @@
  */
 
 import { createClient } from '@supabase/supabase-js'
-import WebSocket from 'ws'
-
-// WebSocket constructor for Supabase Realtime in Node.js environment
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const RealtimeWebSocket = WebSocket as any
 
 // ─── ENVIRONMENT RESOLUTION ──────────────────────────────────────────────────
 
+const _env = (globalThis as any).process?.env || {}
+const supabaseUrl: string = _env.SUPABASE_URL!
+const supabaseServiceKey: string = _env.SUPABASE_SERVICE_ROLE_KEY!
+const supabaseAnonKey: string = _env.SUPABASE_ANON_KEY!
+
 /**
  * Active database schema name, read from `DB_SCHEMA` env var.
  *
@@ -35,10 +35,6 @@ const RealtimeWebSocket = WebSocket as any
  * @sideEffects none
  * @calledBy adminDb, getUserDb (applied at client construction time)
  */
-const _env = (globalThis as any).process?.env || {}
-const supabaseUrl: string = _env.SUPABASE_URL || 'https://placeholder.supabase.co'
-const supabaseServiceKey: string = _env.SUPABASE_SERVICE_ROLE_KEY || ''
-const supabaseAnonKey: string = _env.SUPABASE_ANON_KEY || ''
 const dbSchema: string = _env.DB_SCHEMA || 'public'
 
 // ─── CLIENTS ─────────────────────────────────────────────────────────────────
@@ -78,9 +74,9 @@ const dbSchema: string = _env.DB_SCHEMA || 'public'
  * ```
  */
 export const adminDb = createClient(supabaseUrl, supabaseServiceKey, {
-  db: { schema: dbSchema },
-  auth: { autoRefreshToken: false, persistSession: false },
-  realtime: { transport: RealtimeWebSocket }
+  db: {
+    schema: dbSchema
+  }
 })
 
 // ─── CHUNK_START: SHARED_DB_GET_USER_DB ──────────────────────────────────────────────
@@ -99,9 +95,9 @@ export const adminDb = createClient(supabaseUrl, supabaseServiceKey, {
  */
 export function getUserDb(jwt: string) {
   return createClient(supabaseUrl, supabaseAnonKey, {
-    db: { schema: dbSchema },
-    auth: { autoRefreshToken: false, persistSession: false },
-    realtime: { transport: RealtimeWebSocket },  // WebSocket for Node.js 20+
+    db: {
+      schema: dbSchema
+    },
     global: {
       headers: {
         Authorization: `Bearer ${jwt}`

package/.framework/functions/_shared/index.ts

@@ -285,21 +285,21 @@ export { emitAudit } from './audit'
 // ============================================
 
 /**
- * lookupHandler — look up webhook handler metadata by name.
+ * resolveHandler — dynamically load a webhook handler by name.
  *
- * Queries the webhook_handlers table for handler registration info.
- * Actual handler loading is done via HANDLER_REGISTRY static imports.
+ * Used by integration-routes.ts to resolve handlers at runtime
+ * without static imports, enabling custom handlers to self-register.
  *
  * @param handlerName — The handler identifier from webhook_handlers table
- * @returns Handler metadata or null if not found
+ * @returns Handler function or null if not found
  *
  * @example
  * ```ts
- * const meta = await lookupHandler('cortex-webhook')
- * if (meta) console.log(meta.functionName)
+ * const handler = await resolveHandler('cortex-webhook')
+ * if (handler) await handler(event, context)
  * ```
  */
-export { lookupHandler } from './webhook-registry'
+export { resolveHandler, lookupHandler, loadHandler } from './webhook-registry'
 
 /**
  * registerWebhookHandler — self-register a custom webhook handler.
@@ -380,12 +380,3 @@ export {
   expectErrorResponse
 } from './testing'
 export type { TestContext, TestPrincipal, TestLogger } from './testing'
-
-export {
-  resolveTypeIds,
-  resolveTypeId,
-  resolveLinkTypeIds,
-  resolveAccountId,
-  resolveAgentId,
-  resolvePromptConfigId
-} from './resolve-ids'