create-fluxstack 1.9.1 → 1.12.0

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

@@ -1,343 +1,131 @@
-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 type { FluxStack, PluginContext, RequestContext } from "@core/plugins/types"
+import { FLUXSTACK_VERSION } from "@core/utils/version"
+import { clientConfig } from '@config'
+import { pluginsConfig } from '@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
+const PLUGIN_PRIORITY = 800
+const INDEX_FILE = "index.html"
 
-// Default configuration values (uses clientConfig from /config)
-const DEFAULTS = {
-  enabled: true,
-  port: clientConfig.vite.port,
-  host: "localhost",
-  checkInterval: 2000,
-  maxRetries: 10,
-  timeout: 5000,
-  proxyPaths: [] as string[],
-  excludePaths: [] as string[]
+/** Create static file handler with cached base directory */
+function createStaticFallback() {
+  // Discover base directory once
+  const baseDir = existsSync('client') ? 'client'
+    : existsSync('dist/client') ? 'dist/client'
+    : clientConfig.build.outDir ?? 'dist/client'
+
+  return (c: { request?: Request }) => {
+    const req = c.request
+    if (!req) return
+
+    let pathname = decodeURIComponent(new URL(req.url).pathname)
+    if (pathname === '/' || pathname === '') {
+      pathname = `/${INDEX_FILE}`
+    }
+
+    // Try to serve the requested file
+    const filePath = join(baseDir, pathname)
+    try {
+      if (statSync(filePath).isFile()) {
+        return Bun.file(filePath)
+      }
+    } catch {}
+
+    // SPA fallback: serve index.html
+    const indexPath = join(baseDir, INDEX_FILE)
+    try {
+      statSync(indexPath)
+      return Bun.file(indexPath)
+    } catch {}
+  }
 }
 
-/**
- * Helper to safely parse request.url which might be relative or absolute
- */
-function parseRequestURL(request: Request): URL {
+/** Proxy request to Vite dev server */
+async function proxyToVite(ctx: RequestContext): Promise<void> {
+  const { host, port } = clientConfig.vite
+
   try {
-    // Try parsing as absolute URL first
-    return new URL(request.url)
-  } catch {
-    // If relative, use host from headers or default to localhost
-    const host = request.headers.get('host') || 'localhost'
-    const protocol = request.headers.get('x-forwarded-proto') || 'http'
-    return new URL(request.url, `${protocol}://${host}`)
+    // Parse URL (handle relative URLs)
+    let url: URL
+    try {
+      url = new URL(ctx.request.url)
+    } catch {
+      const reqHost = ctx.request.headers.get('host') || 'localhost'
+      const protocol = ctx.request.headers.get('x-forwarded-proto') || 'http'
+      url = new URL(ctx.request.url, `${protocol}://${reqHost}`)
+    }
+
+    const response = await fetch(`http://${host}:${port}${ctx.path}${url.search}`, {
+      method: ctx.method,
+      headers: ctx.headers,
+      body: ctx.method !== 'GET' && ctx.method !== 'HEAD' ? ctx.request.body : undefined
+    })
+
+    ctx.handled = true
+    ctx.response = new Response(await response.arrayBuffer(), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    })
+  } catch (error) {
+    if (clientConfig.vite.enableLogging) {
+      console.warn(`Vite proxy error: ${error}`)
+    }
   }
 }
 
 export const vitePlugin: Plugin = {
   name: "vite",
   version: FLUXSTACK_VERSION,
-  description: "Enhanced Vite integration plugin for FluxStack with improved error handling and monitoring",
+  description: "Vite integration plugin for FluxStack",
   author: "FluxStack Team",
-  priority: 800, // Should run early to setup proxying
+  priority: PLUGIN_PRIORITY,
   category: "development",
   tags: ["vite", "development", "hot-reload"],
   dependencies: [],
 
   setup: async (context: PluginContext) => {
-    if (!DEFAULTS.enabled) {
-      context.logger.debug('Vite plugin disabled or no client configuration found')
+    if (!pluginsConfig.viteEnabled) {
+      context.logger.debug('Vite plugin disabled')
       return
     }
 
-    const vitePort = DEFAULTS.port || clientConfig.vite.port || 5173
-    const viteHost = DEFAULTS.host || "localhost"
-
-    // Import group logger utilities
-    const { startGroup, endGroup, logInGroup } = await import('@/core/utils/logger/group-logger')
-
-    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
-      })
-
-      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)
-        context.logger.debug('⚠️ Falling back to monitoring mode...')
-
-        // Fallback to monitoring if programmatic start fails
-        ; (context as any).viteConfig = {
-          port: vitePort,
-          host: viteHost
-        }
-        monitorVite(context, viteHost, vitePort)
-      }
-    }
-  },
-
-  onServerStart: async (context: PluginContext) => {
-    const viteConfig = (context as any).viteConfig
-
-    if (DEFAULTS.enabled && viteConfig) {
-      context.logger.debug(`Vite integration active - monitoring ${viteConfig.host}:${viteConfig.port}`)
-    }
-  },
-
-  onBeforeRoute: async (requestContext: RequestContext) => {
-    // Skip API routes and swagger - let them be handled by backend
-    if (requestContext.path.startsWith("/api") || requestContext.path.startsWith("/swagger")) {
+    if (!isDevelopment()) {
+      context.logger.debug("Production mode: static file serving enabled")
+      context.app.all('*', createStaticFallback())
       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 = parseRequestURL(requestContext.request)
-        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()
+    const { setupViteDev } = await import('./vite-dev')
+    await setupViteDev(context)
+  },
 
-        requestContext.handled = true
-        requestContext.response = new Response(body, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: response.headers
-        })
+  onServerStart: async (context: PluginContext) => {
+    if (!pluginsConfig.viteEnabled) return
 
-      } 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}`)
-        }
-      }
+    if (!isDevelopment()) {
+      context.logger.debug('Static files ready')
       return
     }
 
-    // Use fixed configuration for simplicity - Vite should be running on port 5173
-    const viteHost = "localhost"
-    const vitePort = 5173
-
-    try {
-      const url = parseRequestURL(requestContext.request)
-      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,
-          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
-      const { clientConfig } = await import('@/config/client.config')
-      if (clientConfig.vite.enableLogging) {
-        console.warn(`Vite proxy error: ${viteError}`)
-      }
-    }
-  }
-}
-
-// 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)
-  }
+    context.logger.debug(`Vite active - ${clientConfig.vite.host}:${clientConfig.vite.port}`)
+  },
 
-  // Start monitoring after a brief delay
-  setTimeout(checkVite, 1000)
-}
+  onBeforeRoute: async (ctx: RequestContext) => {
+    if (!isDevelopment()) return
 
-// 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
-  ]
+    const shouldSkip = (pluginsConfig.viteExcludePaths ?? []).some(prefix =>
+      ctx.path === prefix || ctx.path.startsWith(prefix + '/')
+    )
 
-  for (const port of portsToTry) {
-    try {
-      const isRunning = await checkViteRunning(host, port, 1000)
-      if (isRunning) {
-        return port
-      }
-    } catch (error) {
-      // Continue trying other ports
+    if (!shouldSkip) {
+      await proxyToVite(ctx)
     }
   }
-
-  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
+export default vitePlugin

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

@@ -0,0 +1,82 @@
+import type { PluginContext } from "@core/plugins/types"
+import { clientConfig } from '@config'
+import type { LogLevel } from "vite"
+import conf from "@/vite.config"
+// Dynamic import t@ype for vite
+type ViteDevServer = Awaited<ReturnType<typeof import('vite')['createServer']>>
+
+// Store vite server instance
+let viteServer: ViteDevServer | null = null
+
+/**
+ * Setup Vite development server
+ * This file is only imported in development mode
+ */
+export async function setupViteDev(context: PluginContext): Promise<void> {
+  const vitePort = clientConfig.vite.port || 5173
+  const viteHost = clientConfig.vite.host || "localhost"
+  const logLevel = clientConfig.vite.logLevel as LogLevel
+  // 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: logLevel
+    })
+
+    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/config.ts

@@ -4,8 +4,8 @@
  */
 
 import type { FluxStack, PluginConfigSchema, PluginValidationResult } from "./types"
-import type { FluxStackConfig } from "@/core/config/schema"
-import type { Logger } from "@/core/utils/logger/index"
+import type { FluxStackConfig } from "@config"
+import type { Logger } from "@core/utils/logger/index"
 
 type Plugin = FluxStack.Plugin
 
@@ -61,19 +61,21 @@ export class DefaultPluginConfigManager implements PluginConfigManager {
 
   /**
    * Get plugin configuration from main config
+   * @deprecated Plugin configs are now directly accessed from config.plugins
    */
   getPluginConfig(pluginName: string, config: FluxStackConfig): any {
-    return config.plugins.config[pluginName] || {}
+    // Plugin configs are now accessed directly from config.plugins
+    // Example: config.plugins.swaggerEnabled
+    return {}
   }
 
   /**
    * Set plugin configuration in main config
+   * @deprecated Plugin configs are now set via environment variables and config files
    */
   setPluginConfig(pluginName: string, pluginConfig: any, config: FluxStackConfig): void {
-    if (!config.plugins.config) {
-      config.plugins.config = {}
-    }
-    config.plugins.config[pluginName] = pluginConfig
+    // Plugin configs are now set via environment variables and config files
+    // This function is deprecated and does nothing
   }
 
   /**

package/core/plugins/dependency-manager.ts

@@ -6,7 +6,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs'
 import { join, resolve } from 'path'
 import { execSync } from 'child_process'
-import type { Logger } from '@/core/utils/logger'
+import type { Logger } from '@core/utils/logger'
 
 export interface PluginDependency {
   name: string
@@ -230,6 +230,36 @@ export class PluginDependencyManager {
     }
   }
 
+  /**
+   * Instalar dependências diretamente em um path específico
+   */
+  async installDependenciesInPath(pluginPath: string, dependencies: Record<string, string>): Promise<void> {
+    if (!this.config.autoInstall) {
+      this.logger?.debug('Auto-instalação desabilitada')
+      return
+    }
+
+    if (Object.keys(dependencies).length === 0) {
+      return
+    }
+
+    const pluginDeps: PluginDependency[] = Object.entries(dependencies).map(([name, version]) => ({
+      name,
+      version,
+      type: 'dependency'
+    }))
+
+    this.logger?.debug(`📦 Instalando ${pluginDeps.length} dependência(s) em ${pluginPath}`)
+
+    try {
+      await this.installPluginDependenciesLocally(pluginPath, pluginDeps)
+      this.logger?.debug(`✅ Dependências instaladas com sucesso em ${pluginPath}`)
+    } catch (error) {
+      this.logger?.error(`❌ Erro ao instalar dependências em ${pluginPath}`, { error })
+      throw error
+    }
+  }
+
   /**
    * Encontrar diretório de um plugin pelo nome
    */

package/core/plugins/discovery.ts

@@ -4,7 +4,7 @@
  */
 
 import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
-import type { Logger } from "@/core/utils/logger/index"
+import type { Logger } from "@core/utils/logger/index"
 import { readdir, readFile } from "fs/promises"
 import { join, resolve } from "path"
 import { existsSync } from "fs"
@@ -306,12 +306,24 @@ export class PluginDiscovery {
    * Validate if an object is a valid plugin
    */
   private isValidPlugin(plugin: any): plugin is Plugin {
-    return (
-      plugin &&
-      typeof plugin === 'object' &&
-      typeof plugin.name === 'string' &&
-      plugin.name.length > 0
-    )
+    if (!plugin || typeof plugin !== 'object' || typeof plugin.name !== 'string' || plugin.name.length === 0) {
+      return false
+    }
+
+    const hookNames = [
+      'setup', 'onConfigLoad', 'onBeforeServerStart', 'onServerStart',
+      'onAfterServerStart', 'onBeforeServerStop', 'onServerStop',
+      'onRequest', 'onResponse', 'onError'
+    ]
+
+    for (const hook of hookNames) {
+      if (hook in plugin && typeof plugin[hook] !== 'function') {
+        this.logger?.warn(`Plugin "${plugin.name}" has invalid hook "${hook}" (expected function, got ${typeof plugin[hook]})`)
+        return false
+      }
+    }
+
+    return true
   }
 
   /**

package/core/plugins/executor.ts

@@ -10,8 +10,8 @@ import type {
   PluginPriority,
   HookExecutionOptions
 } from "./types"
-import type { Logger } from "@/core/utils/logger/index"
-import { FluxStackError } from "@/core/utils/errors"
+import type { Logger } from "@core/utils/logger/index"
+import { FluxStackError } from "@core/utils/errors"
 
 export interface PluginExecutionPlan {
   hook: PluginHook