spine-framework 0.3.62 → 0.3.65

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

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander'
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+interface Manifest {
+  name: string
+  slug: string
+  version: string
+  app_type: 'full' | 'ui' | 'backend' | 'data'
+  registration?: {
+    enabled?: boolean
+    default_role?: string
+    redirect_path?: string
+    account_strategy?: 'existing' | 'new' | 'choice'
+    target_account?: string
+  }
+}
+
+interface PackageJson {
+  name: string
+  version: string
+  files?: string[]
+  spine?: {
+    type?: string
+    slug?: string
+    manifestPath?: string
+    app_slug?: string
+    entry_point?: string
+    manifest?: string
+  }
+}
+
+class ValidationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'ValidationError'
+  }
+}
+
+function validateManifest(appPath: string): Manifest {
+  const manifestPath = join(appPath, 'manifest.json')
+  
+  if (!existsSync(manifestPath)) {
+    throw new ValidationError('❌ manifest.json is required')
+  }
+  
+  let manifest: Manifest
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+  } catch (err) {
+    throw new ValidationError('❌ manifest.json is not valid JSON')
+  }
+  
+  // Required fields
+  const requiredFields = ['name', 'slug', 'version', 'app_type']
+  for (const field of requiredFields) {
+    if (!manifest[field]) {
+      throw new ValidationError(`❌ manifest.json missing required field: ${field}`)
+    }
+  }
+  
+  // Validate app_type
+  const validAppTypes = ['full', 'ui', 'backend', 'data']
+  if (!validAppTypes.includes(manifest.app_type)) {
+    throw new ValidationError(`❌ manifest.json app_type must be one of: ${validAppTypes.join(', ')}`)
+  }
+  
+  return manifest
+}
+
+function validatePackageJson(appPath: string, manifest: Manifest): PackageJson {
+  const packagePath = join(appPath, 'package.json')
+  
+  if (!existsSync(packagePath)) {
+    throw new ValidationError('❌ package.json is required')
+  }
+  
+  let packageJson: PackageJson
+  try {
+    packageJson = JSON.parse(readFileSync(packagePath, 'utf8'))
+  } catch (err) {
+    throw new ValidationError('❌ package.json is not valid JSON')
+  }
+  
+  // Check version sync
+  if (packageJson.version !== manifest.version) {
+    throw new ValidationError(`❌ Version mismatch: package.json has ${packageJson.version} but manifest.json has ${manifest.version}`)
+  }
+  
+  return packageJson
+}
+
+function validateRequiredFiles(appPath: string, manifest: Manifest): void {
+  const { app_type } = manifest
+  
+  // index.tsx is required for full and ui apps
+  if (['full', 'ui'].includes(app_type)) {
+    if (!existsSync(join(appPath, 'index.tsx'))) {
+      throw new ValidationError('❌ index.tsx is required for full and ui apps')
+    }
+  }
+  
+  // pages/ is required for full and ui apps
+  if (['full', 'ui'].includes(app_type)) {
+    if (!existsSync(join(appPath, 'pages'))) {
+      throw new ValidationError('❌ pages/ directory is required for full and ui apps')
+    }
+  }
+  
+  // functions/ is required for full and backend apps
+  if (['full', 'backend'].includes(app_type)) {
+    if (!existsSync(join(appPath, 'functions'))) {
+      throw new ValidationError('❌ functions/ directory is required for full and backend apps')
+    }
+  }
+}
+
+function validateAllowedDirectories(appPath: string): void {
+  const allowedDirs = [
+    'pages', 'components', 'hooks', 'utils', 'functions', 
+    'seed', 'public', '.devin'
+  ]
+  
+  const entries = readdirSync(appPath, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name)
+  
+  const unknownDirs = entries.filter(dir => !allowedDirs.includes(dir))
+  
+  if (unknownDirs.length > 0) {
+    throw new ValidationError(`❌ Unknown directories found: ${unknownDirs.join(', ')}. Allowed directories: ${allowedDirs.join(', ')}`)
+  }
+}
+
+function validateDevinDirectory(appPath: string): void {
+  const devinPath = join(appPath, '.devin')
+  
+  if (existsSync(devinPath)) {
+    const agentsPath = join(devinPath, 'AGENTS.md')
+    const agentsAltPath = join(devinPath, 'AGENT.md')
+    
+    if (!existsSync(agentsPath) && !existsSync(agentsAltPath)) {
+      throw new ValidationError('❌ .devin/ directory exists but AGENTS.md is missing. If .devin/ exists, it must contain AGENTS.md with agentic guidance.')
+    }
+    
+    // Validate skills if they exist
+    const skillsPath = join(devinPath, 'skills')
+    if (existsSync(skillsPath)) {
+      const skillDirs = readdirSync(skillsPath, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+      
+      for (const skillDir of skillDirs) {
+        const skillFile = join(skillsPath, skillDir.name, 'SKILL.md')
+        if (!existsSync(skillFile)) {
+          throw new ValidationError(`❌ Skill directory ${skillDir.name} exists but SKILL.md is missing`)
+        }
+      }
+    }
+  }
+}
+
+function validatePackageFiles(appPath: string, packageJson: PackageJson): void {
+  const { files = [] } = packageJson
+  
+  // Check that important directories are included in files array
+  const importantFiles = ['index.tsx', 'manifest.json']
+  const importantDirs = ['pages', 'components', 'hooks', 'utils', 'functions', 'seed', 'public']
+  
+  for (const file of importantFiles) {
+    if (existsSync(join(appPath, file)) && !files.includes(file)) {
+      console.warn(`⚠️  ${file} exists but is not in package.json files array`)
+    }
+  }
+  
+  for (const dir of importantDirs) {
+    if (existsSync(join(appPath, dir)) && !files.includes(`${dir}/`)) {
+      console.warn(`⚠️  ${dir}/ exists but is not in package.json files array`)
+    }
+  }
+}
+
+function validateApp(appPath: string): void {
+  try {
+    console.log(`🔍 Validating app at: ${appPath}`)
+    
+    const manifest = validateManifest(appPath)
+    console.log(`✅ manifest.json valid for ${manifest.name} v${manifest.version}`)
+    
+    const packageJson = validatePackageJson(appPath, manifest)
+    console.log(`✅ package.json valid and versions match`)
+    
+    validateRequiredFiles(appPath, manifest)
+    console.log(`✅ Required files present for app_type: ${manifest.app_type}`)
+    
+    validateAllowedDirectories(appPath)
+    console.log(`✅ No unknown directories found`)
+    
+    validateDevinDirectory(appPath)
+    console.log(`✅ .devin/ directory valid (if present)`)
+    
+    validatePackageFiles(appPath, packageJson)
+    console.log(`✅ package.json files array checked`)
+    
+    console.log(`\n🎉 App validation passed!`)
+    
+  } catch (err) {
+    if (err instanceof ValidationError) {
+      console.error(err.message)
+      process.exit(1)
+    } else {
+      console.error(`❌ Unexpected error: ${err.message}`)
+      process.exit(1)
+    }
+  }
+}
+
+const program = new Command()
+
+program
+  .name('validate-app')
+  .description('Validate a Spine app structure and configuration')
+  .argument('[path]', 'Path to the app directory', '.')
+  .action(validateApp)
+
+program.parse()

package/.framework/scripts/assemble-functions.sh

@@ -42,12 +42,32 @@ fi
 
 # 3. Overlay custom functions (overrides + additions), excluding test files
 CUSTOM_COUNT=0
+
+# 3a. Copy functions from custom/functions/
 if [ -d "$CUSTOM_DIR/functions" ]; then
   # Copy all files except test files (*-test.ts, *.test.ts)
   find "$CUSTOM_DIR/functions" -maxdepth 1 -name '*.ts' ! -name '*-test.ts' ! -name '*.test.ts' -exec cp {} "$TMP_DIR"/ \; 2>/dev/null || true
   # Copy subdirectories if any
   find "$CUSTOM_DIR/functions" -mindepth 1 -type d -exec sh -c 'dir="$1"; base=$(basename "$dir"); mkdir -p "'"$TMP_DIR"'/$base" && cp -r "$dir"/* "'"$TMP_DIR"'/$base/"' _ {} \; 2>/dev/null || true
-  CUSTOM_COUNT=$(find "$CUSTOM_DIR/functions" -name '*.ts' ! -name '*-test.ts' ! -name '*.test.ts' 2>/dev/null | wc -l | tr -d ' ')
+  CUSTOM_COUNT=$((CUSTOM_COUNT + $(find "$CUSTOM_DIR/functions" -name '*.ts' ! -name '*-test.ts' ! -name '*.test.ts' 2>/dev/null | wc -l | tr -d ' ')))
+fi
+
+# 3b. Copy functions from custom/apps/*/functions/
+if [ -d "$CUSTOM_DIR/apps" ]; then
+  for app_dir in "$CUSTOM_DIR/apps"/*; do
+    if [ -d "$app_dir/functions" ]; then
+      # Copy all files except test files (*-test.ts, *.test.ts)
+      find "$app_dir/functions" -maxdepth 1 -name '*.ts' ! -name '*-test.ts' ! -name '*.test.ts' -exec cp {} "$TMP_DIR"/ \; 2>/dev/null || true
+      # Copy subdirectories if any
+      find "$app_dir/functions" -mindepth 1 -type d -exec sh -c 'dir="$1"; base=$(basename "$dir"); mkdir -p "'"$TMP_DIR"'/$base" && cp -r "$dir"/* "'"$TMP_DIR"'/$base/"' _ {} \; 2>/dev/null || true
+      APP_COUNT=$(find "$app_dir/functions" -name '*.ts' ! -name '*-test.ts' ! -name '*.test.ts' 2>/dev/null | wc -l | tr -d ' ')
+      CUSTOM_COUNT=$((CUSTOM_COUNT + APP_COUNT))
+      echo "  ✓ $(basename "$app_dir"): $APP_COUNT files"
+    fi
+  done
+fi
+
+if [ $CUSTOM_COUNT -gt 0 ]; then
   echo "  ✓ Custom: $CUSTOM_COUNT files"
 else
   echo "  ○ Custom: (empty)"

package/.framework/src/pages/auth/RegisterPage.tsx

@@ -252,6 +252,8 @@ export function RegisterPage() {
       if (urlApp && regConfig?.apps[urlApp]) {
         const appConfig = regConfig.apps[urlApp]
         
+        console.log('App config found:', appConfig)
+        
         // Determine role
         if (urlRole && appConfig.roles.includes(urlRole)) {
           effectiveRole = urlRole
@@ -262,6 +264,8 @@ export function RegisterPage() {
         // Determine account strategy
         effectiveAccountStrategy = appConfig.account_strategy
         targetAccount = appConfig.target_account
+        
+        console.log('Account strategy resolved:', { effectiveAccountStrategy, targetAccount })
       }
       // If only URL role is specified (no app), use it directly with default strategy
       else if (urlRole) {
@@ -294,8 +298,11 @@ export function RegisterPage() {
 
       // Handle account creation vs existing account assignment
       let registrationResult
+      console.log('Registration decision:', { accountStrategy, targetAccount, effectiveRole })
+      
       if (accountStrategy === 'existing' && targetAccount) {
         // Assign to existing account
+        console.log('Using existing_account path')
         registrationResult = await callInvitesApi('complete-registration', {
           path: 'existing_account',
           email: resolvedEmail,
@@ -304,6 +311,7 @@ export function RegisterPage() {
         }, 'POST')
       } else {
         // Create new account (personal or company)
+        console.log('Using new_account path')
         const accountName = useType === 'personal' ? fullName : companyName
         registrationResult = await callInvitesApi('complete-registration', {
           path: 'new_account',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework",
-  "version": "0.3.62",
+  "version": "0.3.65",
   "description": "Multi-tenant, modular application platform for modern SaaS systems",
   "type": "module",
   "bin": {