create-fluxstack 1.0.22 → 1.4.0

package/config/system.config.ts

@@ -0,0 +1,105 @@
+/**
+ * System Runtime Configuration
+ * System information and environment variables
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+/**
+ * System environment variables config
+ */
+export const systemConfig = defineConfig({
+  // User/System info
+  user: config.string('USER', ''),
+  username: config.string('USERNAME', ''),
+  home: config.string('HOME', ''),
+  userProfile: config.string('USERPROFILE', ''),
+
+  // Paths
+  pwd: config.string('PWD', ''),
+  path: config.string('PATH', ''),
+
+  // Shell
+  shell: config.string('SHELL', ''),
+  term: config.string('TERM', ''),
+
+  // Common environment variables
+  lang: config.string('LANG', 'en_US.UTF-8'),
+  tmpDir: config.string('TMPDIR', ''),
+
+  // CI/CD detection
+  ci: config.boolean('CI', false),
+
+  // Computed helpers (not from env)
+  get currentUser() {
+    return this.user || this.username || 'unknown'
+  },
+
+  get homeDirectory() {
+    return this.home || this.userProfile || ''
+  },
+
+  get isCI() {
+    return this.ci
+  }
+})
+
+/**
+ * System runtime info (from Node.js/Bun process)
+ * These are not from environment variables, but from runtime
+ */
+export const systemRuntimeInfo = {
+  get nodeVersion() {
+    return process.version
+  },
+
+  get bunVersion() {
+    return (process.versions as any).bun || 'N/A'
+  },
+
+  get platform() {
+    return process.platform
+  },
+
+  get architecture() {
+    return process.arch
+  },
+
+  get cpuCount() {
+    return require('os').cpus().length
+  },
+
+  get totalMemory() {
+    const os = require('os')
+    return Math.round(os.totalmem() / 1024 / 1024 / 1024 * 100) / 100 // GB
+  },
+
+  get workingDirectory() {
+    return process.cwd()
+  },
+
+  get executablePath() {
+    return process.execPath
+  },
+
+  get uptime() {
+    return process.uptime()
+  },
+
+  get memoryUsage() {
+    const usage = process.memoryUsage()
+    return {
+      rss: Math.round(usage.rss / 1024 / 1024 * 100) / 100, // MB
+      heapTotal: Math.round(usage.heapTotal / 1024 / 1024 * 100) / 100,
+      heapUsed: Math.round(usage.heapUsed / 1024 / 1024 * 100) / 100,
+      external: Math.round(usage.external / 1024 / 1024 * 100) / 100
+    }
+  }
+}
+
+// Export types
+export type SystemConfig = typeof systemConfig
+export type SystemRuntimeInfo = typeof systemRuntimeInfo
+
+// Export default
+export default systemConfig

package/core/build/bundler.ts

@@ -9,7 +9,6 @@ export interface BundlerConfig {
   outDir: string
   sourceMaps: boolean
   external?: string[]
-  minify?: boolean
 }
 
 export class Bundler {
@@ -32,6 +31,7 @@ export class Bundler {
         stderr: "pipe",
         env: {
           ...process.env,
+          NODE_ENV: 'production',  // Force production environment for builds
           VITE_BUILD_OUTDIR: this.config.outDir,
           VITE_BUILD_MINIFY: (this.config.minify || false).toString(),
           VITE_BUILD_SOURCEMAPS: this.config.sourceMaps.toString(),
@@ -73,8 +73,21 @@ export class Bundler {
     console.log("⚡ Bundling server...")
     
     const startTime = Date.now()
+    let liveComponentsGenerator: any = null
     
     try {
+      // 🚀 PRE-BUILD: Auto-generate Live Components registration
+      const generatorModule = await import('./live-components-generator')
+      liveComponentsGenerator = generatorModule.liveComponentsGenerator
+      const discoveredComponents = await liveComponentsGenerator.preBuild()
+      console.log(`🔍 Auto-discovered ${discoveredComponents.length} Live Components for bundle`)
+      
+      // 🔌 PRE-BUILD: Auto-generate FluxStack Plugins registration
+      const pluginsGeneratorModule = await import('./flux-plugins-generator')
+      const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
+      const discoveredPlugins = await fluxPluginsGenerator.preBuild()
+      console.log(`🔍 Auto-discovered ${discoveredPlugins.length} FluxStack Plugins for bundle`)
+      
       // Ensure output directory exists
       if (!existsSync(this.config.outDir)) {
         mkdirSync(this.config.outDir, { recursive: true })
@@ -102,9 +115,7 @@ export class Bundler {
         buildArgs.push("--sourcemap")
       }
 
-      if (this.config.minify) {
-        buildArgs.push("--minify")
-      }
+      // Bun bundling only - no minification for better compatibility
 
       const buildProcess = spawn({
         cmd: buildArgs,
@@ -112,6 +123,7 @@ export class Bundler {
         stderr: "pipe",
         env: {
           ...process.env,
+          NODE_ENV: 'production',  // Force production environment for builds
           ...options.env
         }
       })
@@ -119,8 +131,20 @@ export class Bundler {
       const exitCode = await buildProcess.exited
       const duration = Date.now() - startTime
       
+      // 🧹 POST-BUILD: Handle auto-generated registration file
+      // (liveComponentsGenerator already available from above)
+      
       if (exitCode === 0) {
         console.log("✅ Server bundle completed")
+        
+        // Keep generated files for production (they're now baked into bundle)
+        await liveComponentsGenerator.postBuild(false)
+        
+        // Cleanup plugins registry
+        const pluginsGeneratorModule = await import('./flux-plugins-generator')
+        const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
+        await fluxPluginsGenerator.postBuild(false)
+        
         return {
           success: true,
           duration,
@@ -128,8 +152,17 @@ export class Bundler {
           entryPoint: join(this.config.outDir, "index.js")
         }
       } else {
-        const stderr = await new Response(buildProcess.stderr).text()
         console.error("❌ Server bundle failed")
+        
+        // Restore original files since build failed
+        await liveComponentsGenerator.postBuild(false)
+        
+        // Restore plugins registry
+        const pluginsGeneratorModule = await import('./flux-plugins-generator')
+        const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
+        await fluxPluginsGenerator.postBuild(false)
+        
+        const stderr = await new Response(buildProcess.stderr).text()
         return {
           success: false,
           duration,
@@ -138,6 +171,21 @@ export class Bundler {
       }
     } catch (error) {
       const duration = Date.now() - startTime
+      
+      // 🧹 CLEANUP: Restore original files on error
+      try {
+        if (liveComponentsGenerator) {
+          await liveComponentsGenerator.postBuild(false)
+        }
+        
+        // Cleanup plugins registry
+        const pluginsGeneratorModule = await import('./flux-plugins-generator')
+        const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
+        await fluxPluginsGenerator.postBuild(false)
+      } catch (cleanupError) {
+        console.warn('⚠️ Failed to cleanup generated files:', cleanupError)
+      }
+      
       return {
         success: false,
         duration,

package/core/build/flux-plugins-generator.ts

@@ -0,0 +1,315 @@
+// 🚀 FluxStack Plugins - Auto Registration Generator
+// Automatically generates plugin registration during build time
+
+import { existsSync, readdirSync, writeFileSync, unlinkSync, readFileSync, statSync } from 'fs'
+import { join, extname, basename } from 'path'
+
+export interface PluginInfo {
+  pluginDir: string
+  pluginName: string
+  entryFile: string
+  relativePath: string
+  type: 'external' | 'built-in'
+}
+
+export class FluxPluginsGenerator {
+  private pluginsPath: string
+  private builtInPluginsPath: string
+  private registrationFilePath: string
+  private backupFilePath: string
+
+  constructor() {
+    this.pluginsPath = join(process.cwd(), 'plugins')
+    this.builtInPluginsPath = join(process.cwd(), 'core', 'plugins', 'built-in')
+    this.registrationFilePath = join(process.cwd(), 'core', 'plugins', 'auto-registry.ts')
+    this.backupFilePath = join(process.cwd(), 'core', 'plugins', 'auto-registry.backup.ts')
+  }
+
+  /**
+   * Scan plugin directories and discover external plugins only
+   * Built-in plugins are handled by the core system
+   */
+  discoverPlugins(): PluginInfo[] {
+    const plugins: PluginInfo[] = []
+
+    // Discover external plugins only
+    if (existsSync(this.pluginsPath)) {
+      const externalPlugins = this.discoverPluginsInDirectory(this.pluginsPath, 'external')
+      plugins.push(...externalPlugins)
+    } else {
+      console.log('⚠️ No external plugins directory found (plugins/)')
+    }
+
+    // Note: Built-in plugins are automatically loaded by core system
+    // No need to include them in auto-generation
+
+    return plugins
+  }
+
+  /**
+   * Discover plugins in a specific directory
+   */
+  private discoverPluginsInDirectory(directory: string, type: 'external' | 'built-in'): PluginInfo[] {
+    const plugins: PluginInfo[] = []
+
+    try {
+      const entries = readdirSync(directory)
+
+      for (const entry of entries) {
+        const pluginDir = join(directory, entry)
+        
+        // Skip files, only process directories
+        if (!statSync(pluginDir).isDirectory()) {
+          continue
+        }
+
+        // Look for plugin entry point
+        const entryFile = this.findPluginEntryFile(pluginDir)
+        if (entryFile) {
+          const relativePath = type === 'external' 
+            ? `../../plugins/${entry}`
+            : `./built-in/${entry}`
+
+          plugins.push({
+            pluginDir,
+            pluginName: entry,
+            entryFile,
+            relativePath,
+            type
+          })
+
+          console.log(`🔍 Discovered ${type} plugin: ${entry} (${entryFile})`)
+        } else {
+          console.warn(`⚠️ Plugin '${entry}' has no valid entry point`)
+        }
+      }
+    } catch (error) {
+      console.warn(`⚠️ Failed to scan ${type} plugins directory '${directory}':`, error)
+    }
+
+    return plugins
+  }
+
+  /**
+   * Find the main plugin entry file
+   */
+  private findPluginEntryFile(pluginDir: string): string | null {
+    const possibleFiles = [
+      'index.ts',
+      'index.js',
+      'plugin.ts',
+      'plugin.js',
+      'src/index.ts',
+      'src/index.js',
+      'dist/index.js'
+    ]
+
+    for (const file of possibleFiles) {
+      const filePath = join(pluginDir, file)
+      if (existsSync(filePath)) {
+        return basename(file)
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Generate the registration file with all discovered plugins
+   */
+  generateRegistrationFile(plugins: PluginInfo[]): void {
+    // Backup existing file if it exists
+    if (existsSync(this.registrationFilePath)) {
+      const existingContent = readFileSync(this.registrationFilePath, 'utf-8')
+      writeFileSync(this.backupFilePath, existingContent)
+      console.log('📄 Backed up existing auto-registry.ts')
+    }
+
+    // All discovered plugins are external (built-in are handled by core)
+    const externalPlugins = plugins
+
+    // Generate imports
+    const imports = plugins
+      .map(plugin => {
+        const importName = this.getImportName(plugin.pluginName)
+        const importPath = plugin.entryFile === 'index.ts' || plugin.entryFile === 'index.js'
+          ? plugin.relativePath
+          : `${plugin.relativePath}/${plugin.entryFile.replace(/\.(ts|js)$/, '')}`
+        return `import ${importName} from "${importPath}"`
+      })
+      .join('\n')
+
+    // Generate plugin array
+    const pluginsList = plugins
+      .map(plugin => {
+        const importName = this.getImportName(plugin.pluginName)
+        return `  ${importName}`
+      })
+      .join(',\n')
+
+    // Generate file content
+    const fileContent = `// 🔥 Auto-generated FluxStack External Plugins Registry
+// This file is automatically generated during build time - DO NOT EDIT MANUALLY
+// Built-in plugins are handled by the core system automatically
+// Generated at: ${new Date().toISOString()}
+
+import type { Plugin } from './types'
+
+${imports}
+
+// Auto-discovered external plugins array
+export const discoveredPlugins: Plugin[] = [
+${pluginsList}
+]
+
+// All discovered plugins are external (built-in handled by core)
+export const externalPlugins = discoveredPlugins
+
+// Plugin registration function
+export async function registerDiscoveredPlugins(registry: any): Promise<void> {
+  if (discoveredPlugins.length === 0) {
+    console.log('📦 No external plugins to register')
+    return
+  }
+  
+  console.log(\`📦 Registering \${discoveredPlugins.length} auto-discovered external plugins...\`)
+  
+  let registered = 0
+  let failed = 0
+  
+  for (const plugin of discoveredPlugins) {
+    try {
+      await registry.register(plugin)
+      registered++
+      console.log(\`✅ Registered external plugin: \${plugin.name}\`)
+    } catch (error) {
+      failed++
+      console.error(\`❌ Failed to register external plugin \${plugin.name}:\`, error)
+    }
+  }
+  
+  console.log(\`📊 External plugin registration complete: \${registered} registered, \${failed} failed\`)
+}
+
+// Export plugin names for easy access
+export const pluginNames = discoveredPlugins.map(p => p.name)
+
+console.log('🔍 Auto-discovered ${plugins.length} external plugins' + (pluginNames.length > 0 ? ': ' + pluginNames.join(', ') : ''))
+`
+
+    writeFileSync(this.registrationFilePath, fileContent)
+    console.log(`✅ Generated plugin registry with ${plugins.length} plugins`)
+  }
+
+  /**
+   * Generate a valid import name from plugin name
+   */
+  private getImportName(pluginName: string): string {
+    // Convert kebab-case to PascalCase for import names
+    return pluginName
+      .split('-')
+      .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+      .join('') + 'Plugin'
+  }
+
+  /**
+   * Restore the original registration file from backup
+   */
+  restoreOriginalFile(): void {
+    if (existsSync(this.backupFilePath)) {
+      const backupContent = readFileSync(this.backupFilePath, 'utf-8')
+      writeFileSync(this.registrationFilePath, backupContent)
+      unlinkSync(this.backupFilePath)
+      console.log('🔄 Restored original auto-registry.ts')
+    } else {
+      // If no backup exists, remove the generated file
+      if (existsSync(this.registrationFilePath)) {
+        unlinkSync(this.registrationFilePath)
+        console.log('🗑️ Removed auto-generated registry file')
+      }
+    }
+  }
+
+  /**
+   * Check if the current registration file is auto-generated
+   */
+  isAutoGenerated(): boolean {
+    if (!existsSync(this.registrationFilePath)) {
+      return false
+    }
+
+    const content = readFileSync(this.registrationFilePath, 'utf-8')
+    return content.includes('// 🔥 Auto-generated FluxStack Plugins Registry')
+  }
+
+  /**
+   * Pre-build hook: Generate registration file
+   */
+  async preBuild(): Promise<PluginInfo[]> {
+    console.log('🚀 [PRE-BUILD] Generating FluxStack Plugins registry...')
+    
+    const plugins = this.discoverPlugins()
+    
+    if (plugins.length === 0) {
+      console.log('⚠️ No FluxStack Plugins found to register')
+      return []
+    }
+
+    this.generateRegistrationFile(plugins)
+    
+    return plugins
+  }
+
+  /**
+   * Post-build hook: Clean up generated file (optional)
+   */
+  async postBuild(keepGenerated: boolean = false): Promise<void> {
+    console.log('🧹 [POST-BUILD] Cleaning up FluxStack Plugins registry...')
+    
+    if (keepGenerated) {
+      console.log('📝 Keeping auto-generated plugin registry for production')
+      // Remove backup since we're keeping the generated version
+      if (existsSync(this.backupFilePath)) {
+        unlinkSync(this.backupFilePath)
+      }
+    } else {
+      this.restoreOriginalFile()
+    }
+  }
+
+  /**
+   * Development mode: Check if registration needs update
+   */
+  needsUpdate(): boolean {
+    if (!this.isAutoGenerated()) {
+      return false // No auto-generated file, don't touch manual setup
+    }
+
+    const plugins = this.discoverPlugins()
+    const currentContent = readFileSync(this.registrationFilePath, 'utf-8')
+    
+    // Check if all discovered plugins are in the current file
+    for (const plugin of plugins) {
+      const importName = this.getImportName(plugin.pluginName)
+      if (!currentContent.includes(importName)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Development mode: Update registration if needed
+   */
+  updateIfNeeded(): void {
+    if (this.needsUpdate()) {
+      console.log('🔄 FluxStack Plugins changed, updating registry...')
+      const plugins = this.discoverPlugins()
+      this.generateRegistrationFile(plugins)
+    }
+  }
+}
+
+// Export singleton instance
+export const fluxPluginsGenerator = new FluxPluginsGenerator()

package/core/build/index.ts

@@ -1,4 +1,4 @@
-import { copyFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
+import { copyFileSync, writeFileSync, existsSync, mkdirSync, readFileSync } from "fs"
 import { join } from "path"
 import type { FluxStackConfig } from "../config"
 import type { BuildResult, BuildManifest } from "../types/build"
@@ -18,13 +18,11 @@ export class FluxStackBuilder {
       target: config.build.target,
       outDir: config.build.outDir,
       sourceMaps: config.build.sourceMaps,
-      minify: config.build.minify,
       external: config.build.external
     })
     
     // Initialize optimizer with configuration
     this.optimizer = new Optimizer({
-      minify: config.build.minify,
       treeshake: config.build.treeshake,
       compress: config.build.compress || false,
       removeUnusedCSS: config.build.removeUnusedCSS || false,
@@ -37,7 +35,6 @@ export class FluxStackBuilder {
     return await this.bundler.bundleClient({
       env: {
         VITE_BUILD_OUTDIR: this.config.client.build.outDir,
-        VITE_BUILD_MINIFY: this.config.client.build.minify.toString(),
         VITE_BUILD_SOURCEMAPS: this.config.client.build.sourceMaps.toString()
       }
     })
@@ -180,9 +177,15 @@ coverage
     console.log(`  - target path: ${distEnvPath}`)
     
     if (existsSync(envPath)) {
-      console.log(`📄 Copying .env file...`)
-      copyFileSync(envPath, distEnvPath)
-      console.log("📄 Environment file copied to dist/")
+      console.log(`📄 Copying .env file and setting production mode...`)
+      // Read .env content
+      let envContent = readFileSync(envPath, 'utf-8')
+      // Replace development with production
+      envContent = envContent.replace(/NODE_ENV=development/g, 'NODE_ENV=production')
+      envContent = envContent.replace(/VITE_NODE_ENV=development/g, 'VITE_NODE_ENV=production')
+      // Write to dist
+      writeFileSync(distEnvPath, envContent)
+      console.log("📄 Environment file copied to dist/ (NODE_ENV=production)")
     } else if (existsSync(envExamplePath)) {
       console.log(`📄 Copying .env.example file...`)
       copyFileSync(envExamplePath, distEnvPath)
@@ -229,6 +232,7 @@ MONITORING_ENABLED=true
     console.log("✅ Docker files created in dist/")
   }
 
+
   async build(): Promise<BuildResult> {
     console.log("⚡ FluxStack Framework - Building...")