create-fluxstack 1.10.1 → 1.12.0

package/core/cli/commands/build.ts

@@ -0,0 +1,79 @@
+/**
+ * FluxStack CLI - Build Command
+ * Build the application for production
+ */
+
+import type { CLICommand } from '../command-registry'
+import { FluxStackBuilder } from '@core/build'
+import { fluxStackConfig } from '@config'
+
+export const buildCommand: CLICommand = {
+  name: 'build',
+  description: 'Build the application for production',
+  category: 'Build',
+  usage: 'flux build [options]',
+  examples: [
+    'flux build                  # Build both frontend and backend',
+    'flux build --frontend-only  # Build only frontend',
+    'flux build --backend-only   # Build only backend'
+  ],
+  options: [
+    {
+      name: 'frontend-only',
+      description: 'Build only frontend',
+      type: 'boolean'
+    },
+    {
+      name: 'backend-only',
+      description: 'Build only backend',
+      type: 'boolean'
+    },
+    {
+      name: 'production',
+      description: 'Build for production (minified)',
+      type: 'boolean',
+      default: true
+    }
+  ],
+  handler: async (args, options, context) => {
+    const config = fluxStackConfig
+
+    // Load plugins for build hooks
+    const { PluginRegistry } = await import('@core/plugins/registry')
+    const { PluginManager } = await import('@core/plugins/manager')
+    const pluginRegistry = new PluginRegistry({ config, logger: context.logger })
+    const pluginManager = new PluginManager({ config, logger: context.logger })
+
+    try {
+      await pluginManager.initialize()
+      // Sync plugins to registry (same as framework does)
+      const discoveredPlugins = pluginManager.getRegistry().getAll()
+      for (const plugin of discoveredPlugins) {
+        if (!pluginRegistry.has(plugin.name)) {
+          (pluginRegistry as any).plugins.set(plugin.name, plugin)
+          if (plugin.dependencies) {
+            (pluginRegistry as any).dependencies.set(plugin.name, plugin.dependencies)
+          }
+        }
+      }
+      try {
+        (pluginRegistry as any).updateLoadOrder()
+      } catch (error) {
+        const plugins = (pluginRegistry as any).plugins as Map<string, any>
+        ;(pluginRegistry as any).loadOrder = Array.from(plugins.keys())
+      }
+    } catch (error) {
+      context.logger.warn('Failed to load plugins for build hooks', { error })
+    }
+
+    const builder = new FluxStackBuilder(config, pluginRegistry)
+
+    if (options['frontend-only']) {
+      await builder.buildClient()
+    } else if (options['backend-only']) {
+      await builder.buildServer()
+    } else {
+      await builder.build()
+    }
+  }
+}

package/core/cli/commands/create.ts

@@ -0,0 +1,54 @@
+/**
+ * FluxStack CLI - Create Command
+ * Create a new FluxStack project
+ */
+
+import type { CLICommand } from '../command-registry'
+import { ProjectCreator } from '@core/templates/create-project'
+
+export const createCommand: CLICommand = {
+  name: 'create',
+  description: 'Create a new FluxStack project',
+  category: 'Project',
+  usage: 'flux create <project-name> [template]',
+  examples: [
+    'flux create my-app          # Create basic project',
+    'flux create my-app full     # Create full-featured project'
+  ],
+  arguments: [
+    {
+      name: 'project-name',
+      description: 'Name of the project to create',
+      required: true,
+      type: 'string'
+    },
+    {
+      name: 'template',
+      description: 'Project template to use',
+      required: false,
+      type: 'string',
+      default: 'basic',
+      choices: ['basic', 'full']
+    }
+  ],
+  handler: async (args, options, context) => {
+    const [projectName, template] = args
+
+    if (!/^[a-zA-Z0-9-_]+$/.test(projectName)) {
+      console.error("❌ Project name can only contain letters, numbers, hyphens, and underscores")
+      return
+    }
+
+    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))
+      throw error
+    }
+  }
+}

package/core/cli/commands/dev.ts

@@ -0,0 +1,101 @@
+/**
+ * FluxStack CLI - Dev Command
+ * Start full-stack development server with hot reload
+ */
+
+import type { CLICommand } from '../command-registry'
+import { serverConfig, clientConfig } from '@config'
+
+export const devCommand: CLICommand = {
+  name: 'dev',
+  description: 'Start full-stack development server',
+  category: 'Development',
+  usage: 'flux dev [options]',
+  examples: [
+    'flux dev                    # Start full-stack development',
+    'flux dev --port 4000        # Start on custom port',
+    'flux dev --frontend-only    # Start only frontend (Vite)',
+    'flux dev --backend-only     # Start only backend (Elysia)'
+  ],
+  options: [
+    {
+      name: 'port',
+      short: 'p',
+      description: 'Port for backend server',
+      type: 'number',
+      default: serverConfig.server.port
+    },
+    {
+      name: 'frontend-port',
+      description: 'Port for frontend server',
+      type: 'number',
+      default: clientConfig.vite.port
+    },
+    {
+      name: 'frontend-only',
+      short: 'f',
+      description: 'Start only the frontend (Vite dev server)',
+      type: 'boolean',
+      default: false
+    },
+    {
+      name: 'backend-only',
+      short: 'b',
+      description: 'Start only the backend (Elysia server)',
+      type: 'boolean',
+      default: false
+    }
+  ],
+  handler: async (args, options, context) => {
+    const { spawn } = await import("child_process")
+
+    const frontendOnly = options['frontend-only'] === true
+    const backendOnly = options['backend-only'] === true
+
+    if (frontendOnly && backendOnly) {
+      console.error('❌ Cannot use --frontend-only and --backend-only together')
+      process.exit(1)
+    }
+
+    // Determine mode and entry point
+    const mode = frontendOnly ? 'Frontend only' : backendOnly ? 'Backend only' : 'Full-stack'
+
+    // Frontend-only: roda direto do core (não passa pelo app/server/index.ts)
+    const entryPoint = frontendOnly
+      ? 'core/client/standalone-entry.ts'
+      : 'app/server/index.ts'
+
+    const fluxstackMode = backendOnly ? 'backend-only' : 'full-stack'
+
+    console.log(`⚡ Starting ${mode} development server...`)
+
+    const devProcess = spawn("bun", ["--watch", entryPoint], {
+      stdio: "inherit",
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        FRONTEND_PORT: options['frontend-port'].toString(),
+        BACKEND_PORT: options.port.toString(),
+        FLUXSTACK_MODE: fluxstackMode
+      }
+    })
+
+    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
+    return new Promise((resolve) => {
+      devProcess.on('exit', resolve)
+    })
+  }
+}

package/core/cli/commands/help.ts

@@ -0,0 +1,34 @@
+/**
+ * FluxStack CLI - Help Command
+ * Display help information for commands
+ */
+
+import type { CLICommand } from '../command-registry'
+import { cliRegistry } from '../command-registry'
+
+export const helpCommand: CLICommand = {
+  name: 'help',
+  description: 'Show help information',
+  category: 'General',
+  aliases: ['h', '--help', '-h'],
+  arguments: [
+    {
+      name: 'command',
+      description: 'Command to show help for',
+      required: false
+    }
+  ],
+  handler: async (args, options, context) => {
+    if (args[0]) {
+      const targetCommand = cliRegistry.get(args[0])
+      if (targetCommand) {
+        cliRegistry.showCommandHelp(targetCommand)
+      } else {
+        console.error(`❌ Unknown command: ${args[0]}`)
+        cliRegistry.showHelp()
+      }
+    } else {
+      cliRegistry.showHelp()
+    }
+  }
+}

package/core/cli/commands/index.ts

@@ -0,0 +1,34 @@
+/**
+ * FluxStack CLI Commands
+ * Central export for all command modules
+ */
+
+// General commands
+export { helpCommand } from './help'
+
+// Development commands
+export { devCommand } from './dev'
+
+// Build commands
+export { buildCommand } from './build'
+
+// Project commands
+export { createCommand } from './create'
+
+// Plugin commands (management)
+export { makePluginCommand } from './make-plugin'
+
+// Export all commands as an array for easy registration
+import { helpCommand } from './help'
+import { devCommand } from './dev'
+import { buildCommand } from './build'
+import { createCommand } from './create'
+import { makePluginCommand } from './make-plugin'
+
+export const builtInCommands = [
+  helpCommand,
+  devCommand,
+  buildCommand,
+  createCommand,
+  makePluginCommand,
+]

package/core/cli/commands/make-plugin.ts

@@ -0,0 +1,90 @@
+/**
+ * FluxStack CLI - Make Plugin Command
+ * Create a new FluxStack plugin
+ */
+
+import type { CLICommand } from '../command-registry'
+
+export const makePluginCommand: CLICommand = {
+  name: 'make:plugin',
+  description: 'Create a new FluxStack plugin',
+  category: 'Plugins',
+  usage: 'flux make:plugin <name> [options]',
+  aliases: ['create:plugin'],
+  examples: [
+    'flux make:plugin my-plugin              # Create basic plugin',
+    'flux make:plugin my-plugin --template full    # Create full plugin with server/client',
+    'flux make:plugin auth --template server       # Create server-only plugin'
+  ],
+  arguments: [
+    {
+      name: 'name',
+      description: 'Name of the plugin to create',
+      required: true,
+      type: 'string'
+    }
+  ],
+  options: [
+    {
+      name: 'template',
+      short: 't',
+      description: 'Plugin template to use',
+      type: 'string',
+      choices: ['basic', 'full', 'server', 'client'],
+      default: 'basic'
+    },
+    {
+      name: 'description',
+      short: 'd',
+      description: 'Plugin description',
+      type: 'string',
+      default: 'A FluxStack plugin'
+    },
+    {
+      name: 'force',
+      short: 'f',
+      description: 'Overwrite existing plugin',
+      type: 'boolean',
+      default: false
+    }
+  ],
+  handler: async (args, options, context) => {
+    const [name] = args
+
+    if (!/^[a-zA-Z0-9-_]+$/.test(name)) {
+      console.error("❌ Plugin name can only contain letters, numbers, hyphens, and underscores")
+      return
+    }
+
+    // Use the plugin generator
+    const { generatorRegistry } = await import('../generators/index')
+    const pluginGenerator = generatorRegistry.get('plugin')
+
+    if (!pluginGenerator) {
+      console.error("❌ Plugin generator not found")
+      return
+    }
+
+    const generatorContext = {
+      workingDir: context.workingDir,
+      config: context.config,
+      logger: context.logger,
+      utils: context.utils
+    }
+
+    const generatorOptions = {
+      name,
+      template: options.template,
+      force: options.force,
+      dryRun: false,
+      description: options.description
+    }
+
+    try {
+      await pluginGenerator.generate(generatorContext, generatorOptions)
+    } catch (error) {
+      console.error("❌ Failed to create plugin:", error instanceof Error ? error.message : String(error))
+      throw error
+    }
+  }
+}

package/core/cli/commands/plugin-add.ts

@@ -0,0 +1,197 @@
+/**
+ * FluxStack CLI - Plugin Add Command
+ * Safely install and whitelist NPM plugins
+ */
+
+import { Command } from 'commander'
+import { readFileSync, writeFileSync, existsSync } from 'fs'
+import { join } from 'path'
+import { $ } from 'bun'
+import chalk from 'chalk'
+
+interface PluginAddOptions {
+  skipAudit?: boolean
+  skipConfirmation?: boolean
+}
+
+export function createPluginAddCommand(): Command {
+  const command = new Command('plugin:add')
+    .description('Install and whitelist an NPM plugin securely')
+    .argument('<plugin-name>', 'Name of the plugin to install (e.g., fluxstack-plugin-auth)')
+    .option('--skip-audit', 'Skip npm audit check')
+    .option('--skip-confirmation', 'Skip confirmation prompt')
+    .action(async (pluginName: string, options: PluginAddOptions) => {
+      console.log(chalk.blue('\n🔌 FluxStack Plugin Installer\n'))
+
+      try {
+        // 1. Validate plugin name
+        if (!isValidPluginName(pluginName)) {
+          console.error(chalk.red(`❌ Invalid plugin name: ${pluginName}`))
+          console.log(chalk.yellow('\n📝 Valid plugin names:'))
+          console.log('  - fluxstack-plugin-*')
+          console.log('  - fplugin-*')
+          console.log('  - @fluxstack/plugin-*')
+          console.log('  - @fplugin/*')
+          console.log('  - @org/fluxstack-plugin-*')
+          console.log('  - @org/fplugin-*')
+          process.exit(1)
+        }
+
+        // 2. Check if plugin already installed
+        const packageJsonPath = join(process.cwd(), 'package.json')
+        if (!existsSync(packageJsonPath)) {
+          console.error(chalk.red('❌ package.json not found'))
+          process.exit(1)
+        }
+
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+        const isAlreadyInstalled =
+          packageJson.dependencies?.[pluginName] ||
+          packageJson.devDependencies?.[pluginName]
+
+        if (isAlreadyInstalled && !options.skipConfirmation) {
+          console.log(chalk.yellow(`⚠️  Plugin ${pluginName} is already installed`))
+          console.log(chalk.yellow('   Will only update whitelist\n'))
+        }
+
+        // 3. Audit plugin (unless skipped)
+        if (!options.skipAudit && !isAlreadyInstalled) {
+          console.log(chalk.blue('🔍 Auditing plugin security...\n'))
+
+          try {
+            // Get plugin info
+            const info = await $`npm view ${pluginName} repository homepage version description`.text()
+            console.log(chalk.gray(info))
+
+            // Run audit
+            console.log(chalk.blue('\n🛡️  Running npm audit...\n'))
+            const auditResult = await $`npm audit ${pluginName}`.text()
+            console.log(chalk.gray(auditResult))
+          } catch (error) {
+            console.warn(chalk.yellow(`⚠️  Could not audit plugin: ${error instanceof Error ? error.message : 'Unknown error'}`))
+          }
+        }
+
+        // 4. Confirmation prompt (unless skipped)
+        if (!options.skipConfirmation) {
+          console.log(chalk.yellow('\n⚠️  Security Warning:'))
+          console.log(chalk.yellow('   NPM plugins can execute arbitrary code'))
+          console.log(chalk.yellow('   Only install plugins from trusted sources\n'))
+
+          const answer = prompt(chalk.blue('Continue with installation? (yes/no): '))
+          if (answer?.toLowerCase() !== 'yes' && answer?.toLowerCase() !== 'y') {
+            console.log(chalk.red('❌ Installation cancelled'))
+            process.exit(0)
+          }
+        }
+
+        // 5. Install plugin
+        if (!isAlreadyInstalled) {
+          console.log(chalk.blue(`\n📦 Installing ${pluginName}...\n`))
+          await $`bun add ${pluginName}`.quiet()
+          console.log(chalk.green(`✅ Plugin installed successfully`))
+        }
+
+        // 6. Update .env file
+        console.log(chalk.blue('\n🔧 Updating configuration...\n'))
+        updateEnvFile(pluginName)
+
+        // 7. Success message
+        console.log(chalk.green('\n✅ Plugin setup complete!\n'))
+        console.log(chalk.blue('📋 What was done:'))
+        if (!isAlreadyInstalled) {
+          console.log(chalk.gray(`   • Installed ${pluginName}`))
+        }
+        console.log(chalk.gray('   • Enabled NPM plugin discovery (PLUGINS_DISCOVER_NPM=true)'))
+        console.log(chalk.gray(`   • Added ${pluginName} to whitelist (PLUGINS_ALLOWED)`))
+
+        console.log(chalk.blue('\n🚀 Next steps:'))
+        console.log(chalk.gray('   1. Restart your dev server: bun run dev'))
+        console.log(chalk.gray('   2. Plugin will be auto-discovered and loaded'))
+        console.log(chalk.gray('   3. Check logs for plugin initialization'))
+
+      } catch (error) {
+        console.error(chalk.red('\n❌ Failed to install plugin:'))
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)))
+        process.exit(1)
+      }
+    })
+
+  return command
+}
+
+/**
+ * Validate plugin name against FluxStack naming conventions
+ */
+function isValidPluginName(name: string): boolean {
+  const patterns = [
+    /^fluxstack-plugin-/,
+    /^fplugin-/,
+    /^@fluxstack\/plugin-/,
+    /^@fplugin\//,
+    /^@[\w-]+\/fluxstack-plugin-/,
+    /^@[\w-]+\/fplugin-/,
+  ]
+
+  return patterns.some(pattern => pattern.test(name))
+}
+
+/**
+ * Update .env file with plugin configuration
+ */
+function updateEnvFile(pluginName: string): void {
+  const envPath = join(process.cwd(), '.env')
+
+  if (!existsSync(envPath)) {
+    console.warn(chalk.yellow('⚠️  .env file not found, creating...'))
+    writeFileSync(envPath, '', 'utf-8')
+  }
+
+  let envContent = readFileSync(envPath, 'utf-8')
+  let updated = false
+
+  // 1. Enable NPM plugin discovery
+  if (/^PLUGINS_DISCOVER_NPM=false/m.test(envContent)) {
+    envContent = envContent.replace(
+      /^PLUGINS_DISCOVER_NPM=false/m,
+      'PLUGINS_DISCOVER_NPM=true'
+    )
+    updated = true
+    console.log(chalk.gray('   • Set PLUGINS_DISCOVER_NPM=true'))
+  } else if (!/^PLUGINS_DISCOVER_NPM=/m.test(envContent)) {
+    envContent += '\n# Plugin Discovery\nPLUGINS_DISCOVER_NPM=true\n'
+    updated = true
+    console.log(chalk.gray('   • Added PLUGINS_DISCOVER_NPM=true'))
+  }
+
+  // 2. Add plugin to whitelist
+  const allowedPluginsRegex = /^PLUGINS_ALLOWED=(.*)$/m
+  const match = envContent.match(allowedPluginsRegex)
+
+  if (match) {
+    const currentPlugins = match[1]
+      .split(',')
+      .map(p => p.trim())
+      .filter(p => p.length > 0)
+
+    if (!currentPlugins.includes(pluginName)) {
+      const newPlugins = [...currentPlugins, pluginName].join(',')
+      envContent = envContent.replace(
+        allowedPluginsRegex,
+        `PLUGINS_ALLOWED=${newPlugins}`
+      )
+      updated = true
+      console.log(chalk.gray(`   • Added ${pluginName} to PLUGINS_ALLOWED`))
+    } else {
+      console.log(chalk.gray(`   • ${pluginName} already in PLUGINS_ALLOWED`))
+    }
+  } else {
+    envContent += `PLUGINS_ALLOWED=${pluginName}\n`
+    updated = true
+    console.log(chalk.gray(`   • Created PLUGINS_ALLOWED with ${pluginName}`))
+  }
+
+  if (updated) {
+    writeFileSync(envPath, envContent, 'utf-8')
+  }
+}

package/core/cli/commands/plugin-deps.ts

@@ -4,8 +4,8 @@
 
 import { Command } from 'commander'
 import chalk from 'chalk'
-import { PluginDependencyManager } from '@/core/plugins/dependency-manager'
-import { PluginRegistry } from '@/core/plugins/registry'
+import { PluginDependencyManager } from '@core/plugins/dependency-manager'
+import { PluginRegistry } from '@core/plugins/registry'
 import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'