create-fluxstack 1.0.21 → 1.1.0

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

@@ -12,7 +12,7 @@ export const vitePlugin: Plugin = {
   category: "development",
   tags: ["vite", "development", "hot-reload"],
   dependencies: [], // No dependencies
-  
+
   configSchema: {
     type: "object",
     properties: {
@@ -51,14 +51,14 @@ export const vitePlugin: Plugin = {
         description: "Paths to proxy to Vite (defaults to all non-API paths)"
       },
       excludePaths: {
-        type: "array", 
+        type: "array",
         items: { type: "string" },
         description: "Paths to exclude from Vite proxying"
       }
     },
     additionalProperties: false
   },
-  
+
   defaultConfig: {
     enabled: true,
     port: 5173,
@@ -72,17 +72,17 @@ export const vitePlugin: Plugin = {
 
   setup: async (context: PluginContext) => {
     const config = getPluginConfig(context)
-    
+
     if (!config.enabled || !context.config.client) {
       context.logger.info('Vite plugin disabled or no client configuration found')
       return
     }
-    
+
     const vitePort = config.port || context.config.client.port || 5173
     const viteHost = config.host || "localhost"
-    
+
     context.logger.info(`🎨 Starting Vite dev server programmatically on ${viteHost}:${vitePort}`)
-    
+
     try {
       // Start Vite dev server programmatically
       viteServer = await createServer({
@@ -93,21 +93,21 @@ export const vitePlugin: Plugin = {
           host: viteHost
         }
       })
-      
+
       await viteServer.listen()
       viteServer.printUrls()
-      
+
       context.logger.info(`✅ Vite server started successfully on ${viteHost}:${vitePort}`)
       context.logger.info('🔄 Hot reload coordination active - Zero órfãos!')
-      
-      // Store Vite config in context for later use
-      ;(context as any).viteConfig = {
-        port: vitePort,
-        host: viteHost,
-        ...config,
-        server: viteServer
-      }
-      
+
+        // Store Vite config in context for later use
+        ; (context as any).viteConfig = {
+          port: vitePort,
+          host: viteHost,
+          ...config,
+          server: viteServer
+        }
+
       // Setup cleanup on process exit
       const cleanup = async () => {
         if (viteServer) {
@@ -116,21 +116,21 @@ export const vitePlugin: Plugin = {
           viteServer = null
         }
       }
-      
+
       process.on('SIGINT', cleanup)
       process.on('SIGTERM', cleanup)
       process.on('exit', cleanup)
-      
+
     } catch (error) {
       context.logger.error('❌ Failed to start Vite server programmatically:', error)
       context.logger.info('⚠️ Falling back to monitoring mode...')
-      
-      // Fallback to monitoring if programmatic start fails
-      ;(context as any).viteConfig = {
-        port: vitePort,
-        host: viteHost,
-        ...config
-      }
+
+        // Fallback to monitoring if programmatic start fails
+        ; (context as any).viteConfig = {
+          port: vitePort,
+          host: viteHost,
+          ...config
+        }
       monitorVite(context, viteHost, vitePort, config)
     }
   },
@@ -138,45 +138,81 @@ export const vitePlugin: Plugin = {
   onServerStart: async (context: PluginContext) => {
     const config = getPluginConfig(context)
     const viteConfig = (context as any).viteConfig
-    
+
     if (config.enabled && viteConfig) {
       context.logger.info(`Vite integration active - monitoring ${viteConfig.host}:${viteConfig.port}`)
     }
   },
 
   onBeforeRoute: async (requestContext: RequestContext) => {
-    // Skip API routes, swagger, and ALL Vite internal routes
-    if (requestContext.path.startsWith("/api") || 
-        requestContext.path.startsWith("/swagger") ||
-        requestContext.path.startsWith("/@") ||           // All Vite internal routes (/@vite/, /@fs/, /@react-refresh, etc.)
-        requestContext.path.startsWith("/__vite") ||      // Vite HMR and dev routes
-        requestContext.path.startsWith("/node_modules") || // Direct node_modules access
-        requestContext.path.includes("/.vite/") ||        // Vite cache and deps
-        requestContext.path.endsWith(".js.map") ||        // Source maps
-        requestContext.path.endsWith(".css.map")) {       // CSS source maps
+    // Skip API routes and swagger - let them be handled by backend
+    if (requestContext.path.startsWith("/api") || requestContext.path.startsWith("/swagger")) {
       return
     }
-    
+
+    // For Vite internal routes, proxy directly to Vite server
+    if (requestContext.path.startsWith("/@") ||           // All Vite internal routes (/@vite/, /@fs/, /@react-refresh, etc.)
+      requestContext.path.startsWith("/__vite") ||      // Vite HMR and dev routes
+      requestContext.path.startsWith("/node_modules") || // Direct node_modules access
+      requestContext.path.includes("/.vite/") ||        // Vite cache and deps
+      requestContext.path.endsWith(".js.map") ||        // Source maps
+      requestContext.path.endsWith(".css.map")) {       // CSS source maps
+
+      // Use fixed configuration for Vite proxy
+      const viteHost = "localhost"
+      const vitePort = 5173
+
+      try {
+        const url = new URL(requestContext.request.url)
+        const viteUrl = `http://${viteHost}:${vitePort}${requestContext.path}${url.search}`
+
+        // Forward request to Vite
+        const response = await fetch(viteUrl, {
+          method: requestContext.method,
+          headers: requestContext.headers,
+          body: requestContext.method !== 'GET' && requestContext.method !== 'HEAD' ? requestContext.request.body : undefined
+        })
+
+        // Return the Vite response
+        const body = await response.arrayBuffer()
+
+        requestContext.handled = true
+        requestContext.response = new Response(body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        })
+
+      } catch (viteError) {
+        // If Vite fails, let the request continue to normal routing (will become 404)
+        // Only log if explicitly enabled for debugging
+        if (process.env.ENABLE_VITE_PROXY_LOGS === 'true') {
+          console.warn(`Vite proxy error: ${viteError}`)
+        }
+      }
+      return
+    }
+
     // Use fixed configuration for simplicity - Vite should be running on port 5173
     const viteHost = "localhost"
     const vitePort = 5173
-    
+
     try {
       const url = new URL(requestContext.request.url)
       const viteUrl = `http://${viteHost}:${vitePort}${requestContext.path}${url.search}`
-      
+
       // Forward request to Vite
       const response = await fetch(viteUrl, {
         method: requestContext.method,
         headers: requestContext.headers,
         body: requestContext.method !== 'GET' && requestContext.method !== 'HEAD' ? requestContext.request.body : undefined
       })
-      
+
       // If Vite responds successfully, handle the request
       if (response.ok || response.status < 500) {
         // Return a proper Response object with all headers and status
         const body = await response.arrayBuffer()
-        
+
         requestContext.handled = true
         requestContext.response = new Response(body, {
           status: response.status,
@@ -184,7 +220,7 @@ export const vitePlugin: Plugin = {
           headers: response.headers
         })
       }
-      
+
     } catch (viteError) {
       // If Vite fails, let the request continue to normal routing (will become 404)
       // Only log if explicitly enabled for debugging
@@ -203,16 +239,16 @@ function getPluginConfig(context: PluginContext) {
 
 // Monitor Vite server status with automatic port detection
 async function monitorVite(
-  context: PluginContext, 
-  host: string, 
-  initialPort: number, 
+  context: PluginContext,
+  host: string,
+  initialPort: number,
   config: any
 ) {
   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
@@ -223,13 +259,13 @@ async function monitorVite(
           portDetected = true
           // Update the context with the detected port
           if ((context as any).viteConfig) {
-            ;(context as any).viteConfig.port = actualPort
+            ; (context as any).viteConfig.port = actualPort
           }
         }
       }
-      
+
       const isRunning = await checkViteRunning(host, actualPort, config.timeout)
-      
+
       if (isRunning && !isConnected) {
         isConnected = true
         retries = 0
@@ -262,11 +298,11 @@ async function monitorVite(
         context.logger.error('Error checking Vite server status', { error })
       }
     }
-    
+
     // Continue monitoring
     setTimeout(checkVite, config.checkInterval)
   }
-  
+
   // Start monitoring after a brief delay
   setTimeout(checkVite, 1000)
 }
@@ -285,7 +321,7 @@ async function detectVitePort(host: string, startPort: number): Promise<number |
     3000, // Sometimes Vite might use this
     4173  // Another common alternative
   ]
-  
+
   for (const port of portsToTry) {
     try {
       const isRunning = await checkViteRunning(host, port, 1000)
@@ -296,7 +332,7 @@ async function detectVitePort(host: string, startPort: number): Promise<number |
       // Continue trying other ports
     }
   }
-  
+
   return null
 }
 
@@ -305,12 +341,12 @@ async function checkViteRunning(host: string, port: number, timeout: number = 10
   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) {

package/core/plugins/manager.ts

@@ -64,20 +64,35 @@ export class PluginManager extends EventEmitter {
 
     try {
       // Discover and load plugins
+      this.logger.debug('Starting plugin discovery...')
       await this.discoverPlugins()
+      this.logger.debug('Plugin discovery completed')
       
       // Setup plugin contexts
+      this.logger.debug('Setting up plugin contexts...')
       this.setupPluginContexts()
+      this.logger.debug('Plugin contexts setup completed')
       
       // Execute setup hooks
+      this.logger.debug('Executing setup hooks...')
       await this.executeHook('setup')
+      this.logger.debug('Setup hooks execution completed')
       
       this.initialized = true
+      const stats = this.registry.getStats()
       this.logger.info('Plugin manager initialized successfully', {
-        totalPlugins: this.registry.getStats().totalPlugins
+        totalPlugins: stats.totalPlugins,
+        enabledPlugins: stats.enabledPlugins,
+        loadOrder: stats.loadOrder
       })
     } catch (error) {
-      this.logger.error('Failed to initialize plugin manager', { error })
+      this.logger.error('Failed to initialize plugin manager', { 
+        error: error instanceof Error ? {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        } : error 
+      })
       throw error
     }
   }
@@ -396,12 +411,40 @@ export class PluginManager extends EventEmitter {
    */
   private async discoverPlugins(): Promise<void> {
     try {
-      this.logger.info('Discovering external plugins in directory: plugins')
-      const results = await this.registry.discoverPlugins({
-        directories: ['plugins'],
-        includeBuiltIn: false,
-        includeExternal: true
+      // Load built-in plugins first (handled by core system)
+      this.logger.info('Loading built-in plugins...')
+      const builtInResults = await this.registry.discoverPlugins({
+        directories: [],
+        includeBuiltIn: true,
+        includeExternal: false
       })
+      
+      // Try to use auto-generated registry for external plugins (if available from build)
+      let externalResults: any[] = []
+      try {
+        const autoRegistryModule = await import('./auto-registry')
+        if (autoRegistryModule.discoveredPlugins && autoRegistryModule.registerDiscoveredPlugins) {
+          this.logger.info('🚀 Using auto-generated external plugins registry')
+          await autoRegistryModule.registerDiscoveredPlugins(this.registry)
+          externalResults = autoRegistryModule.discoveredPlugins.map((plugin: any) => ({
+            success: true,
+            plugin
+          }))
+        }
+      } catch (error) {
+        this.logger.debug('Auto-generated external plugins registry not found, falling back to discovery', { error: error.message })
+        
+        // Fallback to runtime discovery for external plugins
+        this.logger.info('Discovering external plugins in directory: plugins')
+        externalResults = await this.registry.discoverPlugins({
+          directories: ['plugins'],
+          includeBuiltIn: false,
+          includeExternal: true
+        })
+      }
+      
+      // Combine results
+      const results = [...builtInResults, ...externalResults]
 
       let loaded = 0
       let failed = 0
@@ -448,7 +491,7 @@ export class PluginManager extends EventEmitter {
 
     const context: PluginContext = {
       config: this.config,
-      logger: this.logger,
+      logger: this.logger.child ? this.logger.child({ plugin: plugin.name }) : this.logger,
       app: this.app,
       utils: createPluginUtils(this.logger),
       registry: this.registry

package/core/utils/helpers.ts

@@ -87,15 +87,21 @@ export const throttle = <T extends (...args: any[]) => any>(
 }
 
 export const isProduction = (): boolean => {
-  return process.env.NODE_ENV === 'production'
+  // Import here to avoid circular dependency  
+  const { env } = require('./env-runtime-v2')
+  return env.NODE_ENV === 'production'
 }
 
 export const isDevelopment = (): boolean => {
-  return process.env.NODE_ENV === 'development' || !process.env.NODE_ENV
+  // Import here to avoid circular dependency
+  const { env } = require('./env-runtime-v2')
+  return env.NODE_ENV === 'development' || !env.NODE_ENV
 }
 
 export const isTest = (): boolean => {
-  return process.env.NODE_ENV === 'test'
+  // Import here to avoid circular dependency
+  const { env } = require('./env-runtime-v2')
+  return env.NODE_ENV === 'test'
 }
 
 export const deepMerge = <T extends Record<string, any>>(target: T, source: Partial<T>): T => {

package/fluxstack.config.ts

@@ -42,7 +42,6 @@ export const config: FluxStackConfig = {
     },
     build: {
       sourceMaps: env.get('CLIENT_SOURCEMAPS', helpers.isDevelopment()),
-      minify: env.get('CLIENT_MINIFY', helpers.isProduction()),
       target: env.get('CLIENT_TARGET', 'esnext'),
       outDir: env.get('CLIENT_OUTDIR', 'dist/client')
     }
@@ -53,7 +52,6 @@ export const config: FluxStackConfig = {
     target: env.get('BUILD_TARGET', 'bun'),   // string casting
     outDir: env.get('BUILD_OUTDIR', 'dist'),  // string
     optimization: {
-      minify: env.get('BUILD_MINIFY', helpers.isProduction()),
       treeshake: env.get('BUILD_TREESHAKE', helpers.isProduction()),
       compress: env.get('BUILD_COMPRESS', helpers.isProduction()),
       splitChunks: env.get('BUILD_SPLIT_CHUNKS', true),
@@ -193,7 +191,6 @@ export const config: FluxStackConfig = {
         port: 5173,
         proxy: { target: 'http://localhost:3000' },
         build: {
-          minify: false,
           sourceMaps: true,
           target: 'es2020',
           outDir: 'dist'
@@ -203,7 +200,6 @@ export const config: FluxStackConfig = {
         target: 'bun',
         outDir: 'dist',
         optimization: {
-          minify: false,
           compress: false,
           treeshake: false,
           splitChunks: false,
@@ -246,7 +242,6 @@ export const config: FluxStackConfig = {
         port: 5173,
         proxy: { target: 'http://localhost:3000' },
         build: {
-          minify: true,
           sourceMaps: false,
           target: 'es2020',
           outDir: 'dist'
@@ -256,10 +251,9 @@ export const config: FluxStackConfig = {
         target: 'bun',
         outDir: 'dist',
         optimization: {
-          minify: true,
-          treeshake: true,
-          compress: true,
-          splitChunks: true,
+          treeshake: false,
+          compress: false,
+          splitChunks: false,
           bundleAnalyzer: false
         },
         sourceMaps: false,
@@ -306,7 +300,7 @@ export const config: FluxStackConfig = {
       client: {
         port: 0, // Use random available port
         proxy: { target: 'http://localhost:3000' },
-        build: { sourceMaps: true, minify: false, target: 'es2020', outDir: 'dist' }
+        build: { sourceMaps: true, target: 'es2020', outDir: 'dist' }
       },
       monitoring: {
         enabled: false,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-fluxstack",
-  "version": "1.0.21",
-  "description": "⚡ Modern full-stack TypeScript framework with Elysia + React + Bun",
+  "version": "1.1.0",
+  "description": "⚡ Revolutionary full-stack TypeScript framework with Temporal Bridge Auto-Discovery, Elysia + React + Bun",
   "keywords": [
     "framework",
     "full-stack",
@@ -29,7 +29,7 @@
     "dev:backend": "bun run core/cli/index.ts backend",
     "dev:coordinated": "concurrently --prefix {name} --names BACKEND,VITE --prefix-colors blue,green --kill-others-on-fail \"bun --watch app/server/index.ts\" \"vite --config vite.config.ts\"",
     "dev:clean": "bun run run-clean.ts",
-    "build": "bun run core/cli/index.ts build",
+    "build": "cross-env NODE_ENV=production bun run core/cli/index.ts build",
     "build:frontend": "vite build --config vite.config.ts --emptyOutDir",
     "build:backend": "bun run core/cli/index.ts build:backend",
     "start": "bun run core/cli/index.ts start",
@@ -70,6 +70,7 @@
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "concurrently": "^9.2.0",
+    "cross-env": "^10.1.0",
     "eslint": "^9.30.1",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-react-refresh": "^0.4.20",