create-fluxstack 1.8.1 → 1.9.1

package/core/cli/index.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env bun
 
-import { FluxStackBuilder } from "../build"
-import { ProjectCreator } from "../templates/create-project"
-import { getConfigSync } from "../config"
+import { FluxStackBuilder } from "@/core/build"
+import { ProjectCreator } from "@/core/templates/create-project"
+import { getConfigSync } from "@/core/config"
 import { cliRegistry } from "./command-registry"
 import { pluginDiscovery } from "./plugin-discovery"
-import { generateCommand, interactiveGenerateCommand } from "./generators/index.js"
-import { startGroup, endGroup, logBox, logInGroup } from "../utils/logger/group-logger"
+import { generateCommand, interactiveGenerateCommand } from "./generators/index"
+import { startGroup, endGroup, logBox, logInGroup } from "@/core/utils/logger/group-logger"
 
 const command = process.argv[2]
 const args = process.argv.slice(3)
@@ -138,14 +138,14 @@ Examples:
       // Grouped startup messages
       startGroup({
         title: 'FluxStack Development Server',
-        icon: '⚡',
+        icon: '',
         color: 'cyan'
       })
 
-      logInGroup(`Frontend: http://localhost:${options['frontend-port']}`, '🌐')
-      logInGroup(`Backend: http://localhost:${options.port}`, '🚀')
-      logInGroup('Backend inicia Vite programaticamente', '🔄')
-      logInGroup('Starting backend server...', '📦')
+      logInGroup(`Server: http://localhost:${options.port}`, '')
+      logInGroup(`API: http://localhost:${options.port}/api`, '')
+      logInGroup(`Swagger: http://localhost:${options.port}/swagger`, '')
+      logInGroup('Starting with hot reload...', '')
 
       endGroup()
       console.log('') // Separator line
@@ -325,7 +325,7 @@ Examples:
       }
 
       // Use the plugin generator
-      const { generatorRegistry } = await import('./generators/index.js')
+      const { generatorRegistry } = await import('./generators/index')
       const pluginGenerator = generatorRegistry.get('plugin')
 
       if (!pluginGenerator) {
@@ -356,6 +356,248 @@ Examples:
       }
     }
   })
+
+  // Frontend command (frontend-only development)
+  cliRegistry.register({
+    name: 'frontend',
+    description: 'Start frontend development server only',
+    category: 'Development',
+    usage: 'flux frontend [options]',
+    examples: [
+      'flux frontend               # Start Vite dev server on port 5173',
+      'flux frontend --port 3000   # Start on custom port'
+    ],
+    options: [
+      {
+        name: 'port',
+        short: 'p',
+        description: 'Port for frontend server',
+        type: 'number',
+        default: 5173
+      }
+    ],
+    handler: async (args, options, context) => {
+      console.log("🎨 FluxStack Frontend Development")
+      console.log(`🌐 Frontend: http://localhost:${options.port}`)
+      console.log("📦 Starting Vite dev server...")
+      console.log()
+
+      const { spawn } = await import("child_process")
+      const frontendProcess = spawn("vite", ["--config", "vite.config.ts", "--port", options.port.toString()], {
+        stdio: "inherit",
+        cwd: process.cwd()
+      })
+
+      process.on('SIGINT', () => {
+        frontendProcess.kill('SIGINT')
+        process.exit(0)
+      })
+
+      return new Promise((resolve) => {
+        frontendProcess.on('exit', resolve)
+      })
+    }
+  })
+
+  // Backend command (backend-only development)
+  cliRegistry.register({
+    name: 'backend',
+    description: 'Start backend development server only',
+    category: 'Development',
+    usage: 'flux backend [options]',
+    examples: [
+      'flux backend                # Start backend on port 3001',
+      'flux backend --port 4000    # Start on custom port'
+    ],
+    options: [
+      {
+        name: 'port',
+        short: 'p',
+        description: 'Port for backend server',
+        type: 'number',
+        default: 3001
+      }
+    ],
+    handler: async (args, options, context) => {
+      console.log("⚡ FluxStack Backend Development")
+      console.log(`🚀 API Server: http://localhost:${options.port}`)
+      console.log("📦 Starting backend with hot reload...")
+      console.log()
+
+      // Ensure backend-only.ts exists
+      const { ensureBackendEntry } = await import("../utils/regenerate-files")
+      await ensureBackendEntry()
+
+      // Start backend with Bun watch for hot reload
+      const { spawn } = await import("child_process")
+      const backendProcess = spawn("bun", ["--watch", "app/server/backend-only.ts"], {
+        stdio: "inherit",
+        cwd: process.cwd(),
+        env: {
+          ...process.env,
+          BACKEND_PORT: options.port.toString()
+        }
+      })
+
+      // Handle process cleanup
+      process.on('SIGINT', () => {
+        backendProcess.kill('SIGINT')
+        process.exit(0)
+      })
+
+      return new Promise((resolve) => {
+        backendProcess.on('exit', resolve)
+      })
+    }
+  })
+
+  // Start command (production server)
+  cliRegistry.register({
+    name: 'start',
+    description: 'Start production server',
+    category: 'Production',
+    usage: 'flux start',
+    examples: [
+      'flux start                  # Start production server from dist/'
+    ],
+    handler: async (args, options, context) => {
+      console.log("🚀 Starting FluxStack production server...")
+      const { join } = await import("path")
+      await import(join(process.cwd(), "dist", "index.js"))
+    }
+  })
+
+  // Build:frontend command (shortcut)
+  cliRegistry.register({
+    name: 'build:frontend',
+    description: 'Build frontend only (shortcut for build --frontend-only)',
+    category: 'Build',
+    usage: 'flux build:frontend',
+    examples: [
+      'flux build:frontend         # Build only frontend'
+    ],
+    handler: async (args, options, context) => {
+      const config = getConfigSync()
+      const builder = new FluxStackBuilder(config)
+      await builder.buildClient()
+    }
+  })
+
+  // Build:backend command (shortcut)
+  cliRegistry.register({
+    name: 'build:backend',
+    description: 'Build backend only (shortcut for build --backend-only)',
+    category: 'Build',
+    usage: 'flux build:backend',
+    examples: [
+      'flux build:backend          # Build only backend'
+    ],
+    handler: async (args, options, context) => {
+      const config = getConfigSync()
+      const builder = new FluxStackBuilder(config)
+      await builder.buildServer()
+    }
+  })
+
+  // Build:exe command (compile to executable)
+  cliRegistry.register({
+    name: 'build:exe',
+    description: 'Compile application to standalone executable',
+    category: 'Build',
+    usage: 'flux build:exe [options]',
+    examples: [
+      'flux build:exe                                    # Compile to CLauncher executable',
+      'flux build:exe --name MyApp                       # Compile with custom name',
+      'flux build:exe --windows-title "My Launcher"      # Set Windows executable title',
+      'flux build:exe --windows-hide-console             # Hide console window on Windows'
+    ],
+    options: [
+      {
+        name: 'name',
+        short: 'n',
+        description: 'Name for the executable file',
+        type: 'string',
+        default: 'CLauncher'
+      },
+      {
+        name: 'windows-hide-console',
+        description: 'Hide console window on Windows',
+        type: 'boolean',
+        default: false
+      },
+      {
+        name: 'windows-icon',
+        description: 'Path to .ico file for Windows executable',
+        type: 'string'
+      },
+      {
+        name: 'windows-title',
+        description: 'Product name for Windows executable',
+        type: 'string'
+      },
+      {
+        name: 'windows-publisher',
+        description: 'Company name for Windows executable',
+        type: 'string'
+      },
+      {
+        name: 'windows-version',
+        description: 'Version string for Windows executable (e.g. 1.2.3.4)',
+        type: 'string'
+      },
+      {
+        name: 'windows-description',
+        description: 'Description for Windows executable',
+        type: 'string'
+      },
+      {
+        name: 'windows-copyright',
+        description: 'Copyright string for Windows executable',
+        type: 'string'
+      }
+    ],
+    handler: async (args, options, context) => {
+      const config = getConfigSync()
+      const builder = new FluxStackBuilder(config)
+
+      // Build executable options from CLI args
+      const executableOptions: import("../types/build").BundleOptions = {
+        executable: {
+          windows: {
+            hideConsole: options['windows-hide-console'],
+            icon: options['windows-icon'],
+            title: options['windows-title'],
+            publisher: options['windows-publisher'],
+            version: options['windows-version'],
+            description: options['windows-description'],
+            copyright: options['windows-copyright']
+          }
+        }
+      }
+
+      const result = await builder.buildExecutable(options.name, executableOptions)
+
+      if (result.success) {
+        console.log(`\n✅ Executable created successfully: ${result.outputPath}`)
+
+        // Show applied Windows options
+        if (process.platform === 'win32' && Object.values(executableOptions.executable?.windows || {}).some(v => v)) {
+          console.log('\n📦 Windows executable options applied:')
+          const winOpts = executableOptions.executable?.windows
+          if (winOpts?.hideConsole) console.log('   • Console window hidden')
+          if (winOpts?.icon) console.log(`   • Icon: ${winOpts.icon}`)
+          if (winOpts?.title) console.log(`   • Title: ${winOpts.title}`)
+          if (winOpts?.publisher) console.log(`   • Publisher: ${winOpts.publisher}`)
+          if (winOpts?.version) console.log(`   • Version: ${winOpts.version}`)
+          if (winOpts?.description) console.log(`   • Description: ${winOpts.description}`)
+          if (winOpts?.copyright) console.log(`   • Copyright: ${winOpts.copyright}`)
+        }
+      } else {
+        console.error(`\n❌ Compilation failed: ${result.error}`)
+        process.exit(1)
+      }
+    }
+  })
 }
 
 // Main CLI logic
@@ -378,189 +620,12 @@ async function main() {
     process.exit(exitCode)
     return
   }
-  
-  // Fallback to legacy command handling for backward compatibility
-  await handleLegacyCommands()
-}
-
-// Legacy command handling for backward compatibility
-async function handleLegacyCommands() {
-  switch (command) {
-  case "dev":
-    // Grouped startup messages
-    startGroup({
-      title: 'FluxStack Development Server',
-      icon: '⚡',
-      color: 'cyan'
-    })
-
-    logInGroup('Frontend: http://localhost:5173', '🌐')
-    logInGroup('Backend: http://localhost:3000', '🚀')
-    logInGroup('Backend inicia Vite programaticamente', '🔄')
-    logInGroup('Starting backend server...', '📦')
-
-    endGroup()
-    console.log('') // Separator line
-    
-    // Start only backend - it will start Vite programmatically
-    const { spawn } = await import("child_process")
-    const devProcess = spawn("bun", ["--watch", "app/server/index.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-    
-    // Handle process cleanup
-    process.on('SIGINT', () => {
-      console.log('\n🛑 Shutting down gracefully...')
-      devProcess.kill('SIGTERM')
-      setTimeout(() => {
-        devProcess.kill('SIGKILL')
-        process.exit(0)
-      }, 5000)
-    })
-    
-    devProcess.on('close', (code) => {
-      process.exit(code || 0)
-    })
-    
-    // Keep the CLI running until the child process exits
-    await new Promise((resolve) => {
-      devProcess.on('exit', resolve)
-    })
-    break
-
-  case "frontend":
-    console.log("🎨 FluxStack Frontend Development")
-    console.log("🌐 Frontend: http://localhost:5173")
-    console.log("📦 Starting Vite dev server...")
-    console.log()
-    
-    const { spawn: spawnFrontend } = await import("child_process")
-    const frontendProcess = spawnFrontend("vite", ["--config", "vite.config.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-    
-    process.on('SIGINT', () => {
-      frontendProcess.kill('SIGINT')
-      process.exit(0)
-    })
-    break
-
-  case "backend":
-    console.log("⚡ FluxStack Backend Development")
-    console.log("🚀 API Server: http://localhost:3001")
-    console.log("📦 Starting backend with hot reload...")
-    console.log()
-
-    // Ensure backend-only.ts exists
-    const { ensureBackendEntry } = await import("../utils/regenerate-files")
-    await ensureBackendEntry()
-
-    // Start backend with Bun watch for hot reload
-    const { spawn: spawnBackend } = await import("child_process")
-    const backendProcess = spawnBackend("bun", ["--watch", "app/server/backend-only.ts"], {
-      stdio: "inherit",
-      cwd: process.cwd()
-    })
-
-    // Handle process cleanup
-    process.on('SIGINT', () => {
-      backendProcess.kill('SIGINT')
-      process.exit(0)
-    })
-    break
-
-  case "build":
-    const config = getConfigSync()
-    const builder = new FluxStackBuilder(config)
-    await builder.build()
-    break
-
-  case "build:frontend":
-    const frontendConfig = getConfigSync()
-    const frontendBuilder = new FluxStackBuilder(frontendConfig)
-    await frontendBuilder.buildClient()
-    break
-
-  case "build:backend":
-    const backendConfig = getConfigSync()
-    const backendBuilder = new FluxStackBuilder(backendConfig)
-    await backendBuilder.buildServer()
-    break
-
-  case "start":
-    console.log("🚀 Starting FluxStack production server...")
-    const { join } = await import("path")
-    await import(join(process.cwd(), "dist", "index.js"))
-    break
-
-  case "create":
-    const projectName = process.argv[3]
-    const template = process.argv[4]
-    
-    if (!projectName) {
-      console.error("❌ Please provide a project name: flux create my-app")
-      console.error()
-      console.error("Usage:")
-      console.error("  flux create <project-name> [template]")
-      console.error()
-      console.error("Templates:")
-      console.error("  basic    Basic FluxStack project (default)")
-      console.error("  full     Full-featured project with examples")
-      process.exit(1)
-    }
-
-    // Validate project name
-    if (!/^[a-zA-Z0-9-_]+$/.test(projectName)) {
-      console.error("❌ Project name can only contain letters, numbers, hyphens, and underscores")
-      process.exit(1)
-    }
-
-    try {
-      const creator = new ProjectCreator({
-        name: projectName,
-        template: template as 'basic' | 'full' || 'basic'
-      })
-      
-      await creator.create()
-    } catch (error) {
-      console.error("❌ Failed to create project:", error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-    break
 
-  default:
-    console.log(`
-⚡ FluxStack Framework CLI
-
-Usage:
-  flux dev             Start full-stack development server
-  flux frontend        Start frontend only (Vite dev server)
-  flux backend         Start backend only (API server)
-  flux build           Build both frontend and backend
-  flux build:frontend  Build frontend only
-  flux build:backend   Build backend only
-  flux start           Start production server
-  flux create          Create new project
-
-Examples:
-  flux dev                    # Full-stack development
-  flux frontend               # Frontend only (port 5173)
-  flux backend                # Backend only (port 3001)
-  flux create my-app          # Create new project
-
-Alternative commands:
-  fluxstack dev              # Same as flux dev
-  bun run dev:frontend       # Direct frontend start
-  bun run dev:backend        # Direct backend start
-
-Environment Variables:
-  FRONTEND_PORT=5173         # Frontend port
-  BACKEND_PORT=3001          # Backend port  
-  API_URL=http://localhost:3001  # API URL for frontend
-    `)
-  }
+  // Command not found - show error and help
+  console.error(`❌ Unknown command: ${command}`)
+  console.error()
+  await cliRegistry.execute('help', args)
+  process.exit(1)
 }
 
 // Run main CLI

package/core/cli/plugin-discovery.ts

@@ -1,8 +1,8 @@
 import { existsSync } from 'fs'
 import { join } from 'path'
-import type { FluxStack } from '../plugins/types'
+import type { FluxStack } from '@/core/plugins/types'
 import { cliRegistry } from './command-registry'
-import { logger } from '../utils/logger'
+import { logger } from '@/core/utils/logger'
 
 export class CliPluginDiscovery {
   private loadedPlugins = new Set<string>()
@@ -110,7 +110,7 @@ export class CliPluginDiscovery {
     }
   }
 
-  private registerPluginCommands(plugin: Plugin): void {
+  private registerPluginCommands(plugin: FluxStack.Plugin): void {
     if (!plugin.commands || this.loadedPlugins.has(plugin.name)) {
       return
     }

package/core/client/hooks/index.ts

@@ -3,5 +3,5 @@
  * FluxStack hook utilities exports
  */
 
-export { createAuthHook } from './useAuth.js'
-export type { AuthHook } from './useAuth.js'
+export { createAuthHook } from './useAuth'
+export type { AuthHook } from './useAuth'

package/core/client/hooks/state-validator.ts

@@ -1,6 +1,6 @@
 // 🔥 State Validation Utilities
 
-import type { StateValidation, StateConflict, HybridState } from '../../types/types'
+import type { StateValidation, StateConflict, HybridState } from '@/core/types/types'
 
 export class StateValidator {
   /**

package/core/client/hooks/useAuth.ts

@@ -3,7 +3,7 @@
  * Core FluxStack authentication utilities
  */
 
-import type { BaseUser, BaseUserStore } from '../state/index.js'
+import type { BaseUser, BaseUserStore } from '../state/index'
 
 /**
  * Create authentication hook for a user store

package/core/client/hooks/useChunkedUpload.ts

@@ -5,7 +5,7 @@ import type {
   FileUploadCompleteMessage,
   FileUploadProgressResponse,
   FileUploadCompleteResponse
-} from '../../types/types'
+} from '@/core/types/types'
 
 export interface ChunkedUploadOptions {
   chunkSize?: number // Default 64KB

package/core/client/hooks/useHybridLiveComponent.ts

@@ -12,7 +12,7 @@ import type {
   HybridComponentOptions,
   WebSocketMessage,
   WebSocketResponse
-} from '../../types/types'
+} from '@/core/types/types'
 
 // Client-side state persistence for reconnection
 interface PersistedComponentState {

package/core/client/hooks/useWebSocket.ts

@@ -1,7 +1,7 @@
 // 🔥 WebSocket Hook for Live Components
 
 import { useState, useEffect, useCallback, useRef } from 'react'
-import type { WebSocketMessage, WebSocketResponse } from '../../types/types'
+import type { WebSocketMessage, WebSocketResponse } from '@/core/types/types'
 
 // Re-export types for easier importing
 export type { WebSocketMessage, WebSocketResponse }

package/core/config/env.ts

@@ -3,7 +3,7 @@
  * Handles environment variable processing and precedence
  */
 
-import { env, helpers } from '../utils/env'
+import { env, helpers } from '@/core/utils/env'
 import type { FluxStackConfig, LogLevel, BuildTarget, LogFormat } from './schema'
 
 export interface EnvironmentInfo {

package/core/config/runtime-config.ts

@@ -6,11 +6,11 @@
 import { env, createNamespace } from '../utils/env'
 import type { FluxStackConfig } from './schema'
 import { defaultFluxStackConfig } from './schema'
-import { loggerConfig } from '../../config/logger.config'
-import { clientConfig } from '../../config/client.config'
-import { serverConfig } from '../../config/server.config'
-import { monitoringConfig } from '../../config/monitoring.config'
-import { appConfig } from '../../config/app.config'
+import { loggerConfig } from '@/config/logger.config'
+import { clientConfig } from '@/config/client.config'
+import { serverConfig } from '@/config/server.config'
+import { monitoringConfig } from '@/config/monitoring.config'
+import { appConfig } from '@/config/app.config'
 
 /**
  * Runtime Configuration Builder

package/core/config/schema.ts

@@ -209,6 +209,15 @@ export interface FluxStackConfig {
   auth?: AuthConfig
   email?: EmailConfig
   storage?: StorageConfig
+  staticFiles?: {
+    publicDir?: string
+    uploadsDir?: string
+    cacheMaxAge?: number
+    enableUploads?: boolean
+    enablePublic?: boolean
+    publicRoute?: string
+    uploadsRoute?: string
+  }
 
   // Environment-specific overrides
   environments?: {