@friggframework/devtools 2.0.0-next.29 → 2.0.0-next.30

package/management-ui/src/services/apiModuleService.js

@@ -0,0 +1,193 @@
+// Service for discovering and fetching Frigg API modules from npm
+export class APIModuleService {
+  constructor() {
+    this.npmRegistry = 'https://registry.npmjs.org';
+    this.scope = '@friggframework';
+    this.modulePrefix = 'api-module-';
+    
+    // Cache for module data
+    this.moduleCache = new Map();
+    this.cacheExpiry = 60 * 60 * 1000; // 1 hour
+  }
+
+  // Fetch all available API modules from npm
+  async getAllModules() {
+    const cacheKey = 'all-modules';
+    const cached = this.getFromCache(cacheKey);
+    if (cached) return cached;
+
+    try {
+      // Search for all @friggframework/api-module-* packages
+      const searchUrl = `${this.npmRegistry}/-/v1/search?text=${encodeURIComponent(this.scope + '/' + this.modulePrefix)}&size=250`;
+      const response = await fetch(searchUrl);
+      
+      if (!response.ok) {
+        throw new Error(`Failed to fetch modules: ${response.status}`);
+      }
+
+      const data = await response.json();
+      const modules = data.objects
+        .filter(pkg => pkg.package.name.startsWith(`${this.scope}/${this.modulePrefix}`))
+        .map(pkg => ({
+          name: pkg.package.name,
+          displayName: this.formatDisplayName(pkg.package.name),
+          version: pkg.package.version,
+          description: pkg.package.description,
+          keywords: pkg.package.keywords || [],
+          links: pkg.package.links || {},
+          date: pkg.package.date,
+          publisher: pkg.package.publisher,
+          maintainers: pkg.package.maintainers || []
+        }))
+        .sort((a, b) => a.displayName.localeCompare(b.displayName));
+
+      this.setCache(cacheKey, modules);
+      return modules;
+    } catch (error) {
+      console.error('Error fetching API modules:', error);
+      return [];
+    }
+  }
+
+  // Get detailed information about a specific module
+  async getModuleDetails(moduleName) {
+    const cacheKey = `module-${moduleName}`;
+    const cached = this.getFromCache(cacheKey);
+    if (cached) return cached;
+
+    try {
+      const packageUrl = `${this.npmRegistry}/${moduleName}`;
+      const response = await fetch(packageUrl);
+      
+      if (!response.ok) {
+        throw new Error(`Failed to fetch module details: ${response.status}`);
+      }
+
+      const data = await response.json();
+      const latestVersion = data['dist-tags'].latest;
+      const versionData = data.versions[latestVersion];
+
+      const details = {
+        name: data.name,
+        displayName: this.formatDisplayName(data.name),
+        version: latestVersion,
+        description: data.description,
+        readme: data.readme,
+        homepage: data.homepage,
+        repository: data.repository,
+        keywords: versionData.keywords || [],
+        dependencies: versionData.dependencies || {},
+        peerDependencies: versionData.peerDependencies || {},
+        maintainers: data.maintainers || [],
+        time: data.time,
+        // Extract configuration from package.json if available
+        friggConfig: versionData.frigg || {},
+        authType: this.detectAuthType(versionData),
+        requiredFields: this.extractRequiredFields(versionData)
+      };
+
+      this.setCache(cacheKey, details);
+      return details;
+    } catch (error) {
+      console.error(`Error fetching details for ${moduleName}:`, error);
+      return null;
+    }
+  }
+
+  // Format module name for display
+  formatDisplayName(packageName) {
+    const moduleName = packageName
+      .replace(`${this.scope}/`, '')
+      .replace(this.modulePrefix, '')
+      .split('-')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+    return moduleName;
+  }
+
+  // Detect authentication type from module
+  detectAuthType(packageData) {
+    const deps = { ...packageData.dependencies, ...packageData.peerDependencies };
+    const keywords = packageData.keywords || [];
+    const description = (packageData.description || '').toLowerCase();
+
+    if (deps['@friggframework/oauth2'] || keywords.includes('oauth2')) {
+      return 'oauth2';
+    }
+    if (deps['@friggframework/oauth1'] || keywords.includes('oauth1')) {
+      return 'oauth1';
+    }
+    if (keywords.includes('api-key') || description.includes('api key')) {
+      return 'api-key';
+    }
+    if (keywords.includes('basic-auth') || description.includes('basic auth')) {
+      return 'basic-auth';
+    }
+    
+    return 'custom';
+  }
+
+  // Extract required fields from module configuration
+  extractRequiredFields(packageData) {
+    const friggConfig = packageData.frigg || {};
+    const fields = [];
+
+    // Check for defined required fields in frigg config
+    if (friggConfig.requiredFields) {
+      return friggConfig.requiredFields;
+    }
+
+    // Otherwise, try to infer from common patterns
+    const authType = this.detectAuthType(packageData);
+    
+    switch (authType) {
+      case 'oauth2':
+        fields.push(
+          { name: 'client_id', label: 'Client ID', type: 'string', required: true },
+          { name: 'client_secret', label: 'Client Secret', type: 'password', required: true },
+          { name: 'redirect_uri', label: 'Redirect URI', type: 'string', required: true }
+        );
+        break;
+      case 'api-key':
+        fields.push(
+          { name: 'api_key', label: 'API Key', type: 'password', required: true }
+        );
+        break;
+      case 'basic-auth':
+        fields.push(
+          { name: 'username', label: 'Username', type: 'string', required: true },
+          { name: 'password', label: 'Password', type: 'password', required: true }
+        );
+        break;
+    }
+
+    return fields;
+  }
+
+  // Cache management
+  getFromCache(key) {
+    const cached = this.moduleCache.get(key);
+    if (!cached) return null;
+    
+    if (Date.now() - cached.timestamp > this.cacheExpiry) {
+      this.moduleCache.delete(key);
+      return null;
+    }
+    
+    return cached.data;
+  }
+
+  setCache(key, data) {
+    this.moduleCache.set(key, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+
+  clearCache() {
+    this.moduleCache.clear();
+  }
+}
+
+// Export singleton instance
+export default new APIModuleService();

package/management-ui/src/services/websocket-handlers.js

@@ -0,0 +1,120 @@
+// WebSocket event handlers for integration discovery and installation
+
+export const setupIntegrationHandlers = (socket) => {
+  // Installation progress handler
+  socket.on('integration:install:start', (data) => {
+    console.log('Installation started:', data)
+  })
+
+  socket.on('integration:install:progress', (data) => {
+    console.log('Installation progress:', data)
+    // data: { packageName, progress: 0-100, message, status }
+  })
+
+  socket.on('integration:install:complete', (data) => {
+    console.log('Installation complete:', data)
+    // data: { packageName, version, success: true }
+  })
+
+  socket.on('integration:install:error', (data) => {
+    console.error('Installation error:', data)
+    // data: { packageName, error, details }
+  })
+
+  // Uninstallation handlers
+  socket.on('integration:uninstall:start', (data) => {
+    console.log('Uninstallation started:', data)
+  })
+
+  socket.on('integration:uninstall:complete', (data) => {
+    console.log('Uninstallation complete:', data)
+  })
+
+  socket.on('integration:uninstall:error', (data) => {
+    console.error('Uninstallation error:', data)
+  })
+
+  // Update handlers
+  socket.on('integration:update:start', (data) => {
+    console.log('Update started:', data)
+  })
+
+  socket.on('integration:update:progress', (data) => {
+    console.log('Update progress:', data)
+  })
+
+  socket.on('integration:update:complete', (data) => {
+    console.log('Update complete:', data)
+  })
+
+  socket.on('integration:update:error', (data) => {
+    console.error('Update error:', data)
+  })
+
+  // Health check handlers
+  socket.on('integration:health:update', (data) => {
+    console.log('Integration health update:', data)
+    // data: { packageName, status, health }
+  })
+
+  // Configuration change handlers
+  socket.on('integration:config:updated', (data) => {
+    console.log('Integration configuration updated:', data)
+  })
+
+  // Test execution handlers
+  socket.on('integration:test:start', (data) => {
+    console.log('Test started:', data)
+  })
+
+  socket.on('integration:test:complete', (data) => {
+    console.log('Test complete:', data)
+  })
+
+  socket.on('integration:test:error', (data) => {
+    console.error('Test error:', data)
+  })
+
+  return socket
+}
+
+// Emit installation request with progress tracking
+export const installIntegrationWithProgress = (socket, packageName, options = {}) => {
+  socket.emit('integration:install', {
+    packageName,
+    options,
+    trackProgress: true
+  })
+}
+
+// Emit uninstallation request
+export const uninstallIntegrationWithProgress = (socket, packageName) => {
+  socket.emit('integration:uninstall', {
+    packageName,
+    trackProgress: true
+  })
+}
+
+// Emit update request with progress tracking
+export const updateIntegrationWithProgress = (socket, packageName) => {
+  socket.emit('integration:update', {
+    packageName,
+    trackProgress: true
+  })
+}
+
+// Request integration health check
+export const checkIntegrationHealth = (socket, packageName) => {
+  socket.emit('integration:health:check', {
+    packageName
+  })
+}
+
+// Test integration endpoint
+export const testIntegrationEndpoint = (socket, integrationName, endpoint, params) => {
+  socket.emit('integration:test:endpoint', {
+    integrationName,
+    endpoint,
+    params
+  })
+}

package/management-ui/src/test/api/project.test.js

@@ -0,0 +1,273 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import request from 'supertest'
+import express from 'express'
+
+// Mock child_process
+vi.mock('child_process', () => ({
+  spawn: vi.fn(),
+  exec: vi.fn()
+}))
+
+// Mock fs/promises  
+vi.mock('fs/promises', () => ({
+  readFile: vi.fn(),
+  stat: vi.fn(),
+  access: vi.fn()
+}))
+
+// Mock the utilities
+vi.mock('../../server/utils/response.js', () => ({
+  createStandardResponse: (data) => ({ success: true, data }),
+  createErrorResponse: (code, message) => ({ success: false, error: { code, message } }),
+  ERROR_CODES: {
+    PROJECT_ALREADY_RUNNING: 'PROJECT_ALREADY_RUNNING',
+    PROJECT_NOT_RUNNING: 'PROJECT_NOT_RUNNING',
+    PROJECT_START_FAILED: 'PROJECT_START_FAILED',
+    PROJECT_STOP_FAILED: 'PROJECT_STOP_FAILED',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    INTERNAL_ERROR: 'INTERNAL_ERROR'
+  },
+  asyncHandler: (fn) => fn
+}))
+
+describe('Project API - Repository Discovery', () => {
+  let app
+  let projectRouter
+
+  beforeEach(async () => {
+    vi.clearAllMocks()
+    
+    // Create fresh Express app for each test
+    app = express()
+    app.use(express.json())
+    
+    // Import the router after mocks are set up
+    const module = await import('../../server/api/project.js')
+    projectRouter = module.default
+    app.use('/api/project', projectRouter)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    // Clean up environment variables
+    delete process.env.AVAILABLE_REPOSITORIES
+    delete process.env.REPOSITORY_INFO
+  })
+
+  describe('GET /api/project/repositories', () => {
+    it('should return repositories from environment variable when available', async () => {
+      const mockRepos = [
+        {
+          name: 'test-app-1',
+          path: '/path/to/app1',
+          framework: 'React',
+          version: '1.0.0'
+        },
+        {
+          name: 'test-app-2',
+          path: '/path/to/app2',
+          framework: 'Vue', 
+          version: '2.0.0'
+        }
+      ]
+
+      const mockCurrentRepo = {
+        name: 'Multiple Repositories Available',
+        isMultiRepo: true,
+        availableRepos: mockRepos
+      }
+
+      // Set environment variables to simulate CLI discovery
+      process.env.AVAILABLE_REPOSITORIES = JSON.stringify(mockRepos)
+      process.env.REPOSITORY_INFO = JSON.stringify(mockCurrentRepo)
+
+      const response = await request(app)
+        .get('/api/project/repositories')
+        .expect(200)
+
+      expect(response.body).toEqual({
+        success: true,
+        data: {
+          repositories: mockRepos,
+          currentRepository: mockCurrentRepo,
+          isMultiRepo: true
+        }
+      })
+    })
+
+    it('should fall back to CLI discovery when no environment variable', async () => {
+      const { exec } = await import('child_process')
+      const { promisify } = await import('util')
+      
+      const mockRepos = [
+        {
+          name: 'discovered-app',
+          path: '/discovered/path',
+          framework: 'Angular'
+        }
+      ]
+
+      // Mock execAsync to return discovered repositories
+      const execAsync = vi.fn().mockResolvedValue({
+        stdout: JSON.stringify(mockRepos),
+        stderr: ''
+      })
+      
+      vi.mocked(promisify).mockReturnValue(execAsync)
+
+      const response = await request(app)
+        .get('/api/project/repositories')
+        .expect(200)
+
+      expect(response.body.data.repositories).toEqual(mockRepos)
+      expect(response.body.data.isMultiRepo).toBe(false)
+    })
+
+    it('should handle CLI discovery errors gracefully', async () => {
+      const { promisify } = await import('util')
+      
+      // Mock execAsync to throw error
+      const execAsync = vi.fn().mockRejectedValue(new Error('CLI discovery failed'))
+      vi.mocked(promisify).mockReturnValue(execAsync)
+
+      const response = await request(app)
+        .get('/api/project/repositories')
+        .expect(200)
+
+      expect(response.body).toEqual({
+        success: true,
+        data: {
+          repositories: [],
+          currentRepository: null,
+          isMultiRepo: false,
+          error: 'Failed to discover repositories: CLI discovery failed'
+        }
+      })
+    })
+
+    it('should handle malformed environment variable gracefully', async () => {
+      // Set malformed JSON in environment variable
+      process.env.AVAILABLE_REPOSITORIES = 'invalid-json'
+      
+      const { promisify } = await import('util')
+      const execAsync = vi.fn().mockResolvedValue({
+        stdout: '[]',
+        stderr: ''
+      })
+      vi.mocked(promisify).mockReturnValue(execAsync)
+
+      const response = await request(app)
+        .get('/api/project/repositories')
+        .expect(200)
+
+      // Should fall back to CLI discovery
+      expect(response.body.data.repositories).toEqual([])
+    })
+
+    it('should include current repository information', async () => {
+      const mockCurrentRepo = {
+        name: 'current-app',
+        path: '/current/path',
+        version: '1.5.0',
+        isMultiRepo: false
+      }
+
+      process.env.REPOSITORY_INFO = JSON.stringify(mockCurrentRepo)
+      process.env.AVAILABLE_REPOSITORIES = JSON.stringify([])
+
+      const response = await request(app)
+        .get('/api/project/repositories')
+        .expect(200)
+
+      expect(response.body.data.currentRepository).toEqual(mockCurrentRepo)
+      expect(response.body.data.isMultiRepo).toBe(false)
+    })
+
+    it('should detect multi-repo scenario correctly', async () => {
+      const mockRepos = [
+        { name: 'app1', path: '/path1' },
+        { name: 'app2', path: '/path2' },
+        { name: 'app3', path: '/path3' }
+      ]
+
+      const mockCurrentRepo = {
+        name: 'Multiple Repositories Available', 
+        isMultiRepo: true,
+        availableRepos: mockRepos
+      }
+
+      process.env.AVAILABLE_REPOSITORIES = JSON.stringify(mockRepos)
+      process.env.REPOSITORY_INFO = JSON.stringify(mockCurrentRepo)
+
+      const response = await request(app)
+        .get('/api/project/repositories')
+        .expect(200)
+
+      expect(response.body.data.isMultiRepo).toBe(true)
+      expect(response.body.data.repositories).toHaveLength(3)
+      expect(response.body.data.currentRepository.isMultiRepo).toBe(true)
+    })
+  })
+
+  describe('POST /api/project/switch-repository', () => {
+    it('should switch repository successfully', async () => {
+      const fs = await import('fs/promises')
+      
+      // Mock file system operations
+      vi.mocked(fs.stat).mockResolvedValue({ isDirectory: () => true })
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+        name: 'switched-app',
+        version: '2.0.0'
+      }))
+
+      // Mock WebSocket
+      const mockIo = {
+        emit: vi.fn()
+      }
+      app.set('io', mockIo)
+
+      const response = await request(app)
+        .post('/api/project/switch-repository')
+        .send({ repositoryPath: '/path/to/new/repo' })
+        .expect(200)
+
+      expect(response.body.success).toBe(true)
+      expect(response.body.data.repository.name).toBe('switched-app')
+      expect(response.body.data.repository.path).toBe('/path/to/new/repo')
+      
+      // Should emit WebSocket event
+      expect(mockIo.emit).toHaveBeenCalledWith('repository:switched', {
+        repository: {
+          name: 'switched-app',
+          path: '/path/to/new/repo',
+          version: '2.0.0'
+        }
+      })
+    })
+
+    it('should reject invalid repository path', async () => {
+      const response = await request(app)
+        .post('/api/project/switch-repository')
+        .send({}) // Missing repositoryPath
+        .expect(400)
+
+      expect(response.body.success).toBe(false)
+      expect(response.body.error.code).toBe('VALIDATION_ERROR')
+    })
+
+    it('should handle non-existent repository path', async () => {
+      const fs = await import('fs/promises')
+      
+      // Mock file system to throw error
+      vi.mocked(fs.stat).mockRejectedValue(new Error('Path not found'))
+
+      const response = await request(app)
+        .post('/api/project/switch-repository')
+        .send({ repositoryPath: '/invalid/path' })
+        .expect(500)
+
+      expect(response.body.success).toBe(false)
+      expect(response.body.error.code).toBe('INTERNAL_ERROR')
+    })
+  })
+})