create-fluxstack 1.8.3 → 1.10.1

package/core/build/bundler.ts

@@ -79,34 +79,18 @@ export class Bundler {
     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()
-
-      // 🔌 PRE-BUILD: Auto-generate FluxStack Plugins registration
-      const pluginsGeneratorModule = await import('./flux-plugins-generator')
-      const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
-      const discoveredPlugins = await fluxPluginsGenerator.preBuild()
-      
+      // Run pre-build steps
+      liveComponentsGenerator = await this.runPreBuildSteps()
+
       // Ensure output directory exists
-      if (!existsSync(this.config.outDir)) {
-        mkdirSync(this.config.outDir, { recursive: true })
-      }
+      this.ensureOutputDirectory()
 
-      const external = [
-        "@tailwindcss/vite",
-        "tailwindcss", 
-        "lightningcss",
-        "vite",
-        "@vitejs/plugin-react",
-        ...(this.config.external || []),
-        ...(options.external || [])
-      ]
+      // Get external dependencies
+      const external = this.getExternalDependencies(options)
 
       const buildArgs = [
-        "bun", "build", 
-        entryPoint, 
+        "bun", "build",
+        entryPoint,
         "--outdir", this.config.outDir,
         "--target", this.config.target,
         ...external.flatMap(ext => ["--external", ext])
@@ -132,20 +116,12 @@ 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) {
         buildLogger.success(`Server bundle completed in ${buildLogger.formatDuration(duration)}`)
-        
-        // 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)
-        
+
+        // Run post-build cleanup
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+
         return {
           success: true,
           duration,
@@ -154,15 +130,10 @@ export class Bundler {
         }
       } else {
         buildLogger.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)
-        
+
+        // Run post-build cleanup
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+
         const stderr = await new Response(buildProcess.stderr).text()
         return {
           success: false,
@@ -172,21 +143,142 @@ export class Bundler {
       }
     } catch (error) {
       const duration = Date.now() - startTime
-      
+
+      // 🧹 CLEANUP: Restore original files on error
+      try {
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+      } catch (cleanupError) {
+        buildLogger.warn(`Failed to cleanup generated files: ${cleanupError}`)
+      }
+
+      return {
+        success: false,
+        duration,
+        error: error instanceof Error ? error.message : "Unknown error"
+      }
+    }
+  }
+
+  async compileToExecutable(entryPoint: string, outputName: string = "app", options: BundleOptions = {}): Promise<BundleResult> {
+    buildLogger.section('Executable Build', '📦')
+
+    const startTime = Date.now()
+    let liveComponentsGenerator: any = null
+
+    try {
+      // Run pre-build steps
+      liveComponentsGenerator = await this.runPreBuildSteps()
+
+      // Ensure output directory exists
+      this.ensureOutputDirectory()
+
+      const outputPath = join(this.config.outDir, outputName)
+
+      // Get external dependencies
+      const external = this.getExternalDependencies(options)
+
+      // Use target from options or fall back to config
+      const target = options.target || this.config.target
+
+      const buildArgs = [
+        "bun", "build",
+        entryPoint,
+        "--compile",
+        "--outfile", outputPath,
+        "--target", target,
+        ...external.flatMap(ext => ["--external", ext])
+      ]
+
+      if (this.config.sourceMaps) {
+        buildArgs.push("--sourcemap")
+      }
+
+      if (this.config.minify) {
+        buildArgs.push("--minify")
+      }
+
+      // Add Windows-specific options if provided
+      if (options.executable?.windows) {
+        const winOpts = options.executable.windows
+        if (winOpts.hideConsole) {
+          buildArgs.push("--windows-hide-console")
+        }
+        if (winOpts.icon) {
+          buildArgs.push("--windows-icon", winOpts.icon)
+        }
+        if (winOpts.title) {
+          buildArgs.push("--windows-title", winOpts.title)
+        }
+        if (winOpts.publisher) {
+          buildArgs.push("--windows-publisher", winOpts.publisher)
+        }
+        if (winOpts.version) {
+          buildArgs.push("--windows-version", winOpts.version)
+        }
+        if (winOpts.description) {
+          buildArgs.push("--windows-description", winOpts.description)
+        }
+        if (winOpts.copyright) {
+          buildArgs.push("--windows-copyright", winOpts.copyright)
+        }
+      }
+
+      // Add custom build arguments if provided
+      if (options.executable?.customArgs) {
+        buildArgs.push(...options.executable.customArgs)
+      }
+
+      buildLogger.step(`Compiling ${entryPoint} to ${outputPath}...`)
+
+      const buildProcess = spawn({
+        cmd: buildArgs,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: {
+          ...process.env,
+          NODE_ENV: 'production',
+          ...options.env
+        }
+      })
+
+      const exitCode = await buildProcess.exited
+      const duration = Date.now() - startTime
+
+      if (exitCode === 0) {
+        buildLogger.success(`Executable compiled in ${buildLogger.formatDuration(duration)}`)
+
+        // Run post-build cleanup
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+
+        return {
+          success: true,
+          duration,
+          outputPath,
+          entryPoint: outputPath
+        }
+      } else {
+        buildLogger.error("Executable compilation failed")
+
+        // Run post-build cleanup
+        await this.runPostBuildCleanup(liveComponentsGenerator)
+
+        const stderr = await new Response(buildProcess.stderr).text()
+        return {
+          success: false,
+          duration,
+          error: stderr || "Executable compilation failed"
+        }
+      }
+    } 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)
+        await this.runPostBuildCleanup(liveComponentsGenerator)
       } catch (cleanupError) {
         buildLogger.warn(`Failed to cleanup generated files: ${cleanupError}`)
       }
-      
+
       return {
         success: false,
         duration,
@@ -195,6 +287,61 @@ export class Bundler {
     }
   }
 
+  /**
+   * Get list of external dependencies that should not be bundled
+   */
+  private getExternalDependencies(options: BundleOptions = {}): string[] {
+    return [
+      "@tailwindcss/vite",
+      "tailwindcss",
+      "lightningcss",
+      "vite",
+      "@vitejs/plugin-react",
+      "rollup",
+      ...(this.config.external || []),
+      ...(options.external || [])
+    ]
+  }
+
+  /**
+   * Ensure output directory exists
+   */
+  private ensureOutputDirectory(): void {
+    if (!existsSync(this.config.outDir)) {
+      mkdirSync(this.config.outDir, { recursive: true })
+    }
+  }
+
+  /**
+   * Run pre-build steps (Live Components and Plugins generation)
+   */
+  private async runPreBuildSteps(): Promise<any> {
+    // 🚀 PRE-BUILD: Auto-generate Live Components registration
+    const generatorModule = await import('./live-components-generator')
+    const liveComponentsGenerator = generatorModule.liveComponentsGenerator
+    await liveComponentsGenerator.preBuild()
+
+    // 🔌 PRE-BUILD: Auto-generate FluxStack Plugins registration
+    const pluginsGeneratorModule = await import('./flux-plugins-generator')
+    const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
+    await fluxPluginsGenerator.preBuild()
+
+    return liveComponentsGenerator
+  }
+
+  /**
+   * Run post-build cleanup
+   */
+  private async runPostBuildCleanup(liveComponentsGenerator: any): Promise<void> {
+    if (liveComponentsGenerator) {
+      await liveComponentsGenerator.postBuild(false)
+    }
+
+    const pluginsGeneratorModule = await import('./flux-plugins-generator')
+    const fluxPluginsGenerator = pluginsGeneratorModule.fluxPluginsGenerator
+    await fluxPluginsGenerator.postBuild(false)
+  }
+
   private async getClientAssets(): Promise<string[]> {
     // This would analyze the build output to get asset information
     // For now, return empty array - can be enhanced later

package/core/build/index.ts

@@ -1,4 +1,4 @@
-import { copyFileSync, writeFileSync, existsSync, mkdirSync, readFileSync } from "fs"
+import { copyFileSync, writeFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "fs"
 import { join } from "path"
 import type { FluxStackConfig } from "../config"
 import type { BuildResult, BuildManifest } from "../types/build"
@@ -6,14 +6,18 @@ import { Bundler } from "./bundler"
 import { Optimizer } from "./optimizer"
 import { FLUXSTACK_VERSION } from "../utils/version"
 import { buildLogger } from "../utils/build-logger"
+import type { PluginRegistry } from "../plugins/registry"
+import type { BuildContext, BuildAssetContext, BuildErrorContext } from "../plugins/types"
 
 export class FluxStackBuilder {
   private config: FluxStackConfig
   private bundler: Bundler
   private optimizer: Optimizer
+  private pluginRegistry?: PluginRegistry
 
-  constructor(config: FluxStackConfig) {
+  constructor(config: FluxStackConfig, pluginRegistry?: PluginRegistry) {
     this.config = config
+    this.pluginRegistry = pluginRegistry
 
     // Initialize bundler with configuration
     this.bundler = new Bundler({
@@ -47,6 +51,12 @@ export class FluxStackBuilder {
     return await this.bundler.bundleServer("app/server/index.ts")
   }
 
+  async buildExecutable(outputName?: string, options?: import("../types/build").BundleOptions) {
+    // Use app name from config as default, fallback to "FluxStack"
+    const name = outputName || this.config.app.name || "FluxStack"
+    return await this.bundler.compileToExecutable("app/server/index.ts", name, options)
+  }
+
   async createDockerFiles() {
     buildLogger.section('Docker Configuration', '🐳')
 
@@ -234,7 +244,17 @@ MONITORING_ENABLED=true
 
     const startTime = Date.now()
 
+    const buildContext: BuildContext = {
+      target: this.config.build.target,
+      outDir: this.config.build.outDir,
+      mode: (this.config.build.mode || 'production') as 'development' | 'production',
+      config: this.config
+    }
+
     try {
+      // Execute onBeforeBuild hooks
+      await this.executePluginHooks('onBeforeBuild', buildContext)
+
       // Pre-build checks (version sync, etc.)
       await this.runPreBuildChecks()
 
@@ -246,6 +266,9 @@ MONITORING_ENABLED=true
         await this.clean()
       }
 
+      // Execute onBuild hooks
+      await this.executePluginHooks('onBuild', buildContext)
+
       // Build client and server
       const clientResult = await this.buildClient()
       const serverResult = await this.buildServer()
@@ -253,6 +276,16 @@ MONITORING_ENABLED=true
       // Check if builds were successful
       if (!clientResult.success || !serverResult.success) {
         const errorMessage = clientResult.error || serverResult.error || "Build failed"
+
+        // Execute onBuildError hooks
+        const buildErrorContext: BuildErrorContext = {
+          error: new Error(errorMessage),
+          file: undefined,
+          line: undefined,
+          column: undefined
+        }
+        await this.executePluginHooks('onBuildError', buildErrorContext)
+
         return {
           success: false,
           duration: Date.now() - startTime,
@@ -273,6 +306,9 @@ MONITORING_ENABLED=true
         }
       }
 
+      // Process assets and execute onBuildAsset hooks
+      await this.processAssets(this.config.build.outDir)
+
       // Optimize build if enabled
       let optimizationResult
       if (this.config.build.optimize) {
@@ -287,6 +323,9 @@ MONITORING_ENABLED=true
 
       const duration = Date.now() - startTime
 
+      // Execute onBuildComplete hooks
+      await this.executePluginHooks('onBuildComplete', buildContext)
+
       // Print build summary
       buildLogger.summary('Build Completed Successfully', [
         { label: 'Build Time', value: buildLogger.formatDuration(duration), highlight: true },
@@ -319,6 +358,15 @@ MONITORING_ENABLED=true
 
       buildLogger.error(`Build failed: ${errorMessage}`)
 
+      // Execute onBuildError hooks
+      const buildErrorContext: BuildErrorContext = {
+        error: error instanceof Error ? error : new Error(errorMessage),
+        file: undefined,
+        line: undefined,
+        column: undefined
+      }
+      await this.executePluginHooks('onBuildError', buildErrorContext)
+
       return {
         success: false,
         duration,
@@ -409,4 +457,80 @@ MONITORING_ENABLED=true
       }
     }
   }
+
+  /**
+   * Execute plugin hooks for build process
+   */
+  private async executePluginHooks(hookName: string, context: any): Promise<void> {
+    if (!this.pluginRegistry) return
+
+    const loadOrder = this.pluginRegistry.getLoadOrder()
+
+    for (const pluginName of loadOrder) {
+      const plugin = this.pluginRegistry.get(pluginName)
+      if (!plugin) continue
+
+      const hookFn = (plugin as any)[hookName]
+      if (typeof hookFn === 'function') {
+        try {
+          await hookFn(context)
+        } catch (error) {
+          buildLogger.error(`Plugin '${pluginName}' ${hookName} hook failed: ${error instanceof Error ? error.message : String(error)}`)
+        }
+      }
+    }
+  }
+
+  /**
+   * Process build assets and execute onBuildAsset hooks
+   */
+  private async processAssets(outDir: string): Promise<void> {
+    if (!this.pluginRegistry) return
+    if (!existsSync(outDir)) return
+
+    try {
+      const processDirectory = async (dir: string) => {
+        const entries = readdirSync(dir, { withFileTypes: true })
+
+        for (const entry of entries) {
+          const fullPath = join(dir, entry.name)
+
+          if (entry.isDirectory()) {
+            await processDirectory(fullPath)
+          } else if (entry.isFile()) {
+            const stat = statSync(fullPath)
+            const assetType = this.getAssetType(entry.name)
+
+            const assetContext: BuildAssetContext = {
+              assetPath: fullPath,
+              assetType,
+              size: stat.size,
+              content: undefined // Could read file if plugins need it
+            }
+
+            await this.executePluginHooks('onBuildAsset', assetContext)
+          }
+        }
+      }
+
+      await processDirectory(outDir)
+    } catch (error) {
+      buildLogger.warn(`Failed to process assets: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /**
+   * Determine asset type from file extension
+   */
+  private getAssetType(filename: string): 'js' | 'css' | 'html' | 'image' | 'font' | 'other' {
+    const ext = filename.split('.').pop()?.toLowerCase()
+
+    if (ext === 'js' || ext === 'mjs' || ext === 'cjs') return 'js'
+    if (ext === 'css') return 'css'
+    if (ext === 'html' || ext === 'htm') return 'html'
+    if (ext === 'png' || ext === 'jpg' || ext === 'jpeg' || ext === 'gif' || ext === 'svg' || ext === 'webp') return 'image'
+    if (ext === 'woff' || ext === 'woff2' || ext === 'ttf' || ext === 'eot' || ext === 'otf') return 'font'
+
+    return 'other'
+  }
 }

package/core/build/live-components-generator.ts

@@ -16,6 +16,9 @@ export class LiveComponentsGenerator {
   private componentsPath: string
   private registrationFilePath: string
   private backupFilePath: string
+  private entryPointPath: string
+  private entryPointBackupPath: string
+  private readonly importLine = 'import "@/core/server/live/auto-generated-components"'
 
   constructor() {
     // Scan components from app/ directory (user code)
@@ -24,6 +27,10 @@ export class LiveComponentsGenerator {
     // Generate registration file in core/ directory (framework code - protected from user modifications)
     this.registrationFilePath = join(process.cwd(), 'core', 'server', 'live', 'auto-generated-components.ts')
     this.backupFilePath = join(process.cwd(), 'core', 'server', 'live', 'auto-generated-components.backup.ts')
+
+    // Entry point for import injection
+    this.entryPointPath = join(process.cwd(), 'app', 'server', 'index.ts')
+    this.entryPointBackupPath = join(process.cwd(), 'app', 'server', 'index.ts.backup')
   }
 
   /**
@@ -147,6 +154,60 @@ ${components.map(comp => `  ${comp.className}`).join(',\n')}
     }
   }
 
+  /**
+   * Inject the auto-generated components import into the entry point
+   */
+  injectImportIntoEntryPoint(): void {
+    if (!existsSync(this.entryPointPath)) {
+      buildLogger.warn('Entry point not found, skipping import injection')
+      return
+    }
+
+    const content = readFileSync(this.entryPointPath, 'utf-8')
+
+    // Check if import already exists
+    if (content.includes(this.importLine)) {
+      return // Already injected
+    }
+
+    // Backup original file
+    writeFileSync(this.entryPointBackupPath, content)
+
+    // Find the best place to inject (after other imports)
+    const lines = content.split('\n')
+    let lastImportIndex = -1
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim()
+      if (line.startsWith('import ') || line.startsWith('import{')) {
+        lastImportIndex = i
+      }
+    }
+
+    // Inject after the last import
+    if (lastImportIndex >= 0) {
+      lines.splice(lastImportIndex + 1, 0, this.importLine)
+    } else {
+      // No imports found, add at the beginning
+      lines.unshift(this.importLine)
+    }
+
+    writeFileSync(this.entryPointPath, lines.join('\n'))
+    buildLogger.step('Injected auto-generated components import into entry point')
+  }
+
+  /**
+   * Remove the injected import and restore original entry point
+   */
+  removeInjectedImport(): void {
+    if (existsSync(this.entryPointBackupPath)) {
+      const backupContent = readFileSync(this.entryPointBackupPath, 'utf-8')
+      writeFileSync(this.entryPointPath, backupContent)
+      unlinkSync(this.entryPointBackupPath)
+      buildLogger.step('Restored original entry point')
+    }
+  }
+
   /**
    * Check if the current registration file is auto-generated
    */
@@ -190,11 +251,14 @@ ${components.map(comp => `  ${comp.className}`).join(',\n')}
 
     this.generateRegistrationFile(components)
 
+    // Inject import into entry point for build
+    this.injectImportIntoEntryPoint()
+
     return components
   }
 
   /**
-   * Post-build hook: Clean up backup file
+   * Post-build hook: Clean up backup file and restore entry point
    * Note: Since the generated file is now in core/, we always keep it (it's bundled into production)
    */
   async postBuild(keepGenerated: boolean = true): Promise<void> {
@@ -206,6 +270,9 @@ ${components.map(comp => `  ${comp.className}`).join(',\n')}
       unlinkSync(this.backupFilePath)
       buildLogger.step('Removed backup file')
     }
+
+    // Restore original entry point (remove injected import)
+    this.removeInjectedImport()
   }
 
   /**

package/core/cli/generators/plugin.ts

@@ -131,7 +131,7 @@ export default {{camelName}}Config
                 },
                 {
                     path: 'plugins/{{name}}/index.ts',
-                    content: `import type { FluxStackPlugin, PluginContext } from '@/core/types/plugin'
+                    content: `import type { ErrorContext, FluxStack, PluginContext, RequestContext, ResponseContext } from "@/core/plugins/types"
 // ✅ Plugin imports its own configuration
 import { {{camelName}}Config } from './config'
 
@@ -139,7 +139,7 @@ import { {{camelName}}Config } from './config'
  * {{pascalName}} Plugin
  * {{description}}
  */
-export class {{pascalName}}Plugin implements FluxStackPlugin {
+export class {{pascalName}}Plugin implements FluxStack.Plugin {
   name = '{{name}}'
   version = '1.0.0'
 
@@ -173,7 +173,7 @@ export class {{pascalName}}Plugin implements FluxStackPlugin {
   /**
    * Request hook - called on each request
    */
-  async onRequest?(context: PluginContext, request: Request): Promise<void> {
+  async onRequest?(context: RequestContext): Promise<void> {
     if (!{{camelName}}Config.enabled) return
 
     // Add request processing logic
@@ -182,7 +182,7 @@ export class {{pascalName}}Plugin implements FluxStackPlugin {
   /**
    * Response hook - called on each response
    */
-  async onResponse?(context: PluginContext, response: Response): Promise<void> {
+  async onResponse?(context: ResponseContext): Promise<void> {
     if (!{{camelName}}Config.enabled) return
 
     // Add response processing logic
@@ -191,8 +191,8 @@ export class {{pascalName}}Plugin implements FluxStackPlugin {
   /**
    * Error hook - called when errors occur
    */
-  async onError?(context: PluginContext, error: Error): Promise<void> {
-    console.error(\`[{{name}}] Error:\`, error)
+  async onError?(context: ErrorContext): Promise<void> {
+    console.error(\`[{{name}}] Error:\`, context.error)
 
     // Add error handling logic
   }