nex-framework-cli 1.0.1

package/src/services/nex-marketplace/NEXMarketplace.js

@@ -0,0 +1,964 @@
+/**
+ * NEX Marketplace - Complete Agent Marketplace System
+ * Integrates with Supabase, local registry, and NEX Store
+ */
+
+import fs from 'fs-extra'
+import path from 'path'
+import yaml from 'yaml'
+import chalk from 'chalk'
+import ora from 'ora'
+import semver from 'semver'
+import { createClient } from '@supabase/supabase-js'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default class NEXMarketplace {
+  constructor(options = {}) {
+    this.projectRoot = options.projectRoot || process.cwd()
+    this.registryPath = options.registryPath || path.join(this.projectRoot, 'registry')
+    this.installPath = options.installPath || path.join(this.projectRoot, '.nex-core', 'agents')
+    
+    // Supabase client
+    this.supabase = null
+    this.initializeSupabase()
+    
+    // Config
+    this.config = null
+    this.loadConfig()
+  }
+
+  /**
+   * Initialize Supabase client
+   */
+  initializeSupabase() {
+    const supabaseUrl = process.env.VITE_SUPABASE_URL
+    const supabaseKey = process.env.VITE_SUPABASE_ANON_KEY
+    
+    if (supabaseUrl && supabaseKey) {
+      this.supabase = createClient(supabaseUrl, supabaseKey)
+    } else {
+      console.warn(chalk.yellow('⚠️  Supabase not configured. Marketplace will work in local-only mode.'))
+    }
+  }
+
+  /**
+   * Load registry configuration
+   */
+  async loadConfig() {
+    const configPath = path.join(this.registryPath, '.meta', 'registry.yaml')
+    
+    if (await fs.pathExists(configPath)) {
+      const configFile = await fs.readFile(configPath, 'utf8')
+      this.config = yaml.parse(configFile)
+    } else {
+      this.config = this.getDefaultConfig()
+    }
+    
+    return this.config
+  }
+
+  /**
+   * Default configuration
+   */
+  getDefaultConfig() {
+    return {
+      registry: {
+        name: 'NEX Expert Agent Marketplace',
+        version: '1.0.0',
+        type: 'hybrid'
+      },
+      defaults: {
+        install_location: '.nex-core/agents',
+        method: 'symlink',
+        backup_before_update: true
+      }
+    }
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // SEARCH & DISCOVERY
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * Search for agents
+   */
+  async search(query, options = {}) {
+    const spinner = ora(`Searching for "${query}"...`).start()
+    
+    try {
+      let results = []
+      
+      // Search in Supabase if available
+      if (this.supabase) {
+        results = await this.searchRemote(query, options)
+      }
+      
+      // Also search local registry
+      const localResults = await this.searchLocal(query, options)
+      
+      // Merge results (deduplicate by agent_id)
+      const merged = this.mergeResults(results, localResults)
+      
+      spinner.succeed(`Found ${merged.length} agents`)
+      
+      // Display results
+      this.displaySearchResults(merged)
+      
+      return merged
+      
+    } catch (error) {
+      spinner.fail('Search failed')
+      console.error(chalk.red(`Error: ${error.message}`))
+      throw error
+    }
+  }
+
+  /**
+   * Search in Supabase
+   */
+  async searchRemote(query, options = {}) {
+    let dbQuery = this.supabase
+      .from('nex_marketplace_agents')
+      .select('*')
+      .eq('is_active', true)
+    
+    // Text search in name, description, tags
+    if (query) {
+      dbQuery = dbQuery.or(`name.ilike.%${query}%,description.ilike.%${query}%,tags.cs.{${query}}`)
+    }
+    
+    // Filters
+    if (options.category) {
+      dbQuery = dbQuery.eq('category', options.category)
+    }
+    
+    if (options.official) {
+      dbQuery = dbQuery.eq('is_official', true)
+    }
+    
+    // Ordering
+    const orderBy = options.sort || 'total_installs'
+    dbQuery = dbQuery.order(orderBy, { ascending: false })
+    
+    // Limit
+    const limit = options.limit || 50
+    dbQuery = dbQuery.limit(limit)
+    
+    const { data, error } = await dbQuery
+    
+    if (error) throw error
+    
+    return data || []
+  }
+
+  /**
+   * Search in local registry
+   */
+  async searchLocal(query, options = {}) {
+    const results = []
+    
+    const categories = ['planning', 'execution', 'community']
+    
+    for (const category of categories) {
+      const categoryPath = path.join(this.registryPath, category)
+      
+      if (!await fs.pathExists(categoryPath)) continue
+      
+      const agents = await fs.readdir(categoryPath)
+      
+      for (const agentId of agents) {
+        const manifestPath = path.join(categoryPath, agentId, 'manifest.yaml')
+        
+        if (!await fs.pathExists(manifestPath)) continue
+        
+        const manifestFile = await fs.readFile(manifestPath, 'utf8')
+        const manifest = yaml.parse(manifestFile)
+        
+        // Filter by query
+        if (query) {
+          const searchable = [
+            manifest.name,
+            manifest.description,
+            manifest.tagline,
+            ...(manifest.tags || [])
+          ].join(' ').toLowerCase()
+          
+          if (!searchable.includes(query.toLowerCase())) {
+            continue
+          }
+        }
+        
+        // Filter by category
+        if (options.category && manifest.category !== options.category) {
+          continue
+        }
+        
+        results.push(manifest)
+      }
+    }
+    
+    return results
+  }
+
+  /**
+   * Merge and deduplicate results
+   */
+  mergeResults(remote, local) {
+    const map = new Map()
+    
+    // Add remote results first (they have stats)
+    remote.forEach(agent => {
+      map.set(agent.agent_id, { ...agent, source: 'remote' })
+    })
+    
+    // Add local results if not already present
+    local.forEach(agent => {
+      if (!map.has(agent.id)) {
+        map.set(agent.id, { 
+          agent_id: agent.id,
+          ...agent, 
+          source: 'local' 
+        })
+      }
+    })
+    
+    return Array.from(map.values())
+  }
+
+  /**
+   * Display search results
+   */
+  displaySearchResults(results) {
+    if (results.length === 0) {
+      console.log(chalk.yellow('\n😕 No agents found matching your search.\n'))
+      return
+    }
+    
+    console.log('\n')
+    
+    results.forEach(agent => {
+      const icon = agent.icon || '🤖'
+      const name = agent.name
+      const version = agent.current_version || agent.version
+      const tagline = agent.tagline || agent.description?.substring(0, 60) + '...'
+      
+      console.log(chalk.bold.cyan(`${icon} ${name} v${version}`))
+      console.log(chalk.gray(`   ${tagline}`))
+      
+      if (agent.total_installs || agent.stats?.installs) {
+        const installs = agent.total_installs || agent.stats?.installs || 0
+        const rating = agent.average_rating || agent.stats?.rating || 0
+        console.log(chalk.gray(`   ${installs} installs • ⭐ ${rating}/5`))
+      }
+      
+      if (agent.tags && agent.tags.length > 0) {
+        const tags = Array.isArray(agent.tags) ? agent.tags : Object.values(agent.tags)
+        console.log(chalk.gray(`   Tags: ${tags.slice(0, 5).join(', ')}`))
+      }
+      
+      console.log(chalk.dim(`   ${chalk.cyan('nex agent install')} ${agent.agent_id || agent.id}`))
+      console.log()
+    })
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // AGENT INFO
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * Get detailed agent information
+   */
+  async info(agentId) {
+    const spinner = ora(`Loading info for ${agentId}...`).start()
+    
+    try {
+      // Try to load from Supabase first
+      let agent = null
+      
+      if (this.supabase) {
+        const { data } = await this.supabase
+          .from('nex_marketplace_agents')
+          .select('*')
+          .eq('agent_id', agentId)
+          .single()
+        
+        agent = data
+      }
+      
+      // Fallback to local
+      if (!agent) {
+        agent = await this.loadLocalManifest(agentId)
+      }
+      
+      if (!agent) {
+        spinner.fail(`Agent ${agentId} not found`)
+        return null
+      }
+      
+      spinner.succeed(`Loaded info for ${agentId}`)
+      
+      // Display detailed info
+      this.displayAgentInfo(agent)
+      
+      return agent
+      
+    } catch (error) {
+      spinner.fail('Failed to load agent info')
+      console.error(chalk.red(`Error: ${error.message}`))
+      throw error
+    }
+  }
+
+  /**
+   * Load manifest from local registry
+   */
+  async loadLocalManifest(agentId) {
+    const categories = ['planning', 'execution', 'community']
+    
+    for (const category of categories) {
+      const manifestPath = path.join(this.registryPath, category, agentId, 'manifest.yaml')
+      
+      if (await fs.pathExists(manifestPath)) {
+        const manifestFile = await fs.readFile(manifestPath, 'utf8')
+        const manifest = yaml.parse(manifestFile)
+        return { agent_id: agentId, ...manifest }
+      }
+    }
+    
+    return null
+  }
+
+  /**
+   * Display detailed agent information
+   */
+  displayAgentInfo(agent) {
+    const icon = agent.icon || '🤖'
+    const name = agent.name
+    const version = agent.current_version || agent.version
+    
+    console.log('\n' + chalk.bold.cyan('═'.repeat(60)))
+    console.log(chalk.bold.cyan(`${icon} ${name} v${version}`))
+    console.log(chalk.bold.cyan('═'.repeat(60)))
+    
+    if (agent.tagline) {
+      console.log(chalk.bold('\n💫 Tagline:'))
+      console.log(chalk.gray(`   ${agent.tagline}`))
+    }
+    
+    console.log(chalk.bold('\n📝 Description:'))
+    console.log(chalk.gray(`   ${agent.description || agent.long_description || 'N/A'}`))
+    
+    if (agent.author_name || agent.author?.name) {
+      console.log(chalk.bold('\n👤 Author:'))
+      const authorName = agent.author_name || agent.author.name
+      const authorEmail = agent.author_email || agent.author?.email
+      console.log(chalk.gray(`   ${authorName}${authorEmail ? ` <${authorEmail}>` : ''}`))
+    }
+    
+    if (agent.tags && agent.tags.length > 0) {
+      console.log(chalk.bold('\n🏷️  Tags:'))
+      const tags = Array.isArray(agent.tags) ? agent.tags : Object.values(agent.tags)
+      console.log(chalk.gray(`   ${tags.join(', ')}`))
+    }
+    
+    if (agent.capabilities) {
+      console.log(chalk.bold('\n⚡ Capabilities:'))
+      const capabilities = Array.isArray(agent.capabilities) 
+        ? agent.capabilities 
+        : Object.values(agent.capabilities)
+      capabilities.slice(0, 10).forEach(cap => {
+        console.log(chalk.gray(`  • ${cap}`))
+      })
+      if (capabilities.length > 10) {
+        console.log(chalk.gray(`  ... and ${capabilities.length - 10} more`))
+      }
+    }
+    
+    if (agent.total_installs !== undefined) {
+      console.log(chalk.bold('\n📊 Stats:'))
+      console.log(chalk.gray(`   Installs: ${agent.total_installs}`))
+      console.log(chalk.gray(`   Rating: ${'⭐'.repeat(Math.floor(agent.average_rating || 0))} (${agent.average_rating || 0}/5)`))
+      if (agent.total_stars) {
+        console.log(chalk.gray(`   Stars: ${agent.total_stars}`))
+      }
+    }
+    
+    if (agent.dependencies?.agents && agent.dependencies.agents.length > 0) {
+      console.log(chalk.bold('\n🔗 Dependencies:'))
+      agent.dependencies.agents.forEach(dep => {
+        console.log(chalk.gray(`  • ${dep}`))
+      })
+    }
+    
+    console.log(chalk.bold('\n🔧 Installation:'))
+    console.log(chalk.cyan(`   nex agent install ${agent.agent_id || agent.id}`))
+    
+    if (agent.repository_url || agent.links?.repository) {
+      console.log(chalk.bold('\n🌐 Links:'))
+      const repoUrl = agent.repository_url || agent.links?.repository
+      console.log(chalk.gray(`   Repository: ${repoUrl}`))
+      
+      if (agent.documentation_url || agent.links?.documentation) {
+        const docUrl = agent.documentation_url || agent.links?.documentation
+        console.log(chalk.gray(`   Documentation: ${docUrl}`))
+      }
+    }
+    
+    console.log('\n' + chalk.bold.cyan('═'.repeat(60)) + '\n')
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // INSTALLATION
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * Install an agent
+   */
+  async install(agentId, options = {}) {
+    const spinner = ora(`Installing ${agentId}...`).start()
+    
+    try {
+      // 1. Check if agent is registered in NEX Hub (if Supabase is configured)
+      if (this.supabase && !options.skipRegistrationCheck) {
+        spinner.text = 'Checking registration...'
+        
+        const { data: { user } } = await this.supabase.auth.getUser()
+        
+        if (user) {
+          // User is authenticated, check registration
+          const isRegistered = await this.checkAgentRegistration(agentId)
+          
+          if (!isRegistered) {
+            spinner.fail('Agent not registered')
+            console.log(chalk.yellow(`\n⚠️  Agent "${agentId}" is not registered in your NEX Hub account.\n`))
+            console.log(chalk.cyan('💡 Register it first:'))
+            console.log(chalk.cyan(`   nex agent register ${agentId}\n`))
+            console.log(chalk.gray('   Or browse available agents:'))
+            console.log(chalk.gray(`   nex agent search ${agentId}\n`))
+            return false
+          }
+          
+          spinner.text = `Installing ${agentId}...`
+        } else {
+          // User not authenticated, show warning but allow local install
+          spinner.warn('Not authenticated - installing locally only')
+          console.log(chalk.yellow('\n⚠️  You are not logged in to NEX Hub.'))
+          console.log(chalk.gray('   This agent will be installed locally only.\n'))
+        }
+      }
+      
+      // 2. Resolve version
+      const version = options.version || await this.getLatestVersion(agentId)
+      spinner.text = `Installing ${agentId}@${version}...`
+      
+      // 3. Load agent manifest
+      const manifest = await this.loadLocalManifest(agentId)
+      
+      if (!manifest) {
+        spinner.fail(`Agent ${agentId} not found in registry`)
+        return false
+      }
+      
+      // 4. Check dependencies
+      spinner.text = 'Checking dependencies...'
+      await this.checkDependencies(manifest)
+      
+      // 5. Determine install location
+      const installPath = path.join(this.installPath, agentId)
+      
+      // 5. Check if already installed
+      if (await fs.pathExists(installPath)) {
+        spinner.info(`Agent ${agentId} already installed`)
+        
+        // Ask user if they want to update
+        return await this.update(agentId, options)
+      }
+      
+      // 6. Install (symlink or copy)
+      const method = options.method || this.config.defaults.method || 'symlink'
+      const sourcePath = await this.getAgentSourcePath(agentId, version)
+      
+      spinner.text = `Installing ${agentId} (${method})...`
+      
+      if (method === 'symlink') {
+        await fs.ensureDir(path.dirname(installPath))
+        await fs.ensureSymlink(sourcePath, installPath)
+      } else {
+        await fs.copy(sourcePath, installPath)
+      }
+      
+      // 7. Track installation
+      await this.trackInstallation(agentId, version, method)
+      
+      spinner.succeed(chalk.green(`✅ ${manifest.icon} ${manifest.name} v${version} installed!`))
+      
+      // 8. Show quick start
+      console.log(chalk.cyan('\n📖 Quick Start:'))
+      console.log(chalk.gray(`   @${agentId}`))
+      console.log(chalk.gray(`   nex agent run ${agentId} <command>\n`))
+      
+      return true
+      
+    } catch (error) {
+      spinner.fail(chalk.red(`Failed to install ${agentId}`))
+      console.error(chalk.red(`Error: ${error.message}`))
+      throw error
+    }
+  }
+
+  /**
+   * Get agent source path
+   */
+  async getAgentSourcePath(agentId, version) {
+    const categories = ['planning', 'execution', 'community']
+    
+    for (const category of categories) {
+      // Try versioned path first
+      let sourcePath = path.join(this.registryPath, category, agentId, 'versions', version)
+      
+      if (await fs.pathExists(sourcePath)) {
+        return sourcePath
+      }
+      
+      // Fallback to non-versioned
+      sourcePath = path.join(this.registryPath, category, agentId)
+      
+      if (await fs.pathExists(sourcePath)) {
+        return sourcePath
+      }
+    }
+    
+    throw new Error(`Agent source not found: ${agentId}@${version}`)
+  }
+
+  /**
+   * Get latest version of agent
+   */
+  async getLatestVersion(agentId) {
+    // Try Supabase first
+    if (this.supabase) {
+      const { data } = await this.supabase
+        .from('nex_marketplace_versions')
+        .select('version')
+        .eq('agent_id', agentId)
+        .eq('is_latest', true)
+        .single()
+      
+      if (data) return data.version
+    }
+    
+    // Fallback to manifest
+    const manifest = await this.loadLocalManifest(agentId)
+    return manifest?.version || manifest?.current_version || '1.0.0'
+  }
+
+  /**
+   * Check agent dependencies
+   */
+  async checkDependencies(manifest) {
+    if (!manifest.dependencies || !manifest.dependencies.agents) {
+      return true
+    }
+    
+    const missing = []
+    
+    for (const depId of manifest.dependencies.agents) {
+      const depPath = path.join(this.installPath, depId)
+      
+      if (!await fs.pathExists(depPath)) {
+        missing.push(depId)
+      }
+    }
+    
+    if (missing.length > 0) {
+      console.log(chalk.yellow(`\n⚠️  Missing dependencies: ${missing.join(', ')}`))
+      console.log(chalk.gray('These agents will be installed automatically.\n'))
+      
+      // Auto-install dependencies
+      for (const depId of missing) {
+        await this.install(depId)
+      }
+    }
+    
+    return true
+  }
+
+  /**
+   * Track installation
+   */
+  async trackInstallation(agentId, version, method) {
+    // Save to local registry
+    const installedFile = path.join(this.installPath, 'installed.json')
+    await fs.ensureDir(this.installPath)
+    
+    let installed = {}
+    if (await fs.pathExists(installedFile)) {
+      installed = await fs.readJSON(installedFile)
+    }
+    
+    if (!installed.agents) {
+      installed.agents = []
+    }
+    
+    // Remove old entry if exists
+    installed.agents = installed.agents.filter(a => a.id !== agentId)
+    
+    // Add new entry
+    installed.agents.push({
+      id: agentId,
+      version: version,
+      method: method,
+      installed_at: new Date().toISOString(),
+      project_path: this.projectRoot
+    })
+    
+    await fs.writeJSON(installedFile, installed, { spaces: 2 })
+    
+    // Track in Supabase if available
+    if (this.supabase) {
+      await this.supabase
+        .from('nex_marketplace_installs')
+        .upsert({
+          agent_id: agentId,
+          version: version,
+          install_method: method,
+          project_path: this.projectRoot,
+          project_name: path.basename(this.projectRoot),
+          is_active: true
+        })
+    }
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // LIST INSTALLED
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * List installed agents
+   */
+  async list(options = {}) {
+    const installedFile = path.join(this.installPath, 'installed.json')
+    
+    if (!await fs.pathExists(installedFile)) {
+      console.log(chalk.yellow('📭 No agents installed in this project.'))
+      console.log(chalk.gray('\nInstall agents with: nex agent install <agent-id>\n'))
+      return []
+    }
+    
+    const installed = await fs.readJSON(installedFile)
+    const agents = installed.agents || []
+    
+    if (agents.length === 0) {
+      console.log(chalk.yellow('📭 No agents installed in this project.\n'))
+      return []
+    }
+    
+    console.log(chalk.bold.cyan(`\n📦 Installed Agents (${agents.length})`))
+    console.log(chalk.gray(`Project: ${path.basename(this.projectRoot)}\n`))
+    
+    for (const agent of agents) {
+      const manifest = await this.loadLocalManifest(agent.id)
+      
+      if (manifest) {
+        const icon = manifest.icon || '🤖'
+        console.log(chalk.bold(`${icon} ${manifest.name || agent.id}`))
+      } else {
+        console.log(chalk.bold(`🤖 ${agent.id}`))
+      }
+      
+      console.log(chalk.gray(`   Version: ${agent.version}`))
+      console.log(chalk.gray(`   Method: ${agent.method}`))
+      console.log(chalk.gray(`   Installed: ${new Date(agent.installed_at).toLocaleDateString()}`))
+      console.log()
+    }
+    
+    return agents
+  }
+
+  /**
+   * Uninstall agent
+   */
+  async uninstall(agentId) {
+    const spinner = ora(`Uninstalling ${agentId}...`).start()
+    
+    try {
+      const installPath = path.join(this.installPath, agentId)
+      
+      if (!await fs.pathExists(installPath)) {
+        spinner.fail(`Agent ${agentId} is not installed`)
+        return false
+      }
+      
+      // Remove files
+      await fs.remove(installPath)
+      
+      // Update installed.json
+      const installedFile = path.join(this.installPath, 'installed.json')
+      const installed = await fs.readJSON(installedFile)
+      installed.agents = (installed.agents || []).filter(a => a.id !== agentId)
+      await fs.writeJSON(installedFile, installed, { spaces: 2 })
+      
+      // Update Supabase
+      if (this.supabase) {
+        await this.supabase
+          .from('nex_marketplace_installs')
+          .update({ is_active: false, uninstalled_at: new Date().toISOString() })
+          .eq('agent_id', agentId)
+          .eq('project_path', this.projectRoot)
+      }
+      
+      spinner.succeed(chalk.green(`✅ Agent ${agentId} uninstalled`))
+      return true
+      
+    } catch (error) {
+      spinner.fail(`Failed to uninstall ${agentId}`)
+      console.error(chalk.red(`Error: ${error.message}`))
+      throw error
+    }
+  }
+
+  /**
+   * Update agent
+   */
+  async update(agentId, options = {}) {
+    console.log(chalk.blue(`🔄 Updating ${agentId}...`))
+    
+    // Uninstall old version
+    await this.uninstall(agentId)
+    
+    // Install new version
+    return await this.install(agentId, options)
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // AGENT REGISTRATION (HUB REGISTRY SYSTEM)
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * Register an agent in the NEX Hub
+   */
+  async register(agentId) {
+    const spinner = ora(`Registering ${agentId} in NEX Hub...`).start()
+    
+    try {
+      // 1. Check if Supabase is configured
+      if (!this.supabase) {
+        spinner.fail('Supabase not configured')
+        console.log(chalk.yellow('\n⚠️  NEX Hub requires Supabase configuration.'))
+        console.log(chalk.cyan('💡 Set VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY environment variables.\n'))
+        return false
+      }
+      
+      // 2. Check if user is authenticated
+      const { data: { user }, error: authError } = await this.supabase.auth.getUser()
+      
+      if (authError || !user) {
+        spinner.fail('Not authenticated')
+        console.log(chalk.yellow('\n⚠️  You need to be logged in to register agents.'))
+        console.log(chalk.cyan('💡 Run: nex auth login\n'))
+        return false
+      }
+      
+      // 3. Get agent info from database
+      const { data: agent, error: agentError } = await this.supabase
+        .from('nex_marketplace_agents')
+        .select('agent_id, name, agent_type, icon')
+        .eq('agent_id', agentId)
+        .single()
+      
+      if (agentError || !agent) {
+        spinner.fail(`Agent ${agentId} not found`)
+        console.log(chalk.yellow(`\n⚠️  Agent "${agentId}" not found in NEX Hub.`))
+        console.log(chalk.cyan(`💡 Search for agents: nex agent search ${agentId}\n`))
+        return false
+      }
+      
+      // 4. Call Edge Function to register
+      const EDGE_FUNCTION_URL = process.env.VITE_SUPABASE_URL?.replace('.supabase.co', '.supabase.co/functions/v1')
+      const { data: session } = await this.supabase.auth.getSession()
+      
+      const response = await fetch(`${EDGE_FUNCTION_URL}/nex-agent-registry/register`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${session.session?.access_token}`,
+          'apikey': process.env.VITE_SUPABASE_ANON_KEY
+        },
+        body: JSON.stringify({ agent_id: agentId })
+      })
+      
+      const result = await response.json()
+      
+      if (!response.ok) {
+        spinner.fail('Registration failed')
+        
+        if (result.details?.reason === 'limit_reached') {
+          console.log(chalk.red(`\n❌ ${result.error}\n`))
+          console.log(chalk.yellow(`📊 Your Plan: ${result.details.current_plan}`))
+          console.log(chalk.yellow(`   Agent Type: ${result.details.agent_type}`))
+          console.log(chalk.yellow(`   Current: ${result.details.current_count}/${result.details.max_allowed}\n`))
+          
+          if (result.details.upgrade_required) {
+            console.log(chalk.cyan(`💡 Upgrade to ${result.details.upgrade_required} plan to register more agents.`))
+            console.log(chalk.cyan(`   Visit: https://nexhub.dev/pricing\n`))
+          }
+        } else if (result.details?.reason === 'already_registered') {
+          spinner.info('Already registered')
+          console.log(chalk.blue(`\nℹ️  Agent "${agent.name}" is already registered.\n`))
+          return true
+        } else {
+          console.log(chalk.red(`\n❌ ${result.error}\n`))
+        }
+        
+        return false
+      }
+      
+      // 5. Success!
+      spinner.succeed(chalk.green(`✅ Agent registered successfully!`))
+      console.log(chalk.cyan(`\n${agent.icon || '🤖'} ${agent.name} (${agentId})`))
+      console.log(chalk.gray(`   Type: ${agent.agent_type}`))
+      console.log(chalk.gray(`   Registration ID: ${result.registration?.registration_id}\n`))
+      console.log(chalk.green(`✨ You can now install this agent:`))
+      console.log(chalk.cyan(`   nex agent install ${agentId}\n`))
+      
+      return true
+      
+    } catch (error) {
+      spinner.fail('Registration failed')
+      console.error(chalk.red(`\n❌ Error: ${error.message}\n`))
+      return false
+    }
+  }
+
+  /**
+   * List registered agents from NEX Hub
+   */
+  async listRegisteredAgents() {
+    const spinner = ora('Loading your registered agents...').start()
+    
+    try {
+      // 1. Check if Supabase is configured
+      if (!this.supabase) {
+        spinner.fail('Supabase not configured')
+        console.log(chalk.yellow('\n⚠️  NEX Hub requires Supabase configuration.\n'))
+        return []
+      }
+      
+      // 2. Check if user is authenticated
+      const { data: { user }, error: authError } = await this.supabase.auth.getUser()
+      
+      if (authError || !user) {
+        spinner.fail('Not authenticated')
+        console.log(chalk.yellow('\n⚠️  You need to be logged in.\n'))
+        return []
+      }
+      
+      // 3. Call Edge Function to get registered agents
+      const EDGE_FUNCTION_URL = process.env.VITE_SUPABASE_URL?.replace('.supabase.co', '.supabase.co/functions/v1')
+      const { data: session } = await this.supabase.auth.getSession()
+      
+      const response = await fetch(`${EDGE_FUNCTION_URL}/nex-agent-registry/my-agents`, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${session.session?.access_token}`,
+          'apikey': process.env.VITE_SUPABASE_ANON_KEY
+        }
+      })
+      
+      const result = await response.json()
+      
+      if (!response.ok) {
+        spinner.fail('Failed to load agents')
+        console.log(chalk.red(`\n❌ ${result.error}\n`))
+        return []
+      }
+      
+      const agents = result.agents || []
+      
+      spinner.succeed(`Found ${agents.length} registered agents`)
+      
+      // 4. Display agents
+      if (agents.length === 0) {
+        console.log(chalk.yellow('\n😕 You have no agents registered yet.\n'))
+        console.log(chalk.cyan('💡 Register an agent:'))
+        console.log(chalk.cyan('   nex agent search <query>'))
+        console.log(chalk.cyan('   nex agent register <agent-id>\n'))
+        return []
+      }
+      
+      console.log('\n')
+      console.log(chalk.bold.cyan('📦 YOUR REGISTERED AGENTS\n'))
+      
+      agents.forEach(reg => {
+        const agent = reg.nex_marketplace_agents
+        const icon = agent?.icon || '🤖'
+        const name = agent?.name || reg.agent_id
+        const type = agent?.agent_type || 'unknown'
+        const registeredAt = new Date(reg.registered_at).toLocaleDateString()
+        
+        console.log(chalk.bold(`${icon} ${name}`))
+        console.log(chalk.gray(`   ID: ${reg.agent_id}`))
+        console.log(chalk.gray(`   Type: ${type}`))
+        console.log(chalk.gray(`   Registered: ${registeredAt}`))
+        console.log(chalk.dim(`   ${chalk.cyan('nex agent install')} ${reg.agent_id}`))
+        console.log()
+      })
+      
+      // 5. Show plan info
+      const { data: planData } = await this.supabase.rpc('get_user_plan', { p_user_id: user.id })
+      
+      if (planData && planData.length > 0) {
+        const plan = planData[0]
+        const nexCount = agents.filter(a => a.nex_marketplace_agents?.agent_type === 'nex_free').length
+        const bmadCount = agents.filter(a => a.nex_marketplace_agents?.agent_type === 'bmad_free').length
+        const premiumCount = agents.filter(a => a.nex_marketplace_agents?.agent_type === 'premium').length
+        
+        console.log(chalk.bold.cyan('📊 YOUR PLAN\n'))
+        console.log(chalk.bold(`   ${plan.plan_name}`))
+        console.log(chalk.gray(`   NEX Free: ${nexCount}/${plan.max_nex_free}`))
+        console.log(chalk.gray(`   BMAD Free: ${bmadCount}/${plan.max_bmad_free}`))
+        console.log(chalk.gray(`   Premium: ${premiumCount}/${plan.max_premium}`))
+        console.log()
+      }
+      
+      return agents
+      
+    } catch (error) {
+      spinner.fail('Failed to load agents')
+      console.error(chalk.red(`\n❌ Error: ${error.message}\n`))
+      return []
+    }
+  }
+
+  /**
+   * Check if agent is registered (internal method)
+   */
+  async checkAgentRegistration(agentId) {
+    try {
+      if (!this.supabase) return false
+      
+      const { data: { user } } = await this.supabase.auth.getUser()
+      if (!user) return false
+      
+      const EDGE_FUNCTION_URL = process.env.VITE_SUPABASE_URL?.replace('.supabase.co', '.supabase.co/functions/v1')
+      const { data: session } = await this.supabase.auth.getSession()
+      
+      const response = await fetch(`${EDGE_FUNCTION_URL}/nex-agent-registry/check/${agentId}`, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${session.session?.access_token}`,
+          'apikey': process.env.VITE_SUPABASE_ANON_KEY
+        }
+      })
+      
+      const result = await response.json()
+      return result.is_registered || false
+      
+    } catch (error) {
+      return false
+    }
+  }
+}