create-fluxstack 1.8.1 → 1.8.3

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

@@ -1,11 +1,39 @@
-import type { FluxStack, PluginContext, RequestContext } from "../../types"
+import type { FluxStack, PluginContext, RequestContext } from "@/core/plugins/types"
 import { createServer, type ViteDevServer } from 'vite'
-import { FLUXSTACK_VERSION } from "../../../utils/version"
+import { FLUXSTACK_VERSION } from "@/core/utils/version"
+import { clientConfig } from '@/config/client.config'
 
 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",
+  checkInterval: 2000,
+  maxRetries: 10,
+  timeout: 5000,
+  proxyPaths: [] as string[],
+  excludePaths: [] as string[]
+}
+
+/**
+ * Helper to safely parse request.url which might be relative or absolute
+ */
+function parseRequestURL(request: Request): URL {
+  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}`)
+  }
+}
+
 export const vitePlugin: Plugin = {
   name: "vite",
   version: FLUXSTACK_VERSION,
@@ -14,89 +42,22 @@ export const vitePlugin: Plugin = {
   priority: 800, // Should run early to setup proxying
   category: "development",
   tags: ["vite", "development", "hot-reload"],
-  dependencies: [], // No dependencies
-
-  configSchema: {
-    type: "object",
-    properties: {
-      enabled: {
-        type: "boolean",
-        description: "Enable Vite integration"
-      },
-      port: {
-        type: "number",
-        minimum: 1,
-        maximum: 65535,
-        description: "Vite development server port"
-      },
-      host: {
-        type: "string",
-        description: "Vite development server host"
-      },
-      checkInterval: {
-        type: "number",
-        minimum: 100,
-        description: "Interval to check if Vite is running (ms)"
-      },
-      maxRetries: {
-        type: "number",
-        minimum: 1,
-        description: "Maximum retries to connect to Vite"
-      },
-      timeout: {
-        type: "number",
-        minimum: 100,
-        description: "Timeout for Vite requests (ms)"
-      },
-      proxyPaths: {
-        type: "array",
-        items: { type: "string" },
-        description: "Paths to proxy to Vite (defaults to all non-API paths)"
-      },
-      excludePaths: {
-        type: "array",
-        items: { type: "string" },
-        description: "Paths to exclude from Vite proxying"
-      }
-    },
-    additionalProperties: false
-  },
-
-  defaultConfig: {
-    enabled: true,
-    port: 5173,
-    host: "localhost",
-    checkInterval: 2000,
-    maxRetries: 10,
-    timeout: 5000,
-    proxyPaths: [],
-    excludePaths: []
-  },
+  dependencies: [],
 
   setup: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
-
-    if (!config.enabled || !context.config.client) {
+    if (!DEFAULTS.enabled) {
       context.logger.debug('Vite plugin disabled or no client configuration found')
       return
     }
 
-    const vitePort = config.port || context.config.client.port || 5173
-    const viteHost = config.host || "localhost"
+    const vitePort = DEFAULTS.port || clientConfig.vite.port || 5173
+    const viteHost = DEFAULTS.host || "localhost"
 
-    try {
-      const { startGroup, endGroup, logInGroup } = await import('../../../utils/logger/group-logger')
-
-      startGroup({
-        title: 'Vite Development Server',
-        icon: '🎨',
-        color: 'magenta',
-        collapsed: true
-      })
+    // Import group logger utilities
+    const { startGroup, endGroup, logInGroup } = await import('@/core/utils/logger/group-logger')
 
-      logInGroup(`Starting on ${viteHost}:${vitePort}`, '📍')
-
-      // Start Vite dev server programmatically
+    try {
+      // Start Vite dev server programmatically (silently)
       viteServer = await createServer({
         configFile: './vite.config.ts',
         // Don't override root - let vite.config.ts handle it
@@ -105,23 +66,18 @@ export const vitePlugin: Plugin = {
           host: viteHost,
           strictPort: true
         },
-        logLevel: 'warn' // Suppress Vite's verbose logs
+        logLevel: 'silent' // Suppress all Vite logs
       })
 
       await viteServer.listen()
 
-      // Custom URL display instead of viteServer.printUrls()
-      logInGroup(`Local: http://${viteHost}:${vitePort}/`, '✅')
-      logInGroup('Hot reload coordination active', '🔄')
-
-      endGroup()
-      console.log('') // Separator line
+      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,
-          ...config,
           server: viteServer
         }
 
@@ -139,24 +95,40 @@ export const vitePlugin: Plugin = {
       process.on('exit', cleanup)
 
     } catch (error) {
-      context.logger.error('❌ Failed to start Vite server programmatically:', error)
-      context.logger.debug('⚠️ Falling back to monitoring mode...')
+      // 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,
-          ...config
+          host: viteHost
         }
-      monitorVite(context, viteHost, vitePort, config)
+        monitorVite(context, viteHost, vitePort)
+      }
     }
   },
 
   onServerStart: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
     const viteConfig = (context as any).viteConfig
 
-    if (config.enabled && viteConfig) {
+    if (DEFAULTS.enabled && viteConfig) {
       context.logger.debug(`Vite integration active - monitoring ${viteConfig.host}:${viteConfig.port}`)
     }
   },
@@ -180,7 +152,7 @@ export const vitePlugin: Plugin = {
       const vitePort = 5173
 
       try {
-        const url = new URL(requestContext.request.url)
+        const url = parseRequestURL(requestContext.request)
         const viteUrl = `http://${viteHost}:${vitePort}${requestContext.path}${url.search}`
 
         // Forward request to Vite
@@ -216,7 +188,7 @@ export const vitePlugin: Plugin = {
     const vitePort = 5173
 
     try {
-      const url = new URL(requestContext.request.url)
+      const url = parseRequestURL(requestContext.request)
       const viteUrl = `http://${viteHost}:${vitePort}${requestContext.path}${url.search}`
 
       // Forward request to Vite
@@ -250,18 +222,11 @@ export const vitePlugin: Plugin = {
   }
 }
 
-// Helper function to get plugin config
-function getPluginConfig(context: PluginContext) {
-  const pluginConfig = context.config.plugins.config?.vite || {}
-  return { ...vitePlugin.defaultConfig, ...pluginConfig }
-}
-
 // Monitor Vite server status with automatic port detection
 async function monitorVite(
   context: PluginContext,
   host: string,
-  initialPort: number,
-  config: any
+  initialPort: number
 ) {
   let retries = 0
   let isConnected = false
@@ -283,7 +248,7 @@ async function monitorVite(
         }
       }
 
-      const isRunning = await checkViteRunning(host, actualPort, config.timeout)
+      const isRunning = await checkViteRunning(host, actualPort, DEFAULTS.timeout)
 
       if (isRunning && !isConnected) {
         isConnected = true
@@ -302,14 +267,14 @@ async function monitorVite(
         actualPort = initialPort
       } else if (!isRunning) {
         retries++
-        if (retries <= config.maxRetries) {
+        if (retries <= DEFAULTS.maxRetries) {
           if (portDetected) {
-            context.logger.debug(`Waiting for Vite server on ${host}:${actualPort}... (${retries}/${config.maxRetries})`)
+            context.logger.debug(`Waiting for Vite server on ${host}:${actualPort}... (${retries}/${DEFAULTS.maxRetries})`)
           } else {
-            context.logger.debug(`Detecting Vite server port... (${retries}/${config.maxRetries})`)
+            context.logger.debug(`Detecting Vite server port... (${retries}/${DEFAULTS.maxRetries})`)
           }
-        } else if (retries === config.maxRetries + 1) {
-          context.logger.warn(`Vite server not found after ${config.maxRetries} attempts. Development features may be limited.`)
+        } else if (retries === DEFAULTS.maxRetries + 1) {
+          context.logger.warn(`Vite server not found after ${DEFAULTS.maxRetries} attempts. Development features may be limited.`)
         }
       }
     } catch (error) {
@@ -319,7 +284,7 @@ async function monitorVite(
     }
 
     // Continue monitoring
-    setTimeout(checkVite, config.checkInterval)
+    setTimeout(checkVite, DEFAULTS.checkInterval)
   }
 
   // Start monitoring after a brief delay

package/core/plugins/config.ts

@@ -4,8 +4,8 @@
  */
 
 import type { FluxStack, PluginConfigSchema, PluginValidationResult } from "./types"
-import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger/index"
+import type { FluxStackConfig } from "@/core/config/schema"
+import type { Logger } from "@/core/utils/logger/index"
 
 type Plugin = FluxStack.Plugin
 

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 '../utils/logger'
+import type { Logger } from '@/core/utils/logger'
 
 export interface PluginDependency {
   name: string
@@ -176,7 +176,7 @@ export class PluginDependencyManager {
   /**
    * Instalar dependências no diretório local do plugin
    */
-  private async installPluginDependenciesLocally(pluginPath: string, dependencies: PluginDependency[]): Promise<void> {
+  async installPluginDependenciesLocally(pluginPath: string, dependencies: PluginDependency[]): Promise<void> {
     if (dependencies.length === 0) return
 
     const regularDeps = dependencies.filter(d => d.type === 'dependency')

package/core/plugins/discovery.ts

@@ -4,7 +4,7 @@
  */
 
 import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
-import type { Logger } from "../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"

package/core/plugins/executor.ts

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

package/core/plugins/manager.ts

@@ -18,13 +18,28 @@ import type {
 } from "./types"
 
 type Plugin = FluxStack.Plugin
-import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger"
+import type { FluxStackConfig } from "@/core/config/schema"
+import type { Logger } from "@/core/utils/logger"
 import { PluginRegistry } from "./registry"
 import { createPluginUtils } from "./config"
-import { FluxStackError } from "../utils/errors"
+import { FluxStackError } from "@/core/utils/errors"
 import { EventEmitter } from "events"
 
+/**
+ * Helper to safely parse request.url which might be relative or absolute
+ */
+function parseRequestURL(request: Request): URL {
+  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}`)
+  }
+}
+
 export interface PluginManagerConfig {
   config: FluxStackConfig
   logger: Logger
@@ -558,7 +573,7 @@ export class PluginManager extends EventEmitter {
  * Create request context from HTTP request
  */
 export function createRequestContext(request: Request, additionalData: any = {}): RequestContext {
-  const url = new URL(request.url)
+  const url = parseRequestURL(request)
   
   return {
     request,

package/core/plugins/module-resolver.ts

@@ -5,7 +5,7 @@
 
 import { existsSync } from 'fs'
 import { join, resolve } from 'path'
-import type { Logger } from '../utils/logger'
+import type { Logger } from '@/core/utils/logger'
 
 export interface ModuleResolverConfig {
   projectRoot: string

package/core/plugins/registry.ts

@@ -1,9 +1,9 @@
 import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOptions } from "./types"
 
 type FluxStackPlugin = FluxStack.Plugin
-import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger"
-import { FluxStackError } from "../utils/errors"
+import type { FluxStackConfig } from "@/core/config/schema"
+import type { Logger } from "@/core/utils/logger"
+import { FluxStackError } from "@/core/utils/errors"
 import { PluginDependencyManager } from "./dependency-manager"
 import { readdir, readFile } from "fs/promises"
 import { join, resolve } from "path"

package/core/plugins/types.ts

@@ -1,5 +1,5 @@
-import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger/index"
+import type { FluxStackConfig } from "@/core/config/schema"
+import type { Logger } from "@/core/utils/logger/index"
 
 export type PluginHook = 
   | 'setup'
@@ -96,11 +96,31 @@ export namespace FluxStack {
   onError?: (context: ErrorContext) => void | Promise<void>
   onBuild?: (context: BuildContext) => void | Promise<void>
   onBuildComplete?: (context: BuildContext) => void | Promise<void>
-  
+
   // Configuration
+  /**
+   * @deprecated Use declarative config system instead (plugins/[name]/config/)
+   * Create a config/ folder with defineConfig() for type-safe configuration.
+   * This property is kept for backward compatibility with built-in plugins.
+   *
+   * @example
+   * // ✅ New way (recommended):
+   * // plugins/my-plugin/config/index.ts
+   * import { defineConfig, config } from '@/core/utils/config-schema'
+   * export const myConfig = defineConfig({ ... })
+   *
+   * // ❌ Old way (deprecated):
+   * configSchema: { type: 'object', properties: { ... } }
+   */
   configSchema?: PluginConfigSchema
+
+  /**
+   * @deprecated Use declarative config system with defineConfig()
+   * This property will be removed in a future major version.
+   * Use the config/ folder structure for automatic type inference.
+   */
   defaultConfig?: any
-  
+
   // CLI commands
   commands?: CliCommand[]
   }
@@ -251,4 +271,126 @@ export interface CliContext {
     name: string
     version: string
   }
-}
+}
+
+// Live Components Types
+export interface LiveComponent<TState = any> {
+  id: string
+  name: string
+  state: TState
+  mounted: boolean
+  socket?: any
+  userId?: string
+  destroy?: () => void
+  executeAction?: (action: string, payload?: any) => Promise<any>
+  setState?: (newState: Partial<TState>) => void
+  getSerializableState?: () => TState
+}
+
+export interface LiveMessage {
+  type: string
+  componentId: string
+  data?: any
+  payload?: any
+  action?: string
+  property?: string
+  userId?: string
+  expectResponse?: boolean
+  timestamp?: number
+  requestId?: string
+  room?: string
+}
+
+export interface BroadcastMessage {
+  type: string
+  data?: any
+  channel?: string
+  room?: string
+  payload?: any
+  excludeUser?: string
+}
+
+export interface ComponentDefinition<TState = any> {
+  name: string
+  initialState: TState
+  handlers?: Record<string, Function>
+  component?: any
+}
+
+export interface WebSocketData {
+  componentId?: string
+  userId?: string
+  sessionId?: string
+}
+
+// File Upload Types
+export interface ActiveUpload {
+  uploadId: string
+  componentId?: string
+  filename: string
+  fileType?: string
+  fileSize?: number
+  totalChunks: number
+  receivedChunks: Map<number, any>
+  startTime: number
+  lastChunkTime?: number
+}
+
+export interface FileUploadStartMessage {
+  type: 'upload:start' | 'FILE_UPLOAD_START'
+  uploadId: string
+  filename: string
+  totalChunks: number
+  fileSize: number
+  componentId?: string
+  fileType?: string
+  chunkSize?: number
+  requestId?: string
+}
+
+export interface FileUploadChunkMessage {
+  type: 'upload:chunk' | 'FILE_UPLOAD_CHUNK'
+  uploadId: string
+  chunkIndex: number
+  data: string | ArrayBuffer
+  totalChunks?: number
+  componentId?: string
+  requestId?: string
+}
+
+export interface FileUploadCompleteMessage {
+  type: 'upload:complete' | 'FILE_UPLOAD_COMPLETE'
+  uploadId: string
+  requestId?: string
+}
+
+export interface FileUploadProgressResponse {
+  type: 'upload:progress' | 'FILE_UPLOAD_PROGRESS'
+  uploadId: string
+  receivedChunks?: number
+  totalChunks?: number
+  percentage?: number
+  componentId?: string
+  chunkIndex?: number
+  bytesUploaded?: number
+  totalBytes?: number
+  progress?: number
+  timestamp?: number
+}
+
+export interface FileUploadCompleteResponse {
+  type: 'upload:complete' | 'FILE_UPLOAD_COMPLETE'
+  uploadId: string
+  url?: string
+  filename?: string
+  size?: number
+  componentId?: string
+  success?: boolean
+  error?: string
+  message?: string
+  fileUrl?: string
+  timestamp?: number
+}
+
+// Plugin Type Export
+export type Plugin = FluxStack.Plugin

package/core/server/framework.ts

@@ -65,7 +65,7 @@ export class FluxStackFramework {
     // Create plugin context
     this.pluginContext = {
       config: fullConfig,
-      logger: logger as Logger,
+      logger: logger as any,
       app: this.app,
       utils: pluginUtils
     }
@@ -73,7 +73,7 @@ export class FluxStackFramework {
     // Initialize plugin manager
     this.pluginManager = new PluginManager({
       config: fullConfig,
-      logger: logger as Logger,
+      logger: logger as any,
       app: this.app
     })
 

package/core/server/live/ComponentRegistry.ts

@@ -6,7 +6,7 @@ import type {
   BroadcastMessage, 
   ComponentDefinition,
   WebSocketData 
-} from '../../types/types'
+} from '@/core/plugins/types'
 import { stateSignature, type SignedState } from './StateSignature'
 import { performanceMonitor } from './LiveComponentPerformanceMonitor'
 
@@ -151,7 +151,7 @@ export class ComponentRegistry {
     try {
       const fs = await import('fs')
       const path = await import('path')
-      const { startGroup, endGroup, logInGroup, groupSummary } = await import('../../utils/logger/group-logger')
+      const { startGroup, endGroup, logInGroup, groupSummary } = await import('@/core/utils/logger/group-logger')
 
       if (!fs.existsSync(componentsPath)) {
         console.log(`⚠️ Components path not found: ${componentsPath}`)
@@ -159,15 +159,9 @@ export class ComponentRegistry {
       }
 
       const files = fs.readdirSync(componentsPath)
-      let discoveredCount = 0
-
-      startGroup({
-        title: 'Live Components Auto-Discovery',
-        icon: '🔍',
-        color: 'blue',
-        collapsed: true
-      })
+      const components: string[] = []
 
+      // Discovery with component names collection
       for (const file of files) {
         if (file.endsWith('.ts') || file.endsWith('.js')) {
           try {
@@ -183,30 +177,19 @@ export class ComponentRegistry {
 
                 const componentName = exportName.replace(/Component$/, '')
                 this.registerComponentClass(componentName, exportedItem)
-                logInGroup(`${componentName} (from ${file})`, '📦')
-                discoveredCount++
+                components.push(componentName)
               }
             })
-
-            // Check for integration hooks (like SystemMonitorIntegration)
-            if (module.default && typeof module.default === 'object' && module.default.setupIntegration) {
-              logInGroup('Integration hooks found', '🔗')
-            }
           } catch (error) {
-            logInGroup(`Failed to load ${file}`, '⚠️')
+            // Silent - only log in debug mode
           }
         }
       }
 
-      if (discoveredCount > 0) {
-        const label = discoveredCount === 1 ? 'component discovered' : 'components discovered'
-        groupSummary(discoveredCount, label, '✓')
-      } else {
-        logInGroup('No components found', '⚠️')
+      // Display components in a compact single line format
+      if (components.length > 0) {
+        console.log(`\nLive Components (${components.length}): ${components.join(', ')}\n`)
       }
-
-      endGroup()
-      console.log('') // Separator line
     } catch (error) {
       console.error('❌ Auto-discovery failed:', error)
     }

package/core/server/live/FileUploadManager.ts

@@ -8,7 +8,7 @@ import type {
   FileUploadCompleteMessage,
   FileUploadProgressResponse,
   FileUploadCompleteResponse
-} from '../../types/types'
+} from '@/core/plugins/types'
 
 export class FileUploadManager {
   private activeUploads = new Map<string, ActiveUpload>()