create-fluxstack 1.9.1 → 1.10.1

package/core/plugins/built-in/vite/index.ts

@@ -1,22 +1,25 @@
 import type { FluxStack, PluginContext, RequestContext } from "@/core/plugins/types"
-import { createServer, type ViteDevServer } from 'vite'
 import { FLUXSTACK_VERSION } from "@/core/utils/version"
 import { clientConfig } from '@/config/client.config'
+import { isDevelopment } from "@/core/utils/helpers"
+import { join } from "path"
+import { statSync, existsSync } from "fs"
 
 type Plugin = FluxStack.Plugin
 
-let viteServer: ViteDevServer | null = null
-
 // Default configuration values (uses clientConfig from /config)
 const DEFAULTS = {
   enabled: true,
   port: clientConfig.vite.port,
-  host: "localhost",
+  host: clientConfig.vite.host,
   checkInterval: 2000,
   maxRetries: 10,
   timeout: 5000,
   proxyPaths: [] as string[],
-  excludePaths: [] as string[]
+  excludePaths: [] as string[],
+  // Static file serving (production) - uses clientConfig
+  publicDir: clientConfig.build.outDir,
+  indexFile: "index.html"
 }
 
 /**
@@ -50,90 +53,94 @@ export const vitePlugin: Plugin = {
       return
     }
 
-    const vitePort = DEFAULTS.port || clientConfig.vite.port || 5173
-    const viteHost = DEFAULTS.host || "localhost"
+    // Production mode: setup static file serving
+    if (!isDevelopment()) {
+      context.logger.debug("Production mode: static file serving enabled", {
+        publicDir: DEFAULTS.publicDir
+      })
 
-    // Import group logger utilities
-    const { startGroup, endGroup, logInGroup } = await import('@/core/utils/logger/group-logger')
+      // Static fallback handler (runs last)
+      const staticFallback = (c: any) => {
+        const req = c.request
+        if (!req) return
 
-    try {
-      // Start Vite dev server programmatically (silently)
-      viteServer = await createServer({
-        configFile: './vite.config.ts',
-        // Don't override root - let vite.config.ts handle it
-        server: {
-          port: vitePort,
-          host: viteHost,
-          strictPort: true
-        },
-        logLevel: 'silent' // Suppress all Vite logs
-      })
+        const url = new URL(req.url)
+        let pathname = decodeURIComponent(url.pathname)
 
-      await viteServer.listen()
+        // Determine base directory using path discovery
+        let baseDir: string
 
-      context.logger.debug(`Vite server started on ${viteHost}:${vitePort} (internal proxy)`)
-      context.logger.debug('Hot reload coordination active')
+        // Production: try paths in order of preference
+        if (existsSync('client')) {
+          // Found client/ in current directory (running from dist/)
+          baseDir = 'client'
+        } else if (existsSync('dist/client')) {
+          // Found dist/client/ (running from project root)
+          baseDir = 'dist/client'
+        } else {
+          // Fallback to configured path
+          baseDir = DEFAULTS.publicDir
+        }
 
-        // Store Vite config in context for later use
-        ; (context as any).viteConfig = {
-          port: vitePort,
-          host: viteHost,
-          server: viteServer
+        // Root or empty path → index.html
+        if (pathname === '/' || pathname === '') {
+          pathname = `/${DEFAULTS.indexFile}`
         }
 
-      // Setup cleanup on process exit
-      const cleanup = async () => {
-        if (viteServer) {
-          context.logger.debug('🛑 Stopping Vite server...')
-          await viteServer.close()
-          viteServer = null
+        const filePath = join(baseDir, pathname)
+
+        try {
+          const info = statSync(filePath)
+
+          // File exists → serve it
+          if (info.isFile()) {
+            return Bun.file(filePath)
+          }
+        } catch (_) {
+          // File not found → continue
         }
-      }
 
-      process.on('SIGINT', cleanup)
-      process.on('SIGTERM', cleanup)
-      process.on('exit', cleanup)
-
-    } catch (error) {
-      // Check if error is related to port already in use
-      const errorMessage = error instanceof Error ? error.message : String(error)
-      const isPortInUse = errorMessage.includes('EADDRINUSE') ||
-                         errorMessage.includes('address already in use') ||
-                         errorMessage.includes('Port') && errorMessage.includes('is in use')
-
-      if (isPortInUse) {
-        endGroup()
-        console.log('') // Separator line
-        context.logger.error(`❌ Failed to start Vite: Port ${vitePort} is already in use`)
-        context.logger.info(`💡 Try one of these solutions:`)
-        context.logger.info(`   1. Stop the process using port ${vitePort}`)
-        context.logger.info(`   2. Change VITE_PORT in your .env file`)
-        context.logger.info(`   3. Kill the process: ${process.platform === 'win32' ? `netstat -ano | findstr :${vitePort}` : `lsof -ti:${vitePort} | xargs kill -9`}`)
-        process.exit(1)
-      } else {
-        context.logger.error('❌ Failed to start Vite server:', errorMessage)
-        context.logger.debug('Full error:', error)
-        context.logger.debug('⚠️ Falling back to monitoring mode...')
-
-        // Fallback to monitoring if programmatic start fails
-        ; (context as any).viteConfig = {
-          port: vitePort,
-          host: viteHost
+        // SPA fallback: serve index.html for non-file routes
+        const indexPath = join(baseDir, DEFAULTS.indexFile)
+        try {
+          statSync(indexPath) // Ensure index exists
+          return Bun.file(indexPath)
+        } catch (_) {
+          // Index not found → let request continue (404)
         }
-        monitorVite(context, viteHost, vitePort)
       }
+
+      // Register as catch-all fallback (runs after all other routes)
+      context.app.all('*', staticFallback)
+      return
     }
+
+    // Development mode: import and setup Vite dev server
+    const { setupViteDev } = await import('./vite-dev')
+    await setupViteDev(context)
   },
 
   onServerStart: async (context: PluginContext) => {
-    const viteConfig = (context as any).viteConfig
+    if (!DEFAULTS.enabled) return
+
+    if (!isDevelopment()) {
+      context.logger.debug(`Static files ready`, {
+        publicDir: DEFAULTS.publicDir,
+        indexFile: DEFAULTS.indexFile
+      })
+      return
+    }
 
-    if (DEFAULTS.enabled && viteConfig) {
+    const viteConfig = (context as any).viteConfig
+    if (viteConfig) {
       context.logger.debug(`Vite integration active - monitoring ${viteConfig.host}:${viteConfig.port}`)
     }
   },
 
   onBeforeRoute: async (requestContext: RequestContext) => {
+    // Production mode: static serving handled by catch-all route in setup
+    if (!isDevelopment()) return
+
     // Skip API routes and swagger - let them be handled by backend
     if (requestContext.path.startsWith("/api") || requestContext.path.startsWith("/swagger")) {
       return
@@ -175,7 +182,6 @@ export const vitePlugin: Plugin = {
       } catch (viteError) {
         // If Vite fails, let the request continue to normal routing (will become 404)
         // Only log if explicitly enabled for debugging
-        const { clientConfig } = await import('@/config/client.config')
         if (clientConfig.vite.enableLogging) {
           console.warn(`Vite proxy error: ${viteError}`)
         }
@@ -214,7 +220,6 @@ export const vitePlugin: Plugin = {
     } catch (viteError) {
       // If Vite fails, let the request continue to normal routing (will become 404)
       // Only log if explicitly enabled for debugging
-      const { clientConfig } = await import('@/config/client.config')
       if (clientConfig.vite.enableLogging) {
         console.warn(`Vite proxy error: ${viteError}`)
       }
@@ -222,122 +227,5 @@ export const vitePlugin: Plugin = {
   }
 }
 
-// Monitor Vite server status with automatic port detection
-async function monitorVite(
-  context: PluginContext,
-  host: string,
-  initialPort: number
-) {
-  let retries = 0
-  let isConnected = false
-  let actualPort = initialPort
-  let portDetected = false
-
-  const checkVite = async () => {
-    try {
-      // If we haven't found the correct port yet, try to detect it
-      if (!portDetected) {
-        const detectedPort = await detectVitePort(host, initialPort)
-        if (detectedPort !== null) {
-          actualPort = detectedPort
-          portDetected = true
-          // Update the context with the detected port
-          if ((context as any).viteConfig) {
-            ; (context as any).viteConfig.port = actualPort
-          }
-        }
-      }
-
-      const isRunning = await checkViteRunning(host, actualPort, DEFAULTS.timeout)
-
-      if (isRunning && !isConnected) {
-        isConnected = true
-        retries = 0
-        if (actualPort !== initialPort) {
-          context.logger.debug(`✓ Vite server detected on ${host}:${actualPort} (auto-detected from port ${initialPort})`)
-        } else {
-          context.logger.debug(`✓ Vite server detected on ${host}:${actualPort}`)
-        }
-        context.logger.debug("Hot reload coordination active")
-      } else if (!isRunning && isConnected) {
-        isConnected = false
-        context.logger.warn(`✗ Vite server disconnected from ${host}:${actualPort}`)
-        // Reset port detection when disconnected
-        portDetected = false
-        actualPort = initialPort
-      } else if (!isRunning) {
-        retries++
-        if (retries <= DEFAULTS.maxRetries) {
-          if (portDetected) {
-            context.logger.debug(`Waiting for Vite server on ${host}:${actualPort}... (${retries}/${DEFAULTS.maxRetries})`)
-          } else {
-            context.logger.debug(`Detecting Vite server port... (${retries}/${DEFAULTS.maxRetries})`)
-          }
-        } else if (retries === DEFAULTS.maxRetries + 1) {
-          context.logger.warn(`Vite server not found after ${DEFAULTS.maxRetries} attempts. Development features may be limited.`)
-        }
-      }
-    } catch (error) {
-      if (isConnected) {
-        context.logger.error('Error checking Vite server status', { error })
-      }
-    }
-
-    // Continue monitoring
-    setTimeout(checkVite, DEFAULTS.checkInterval)
-  }
-
-  // Start monitoring after a brief delay
-  setTimeout(checkVite, 1000)
-}
-
-// Auto-detect Vite port by trying common ports
-async function detectVitePort(host: string, startPort: number): Promise<number | null> {
-  // Try the initial port first, then common alternatives
-  const portsToTry = [
-    startPort,
-    startPort + 1,
-    startPort + 2,
-    startPort + 3,
-    5174, // Common Vite alternative
-    5175,
-    5176,
-    3000, // Sometimes Vite might use this
-    4173  // Another common alternative
-  ]
-
-  for (const port of portsToTry) {
-    try {
-      const isRunning = await checkViteRunning(host, port, 1000)
-      if (isRunning) {
-        return port
-      }
-    } catch (error) {
-      // Continue trying other ports
-    }
-  }
-
-  return null
-}
-
-// Check if Vite is running
-async function checkViteRunning(host: string, port: number, timeout: number = 1000): Promise<boolean> {
-  try {
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), timeout)
-
-    const response = await fetch(`http://${host}:${port}`, {
-      signal: controller.signal,
-      method: 'HEAD' // Use HEAD to minimize data transfer
-    })
-
-    clearTimeout(timeoutId)
-    return response.status >= 200 && response.status < 500
-  } catch (error) {
-    return false
-  }
-}
-
-// Note: Proxy logic is now handled directly in the onBeforeRoute hook above
 
 export default vitePlugin

package/core/plugins/built-in/vite/vite-dev.ts

@@ -0,0 +1,88 @@
+import type { PluginContext } from "@/core/plugins/types"
+import { clientConfig } from '@/config/client.config'
+
+// Dynamic import type for vite
+type ViteDevServer = Awaited<ReturnType<typeof import('vite')['createServer']>>
+
+// Store vite server instance
+let viteServer: ViteDevServer | null = null
+
+// Default configuration values
+const DEFAULTS = {
+  port: clientConfig.vite.port,
+  host: clientConfig.vite.host
+}
+
+/**
+ * Setup Vite development server
+ * This file is only imported in development mode
+ */
+export async function setupViteDev(context: PluginContext): Promise<void> {
+  const vitePort = DEFAULTS.port || clientConfig.vite.port || 5173
+  const viteHost = DEFAULTS.host || "localhost"
+
+  // Import group logger utilities
+  const { endGroup } = await import('@/core/utils/logger/group-logger')
+
+  try {
+    // Dynamic import of vite
+    const { createServer } = await import('vite')
+
+    // Start Vite dev server programmatically (silently)
+    viteServer = await createServer({
+      configFile: './vite.config.ts',
+      server: {
+        port: vitePort,
+        host: viteHost,
+        strictPort: true
+      },
+      logLevel: 'silent'
+    })
+
+    await viteServer.listen()
+
+    context.logger.debug(`Vite server started on ${viteHost}:${vitePort} (internal proxy)`)
+    context.logger.debug('Hot reload coordination active')
+
+    // Store Vite config in context for later use
+    ;(context as any).viteConfig = {
+      port: vitePort,
+      host: viteHost,
+      server: viteServer
+    }
+
+    // Setup cleanup on process exit
+    const cleanup = async () => {
+      if (viteServer) {
+        context.logger.debug('🛑 Stopping Vite server...')
+        await viteServer.close()
+        viteServer = null
+      }
+    }
+
+    process.on('SIGINT', cleanup)
+    process.on('SIGTERM', cleanup)
+    process.on('exit', cleanup)
+
+  } catch (error) {
+    // Check if error is related to port already in use
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    const isPortInUse = errorMessage.includes('EADDRINUSE') ||
+      errorMessage.includes('address already in use') ||
+      errorMessage.includes('Port') && errorMessage.includes('is in use')
+
+    if (isPortInUse) {
+      endGroup()
+      console.log('') // Separator line
+      context.logger.error(`❌ Failed to start Vite: Port ${vitePort} is already in use`)
+      context.logger.info(`💡 Try one of these solutions:`)
+      context.logger.info(`   1. Stop the process using port ${vitePort}`)
+      context.logger.info(`   2. Change VITE_PORT in your .env file`)
+      context.logger.info(`   3. Kill the process: ${process.platform === 'win32' ? `netstat -ano | findstr :${vitePort}` : `lsof -ti:${vitePort} | xargs kill -9`}`)
+      process.exit(1)
+    } else {
+      context.logger.error('❌ Failed to start Vite server:', errorMessage)
+      context.logger.debug('Full error:', error)
+    }
+  }
+}

package/core/plugins/registry.ts

@@ -56,7 +56,7 @@ export class PluginRegistry {
     }
 
     this.plugins.set(plugin.name, plugin)
-    
+
     if (manifest) {
       this.manifests.set(plugin.name, manifest)
     }
@@ -74,12 +74,58 @@ export class PluginRegistry {
       version: plugin.version,
       dependencies: plugin.dependencies
     })
+
+    // Execute onPluginRegister hooks on all registered plugins
+    await this.executePluginRegisterHooks(plugin)
+  }
+
+  /**
+   * Execute onPluginRegister hooks on all plugins
+   */
+  private async executePluginRegisterHooks(registeredPlugin: FluxStackPlugin): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onPluginRegister && typeof plugin.onPluginRegister === 'function') {
+        try {
+          await plugin.onPluginRegister({
+            pluginName: registeredPlugin.name,
+            pluginVersion: registeredPlugin.version,
+            timestamp: Date.now(),
+            data: { plugin: registeredPlugin }
+          })
+        } catch (error) {
+          this.logger?.error(`Plugin '${plugin.name}' onPluginRegister hook failed`, {
+            error: error instanceof Error ? error.message : String(error)
+          })
+        }
+      }
+    }
+  }
+
+  /**
+   * Execute onPluginUnregister hooks on all plugins
+   */
+  private async executePluginUnregisterHooks(unregisteredPluginName: string, version?: string): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onPluginUnregister && typeof plugin.onPluginUnregister === 'function') {
+        try {
+          await plugin.onPluginUnregister({
+            pluginName: unregisteredPluginName,
+            pluginVersion: version,
+            timestamp: Date.now()
+          })
+        } catch (error) {
+          this.logger?.error(`Plugin '${plugin.name}' onPluginUnregister hook failed`, {
+            error: error instanceof Error ? error.message : String(error)
+          })
+        }
+      }
+    }
   }
 
   /**
    * Unregister a plugin from the registry
    */
-  unregister(name: string): void {
+  async unregister(name: string): Promise<void> {
     if (!this.plugins.has(name)) {
       throw new FluxStackError(
         `Plugin '${name}' is not registered`,
@@ -98,12 +144,18 @@ export class PluginRegistry {
       )
     }
 
+    const plugin = this.plugins.get(name)
+    const version = plugin?.version
+
     this.plugins.delete(name)
     this.manifests.delete(name)
     this.dependencies.delete(name)
     this.loadOrder = this.loadOrder.filter(pluginName => pluginName !== name)
 
     this.logger?.debug(`Plugin '${name}' unregistered successfully`)
+
+    // Execute onPluginUnregister hooks on all remaining plugins
+    await this.executePluginUnregisterHooks(name, version)
   }
 
   /**

package/core/plugins/types.ts

@@ -1,16 +1,35 @@
 import type { FluxStackConfig } from "@/core/config/schema"
 import type { Logger } from "@/core/utils/logger/index"
 
-export type PluginHook = 
+export type PluginHook =
+  // Lifecycle hooks
   | 'setup'
+  | 'onConfigLoad'
+  | 'onBeforeServerStart'
   | 'onServerStart'
+  | 'onAfterServerStart'
+  | 'onBeforeServerStop'
   | 'onServerStop'
+  // Request/Response pipeline hooks
   | 'onRequest'
   | 'onBeforeRoute'
+  | 'onAfterRoute'
+  | 'onBeforeResponse'
   | 'onResponse'
+  | 'onRequestValidation'
+  | 'onResponseTransform'
+  // Error handling hooks
   | 'onError'
+  // Build pipeline hooks
+  | 'onBeforeBuild'
   | 'onBuild'
+  | 'onBuildAsset'
   | 'onBuildComplete'
+  | 'onBuildError'
+  // Plugin system hooks
+  | 'onPluginRegister'
+  | 'onPluginUnregister'
+  | 'onPluginError'
 
 export type PluginPriority = 'highest' | 'high' | 'normal' | 'low' | 'lowest' | number
 
@@ -68,6 +87,49 @@ export interface BuildContext {
   config: FluxStackConfig
 }
 
+export interface ConfigLoadContext {
+  config: FluxStackConfig
+  envVars: Record<string, string | undefined>
+  configPath?: string
+}
+
+export interface RouteContext extends RequestContext {
+  route?: string
+  handler?: Function
+  params: Record<string, string>
+}
+
+export interface ValidationContext extends RequestContext {
+  errors: Array<{ field: string; message: string; code: string }>
+  isValid: boolean
+}
+
+export interface TransformContext extends ResponseContext {
+  transformed: boolean
+  originalResponse?: Response
+}
+
+export interface BuildAssetContext {
+  assetPath: string
+  assetType: 'js' | 'css' | 'html' | 'image' | 'font' | 'other'
+  size: number
+  content?: string | Buffer
+}
+
+export interface BuildErrorContext {
+  error: Error
+  file?: string
+  line?: number
+  column?: number
+}
+
+export interface PluginEventContext {
+  pluginName: string
+  pluginVersion?: string
+  timestamp: number
+  data?: any
+}
+
 export interface PluginConfigSchema {
   type: 'object'
   properties: Record<string, any>
@@ -85,17 +147,39 @@ export namespace FluxStack {
   priority?: number | PluginPriority
   category?: string
   tags?: string[]
-  
+
   // Lifecycle hooks
   setup?: (context: PluginContext) => void | Promise<void>
+  onConfigLoad?: (context: ConfigLoadContext) => void | Promise<void>
+  onBeforeServerStart?: (context: PluginContext) => void | Promise<void>
   onServerStart?: (context: PluginContext) => void | Promise<void>
+  onAfterServerStart?: (context: PluginContext) => void | Promise<void>
+  onBeforeServerStop?: (context: PluginContext) => void | Promise<void>
   onServerStop?: (context: PluginContext) => void | Promise<void>
+
+  // Request/Response pipeline hooks
   onRequest?: (context: RequestContext) => void | Promise<void>
   onBeforeRoute?: (context: RequestContext) => void | Promise<void>
+  onAfterRoute?: (context: RouteContext) => void | Promise<void>
+  onBeforeResponse?: (context: ResponseContext) => void | Promise<void>
   onResponse?: (context: ResponseContext) => void | Promise<void>
+  onRequestValidation?: (context: ValidationContext) => void | Promise<void>
+  onResponseTransform?: (context: TransformContext) => void | Promise<void>
+
+  // Error handling hooks
   onError?: (context: ErrorContext) => void | Promise<void>
+
+  // Build pipeline hooks
+  onBeforeBuild?: (context: BuildContext) => void | Promise<void>
   onBuild?: (context: BuildContext) => void | Promise<void>
+  onBuildAsset?: (context: BuildAssetContext) => void | Promise<void>
   onBuildComplete?: (context: BuildContext) => void | Promise<void>
+  onBuildError?: (context: BuildErrorContext) => void | Promise<void>
+
+  // Plugin system hooks
+  onPluginRegister?: (context: PluginEventContext) => void | Promise<void>
+  onPluginUnregister?: (context: PluginEventContext) => void | Promise<void>
+  onPluginError?: (context: PluginEventContext & { error: Error }) => void | Promise<void>
 
   // Configuration
   /**

package/core/server/index.ts

@@ -1,7 +1,6 @@
 // FluxStack framework exports
 export { FluxStackFramework } from "../framework/server"
-export { vitePlugin } from "../plugins/built-in/vite"
-export { staticPlugin } from "../plugins/built-in/static"
+export { vitePlugin, staticPlugin } from "../plugins/built-in"
 export { swaggerPlugin } from "../plugins/built-in/swagger"
 export { PluginRegistry } from "../plugins/registry"
 export * from "../types"

package/core/server/live/ComponentRegistry.ts

@@ -154,7 +154,11 @@ export class ComponentRegistry {
       const { startGroup, endGroup, logInGroup, groupSummary } = await import('@/core/utils/logger/group-logger')
 
       if (!fs.existsSync(componentsPath)) {
-        console.log(`⚠️ Components path not found: ${componentsPath}`)
+        // In production, components are already bundled - no need to auto-discover
+        const { appConfig } = await import('@/config/app.config')
+        if (appConfig.env !== 'production') {
+          console.log(`⚠️ Components path not found: ${componentsPath}`)
+        }
         return
       }
 
@@ -186,10 +190,8 @@ export class ComponentRegistry {
         }
       }
 
-      // Display components in a compact single line format
-      if (components.length > 0) {
-        console.log(`\nLive Components (${components.length}): ${components.join(', ')}\n`)
-      }
+      // Components are now displayed in the startup banner
+      // No need to log here to avoid duplication
     } catch (error) {
       console.error('❌ Auto-discovery failed:', error)
     }
@@ -729,6 +731,13 @@ export class ComponentRegistry {
     }
   }
 
+  // Get registered component names
+  getRegisteredComponentNames(): string[] {
+    const definitionNames = Array.from(this.definitions.keys())
+    const autoDiscoveredNames = Array.from(this.autoDiscoveredComponents.keys())
+    return [...new Set([...definitionNames, ...autoDiscoveredNames])]
+  }
+
   // Get component by ID
   getComponent(componentId: string): LiveComponent | undefined {
     return this.components.get(componentId)