@friggframework/devtools 2.0.0--canary.400.bed3308.0 → 2.0.0--canary.400.545e7a8.0

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

@@ -1,193 +0,0 @@
-// 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

@@ -1,120 +0,0 @@
-// 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

@@ -1,273 +0,0 @@
-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')
-    })
-  })
-})