create-fluxstack 1.10.1 → 1.12.0

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

@@ -0,0 +1,208 @@
+/**
+ * FluxStack CLI - Plugin List Command
+ * List all plugins (installed, whitelisted, discovered)
+ */
+
+import { Command } from 'commander'
+import { readFileSync, existsSync } from 'fs'
+import { join } from 'path'
+import chalk from 'chalk'
+
+export function createPluginListCommand(): Command {
+  const command = new Command('plugin:list')
+    .description('List all plugins (installed, whitelisted, and discovered)')
+    .option('--installed', 'Show only installed NPM plugins')
+    .option('--whitelisted', 'Show only whitelisted plugins')
+    .option('--json', 'Output as JSON')
+    .action(async (options: { installed?: boolean; whitelisted?: boolean; json?: boolean }) => {
+      try {
+        const info = getPluginInfo()
+
+        if (options.json) {
+          console.log(JSON.stringify(info, null, 2))
+          return
+        }
+
+        console.log(chalk.blue('\n🔌 FluxStack Plugin Status\n'))
+
+        // Configuration
+        console.log(chalk.bold('⚙️  Configuration:'))
+        console.log(chalk.gray(`   NPM Plugin Discovery: ${info.config.npmDiscoveryEnabled ? chalk.green('enabled') : chalk.red('disabled')}`))
+        console.log(chalk.gray(`   Project Plugin Discovery: ${info.config.projectDiscoveryEnabled ? chalk.green('enabled') : chalk.red('disabled')}`))
+        console.log()
+
+        // Whitelisted plugins
+        if (!options.installed) {
+          console.log(chalk.bold('🛡️  Whitelisted NPM Plugins:'))
+          if (info.whitelisted.length === 0) {
+            console.log(chalk.gray('   (none)'))
+          } else {
+            info.whitelisted.forEach(plugin => {
+              const isInstalled = info.installed.includes(plugin)
+              const status = isInstalled ? chalk.green('✓ installed') : chalk.yellow('⚠ not installed')
+              console.log(chalk.gray(`   • ${plugin} ${status}`))
+            })
+          }
+          console.log()
+        }
+
+        // Installed NPM plugins
+        if (!options.whitelisted) {
+          console.log(chalk.bold('📦 Installed NPM Plugins:'))
+          if (info.installed.length === 0) {
+            console.log(chalk.gray('   (none)'))
+          } else {
+            info.installed.forEach(plugin => {
+              const isWhitelisted = info.whitelisted.includes(plugin)
+              let status = ''
+              if (!info.config.npmDiscoveryEnabled) {
+                status = chalk.red('✗ discovery disabled')
+              } else if (!isWhitelisted) {
+                status = chalk.red('✗ not whitelisted (blocked)')
+              } else {
+                status = chalk.green('✓ whitelisted (loaded)')
+              }
+              console.log(chalk.gray(`   • ${plugin} ${status}`))
+            })
+          }
+          console.log()
+        }
+
+        // Project plugins (from plugins/ directory)
+        console.log(chalk.bold('📁 Project Plugins (plugins/):'))
+        if (info.projectPlugins.length === 0) {
+          console.log(chalk.gray('   (none found)'))
+        } else {
+          info.projectPlugins.forEach(plugin => {
+            const status = info.config.projectDiscoveryEnabled
+              ? chalk.green('✓ auto-discovered')
+              : chalk.red('✗ discovery disabled')
+            console.log(chalk.gray(`   • ${plugin} ${status}`))
+          })
+        }
+        console.log()
+
+        // Summary
+        console.log(chalk.bold('📊 Summary:'))
+        console.log(chalk.gray(`   Total NPM plugins installed: ${info.installed.length}`))
+        console.log(chalk.gray(`   Total NPM plugins whitelisted: ${info.whitelisted.length}`))
+        console.log(chalk.gray(`   Total project plugins: ${info.projectPlugins.length}`))
+
+        const blockedCount = info.installed.filter(p => !info.whitelisted.includes(p)).length
+        if (blockedCount > 0) {
+          console.log(chalk.yellow(`   ⚠️  ${blockedCount} installed plugin(s) blocked (not whitelisted)`))
+        }
+        console.log()
+
+        // Help
+        if (info.installed.length > 0 && !info.config.npmDiscoveryEnabled) {
+          console.log(chalk.yellow('💡 Tip: Enable NPM plugin discovery with:'))
+          console.log(chalk.gray('   echo "PLUGINS_DISCOVER_NPM=true" >> .env'))
+          console.log()
+        }
+
+        if (blockedCount > 0 && info.config.npmDiscoveryEnabled) {
+          console.log(chalk.yellow('💡 Tip: Add blocked plugins to whitelist with:'))
+          console.log(chalk.gray('   bun run fluxstack plugin:add <plugin-name>'))
+          console.log()
+        }
+
+      } catch (error) {
+        console.error(chalk.red('\n❌ Failed to list plugins:'))
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)))
+        process.exit(1)
+      }
+    })
+
+  return command
+}
+
+interface PluginInfo {
+  config: {
+    npmDiscoveryEnabled: boolean
+    projectDiscoveryEnabled: boolean
+  }
+  whitelisted: string[]
+  installed: string[]
+  projectPlugins: string[]
+}
+
+/**
+ * Get plugin information from package.json and .env
+ */
+function getPluginInfo(): PluginInfo {
+  const info: PluginInfo = {
+    config: {
+      npmDiscoveryEnabled: false,
+      projectDiscoveryEnabled: true,
+    },
+    whitelisted: [],
+    installed: [],
+    projectPlugins: [],
+  }
+
+  // Read .env for configuration
+  const envPath = join(process.cwd(), '.env')
+  if (existsSync(envPath)) {
+    const envContent = readFileSync(envPath, 'utf-8')
+
+    // Check NPM discovery enabled
+    const npmDiscoveryMatch = envContent.match(/^PLUGINS_DISCOVER_NPM=(.*)$/m)
+    if (npmDiscoveryMatch) {
+      info.config.npmDiscoveryEnabled = npmDiscoveryMatch[1].toLowerCase() === 'true'
+    }
+
+    // Check project discovery enabled
+    const projectDiscoveryMatch = envContent.match(/^PLUGINS_DISCOVER_PROJECT=(.*)$/m)
+    if (projectDiscoveryMatch) {
+      info.config.projectDiscoveryEnabled = projectDiscoveryMatch[1].toLowerCase() === 'true'
+    }
+
+    // Get whitelisted plugins
+    const whitelistMatch = envContent.match(/^PLUGINS_ALLOWED=(.*)$/m)
+    if (whitelistMatch) {
+      info.whitelisted = whitelistMatch[1]
+        .split(',')
+        .map(p => p.trim())
+        .filter(p => p.length > 0)
+    }
+  }
+
+  // Read package.json for installed plugins
+  const packageJsonPath = join(process.cwd(), 'package.json')
+  if (existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies,
+    }
+
+    // Find FluxStack plugins
+    const pluginPatterns = [
+      /^fluxstack-plugin-/,
+      /^fplugin-/,
+      /^@fluxstack\/plugin-/,
+      /^@fplugin\//,
+    ]
+
+    info.installed = Object.keys(allDeps).filter(name =>
+      pluginPatterns.some(pattern => pattern.test(name))
+    )
+  }
+
+  // Scan plugins/ directory for project plugins
+  const pluginsDir = join(process.cwd(), 'plugins')
+  if (existsSync(pluginsDir)) {
+    const fs = require('fs')
+    try {
+      const entries = fs.readdirSync(pluginsDir, { withFileTypes: true })
+      info.projectPlugins = entries
+        .filter((entry: any) => entry.isDirectory())
+        .map((entry: any) => entry.name)
+    } catch (error) {
+      // Ignore errors reading directory
+    }
+  }
+
+  return info
+}

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

@@ -0,0 +1,170 @@
+/**
+ * FluxStack CLI - Plugin Remove Command
+ * Safely remove and un-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 PluginRemoveOptions {
+  skipConfirmation?: boolean
+  keepInstalled?: boolean
+}
+
+export function createPluginRemoveCommand(): Command {
+  const command = new Command('plugin:remove')
+    .description('Remove plugin from whitelist and optionally uninstall')
+    .argument('<plugin-name>', 'Name of the plugin to remove (e.g., fluxstack-plugin-auth)')
+    .option('--skip-confirmation', 'Skip confirmation prompt')
+    .option('--keep-installed', 'Keep plugin installed, only remove from whitelist')
+    .action(async (pluginName: string, options: PluginRemoveOptions) => {
+      console.log(chalk.blue('\n🔌 FluxStack Plugin Remover\n'))
+
+      try {
+        // 1. Check if plugin is 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 isInstalled =
+          packageJson.dependencies?.[pluginName] ||
+          packageJson.devDependencies?.[pluginName]
+
+        if (!isInstalled && !options.keepInstalled) {
+          console.log(chalk.yellow(`⚠️  Plugin ${pluginName} is not installed`))
+          console.log(chalk.yellow('   Will only remove from whitelist\n'))
+        }
+
+        // 2. Confirmation prompt (unless skipped)
+        if (!options.skipConfirmation) {
+          const action = options.keepInstalled
+            ? 'remove from whitelist'
+            : 'uninstall and remove from whitelist'
+
+          const answer = prompt(chalk.yellow(`Remove ${pluginName}? This will ${action}. (yes/no): `))
+          if (answer?.toLowerCase() !== 'yes' && answer?.toLowerCase() !== 'y') {
+            console.log(chalk.red('❌ Removal cancelled'))
+            process.exit(0)
+          }
+        }
+
+        // 3. Remove from whitelist
+        console.log(chalk.blue('\n🔧 Updating configuration...\n'))
+        const removed = removeFromWhitelist(pluginName)
+
+        if (!removed) {
+          console.log(chalk.yellow(`⚠️  Plugin ${pluginName} was not in whitelist`))
+        } else {
+          console.log(chalk.gray(`   • Removed ${pluginName} from PLUGINS_ALLOWED`))
+        }
+
+        // 4. Uninstall plugin (unless --keep-installed)
+        if (!options.keepInstalled && isInstalled) {
+          console.log(chalk.blue(`\n📦 Uninstalling ${pluginName}...\n`))
+          await $`bun remove ${pluginName}`.quiet()
+          console.log(chalk.green(`✅ Plugin uninstalled successfully`))
+        }
+
+        // 5. Check if should disable NPM discovery
+        checkAndDisableNpmDiscovery()
+
+        // 6. Success message
+        console.log(chalk.green('\n✅ Plugin removal complete!\n'))
+        console.log(chalk.blue('📋 What was done:'))
+        console.log(chalk.gray(`   • Removed ${pluginName} from whitelist (PLUGINS_ALLOWED)`))
+        if (!options.keepInstalled && isInstalled) {
+          console.log(chalk.gray(`   • Uninstalled ${pluginName}`))
+        }
+
+        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 no longer be loaded'))
+
+      } catch (error) {
+        console.error(chalk.red('\n❌ Failed to remove plugin:'))
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)))
+        process.exit(1)
+      }
+    })
+
+  return command
+}
+
+/**
+ * Remove plugin from whitelist in .env file
+ */
+function removeFromWhitelist(pluginName: string): boolean {
+  const envPath = join(process.cwd(), '.env')
+
+  if (!existsSync(envPath)) {
+    return false
+  }
+
+  let envContent = readFileSync(envPath, 'utf-8')
+  const allowedPluginsRegex = /^PLUGINS_ALLOWED=(.*)$/m
+  const match = envContent.match(allowedPluginsRegex)
+
+  if (!match) {
+    return false
+  }
+
+  const currentPlugins = match[1]
+    .split(',')
+    .map(p => p.trim())
+    .filter(p => p.length > 0)
+
+  if (!currentPlugins.includes(pluginName)) {
+    return false
+  }
+
+  const newPlugins = currentPlugins.filter(p => p !== pluginName)
+  envContent = envContent.replace(
+    allowedPluginsRegex,
+    `PLUGINS_ALLOWED=${newPlugins.join(',')}`
+  )
+
+  writeFileSync(envPath, envContent, 'utf-8')
+  return true
+}
+
+/**
+ * Check if whitelist is empty and disable NPM discovery if so
+ */
+function checkAndDisableNpmDiscovery(): void {
+  const envPath = join(process.cwd(), '.env')
+
+  if (!existsSync(envPath)) {
+    return
+  }
+
+  let envContent = readFileSync(envPath, 'utf-8')
+  const allowedPluginsRegex = /^PLUGINS_ALLOWED=(.*)$/m
+  const match = envContent.match(allowedPluginsRegex)
+
+  if (!match) {
+    return
+  }
+
+  const currentPlugins = match[1]
+    .split(',')
+    .map(p => p.trim())
+    .filter(p => p.length > 0)
+
+  // If whitelist is empty, disable NPM discovery
+  if (currentPlugins.length === 0) {
+    if (/^PLUGINS_DISCOVER_NPM=true/m.test(envContent)) {
+      envContent = envContent.replace(
+        /^PLUGINS_DISCOVER_NPM=true/m,
+        'PLUGINS_DISCOVER_NPM=false'
+      )
+      writeFileSync(envPath, envContent, 'utf-8')
+      console.log(chalk.gray('   • Disabled NPM plugin discovery (whitelist empty)'))
+    }
+  }
+}