@friggframework/devtools 2.0.0--canary.400.bed3308.0 → 2.0.0--canary.404.e9d4980.0

package/management-ui/server/processManager.js

@@ -1,296 +0,0 @@
-import { spawn } from 'child_process'
-import path from 'path'
-import fs from 'fs/promises'
-
-class FriggProcessManager {
-  constructor() {
-    this.process = null
-    this.status = 'stopped'
-    this.listeners = new Set()
-    this.logs = []
-    this.maxLogs = 1000
-  }
-
-  // Add status change listener
-  addStatusListener(listener) {
-    this.listeners.add(listener)
-  }
-
-  // Remove status change listener
-  removeStatusListener(listener) {
-    this.listeners.delete(listener)
-  }
-
-  // Notify all listeners of status change
-  notifyListeners(status, data = {}) {
-    this.status = status
-    this.listeners.forEach(listener => {
-      try {
-        listener({ status, ...data })
-      } catch (error) {
-        console.error('Error notifying status listener:', error)
-      }
-    })
-  }
-
-  // Add log entry
-  addLog(type, message) {
-    const logEntry = {
-      timestamp: new Date().toISOString(),
-      type, // 'stdout', 'stderr', 'system'
-      message
-    }
-    
-    this.logs.push(logEntry)
-    
-    // Keep only the last maxLogs entries
-    if (this.logs.length > this.maxLogs) {
-      this.logs = this.logs.slice(-this.maxLogs)
-    }
-
-    // Notify listeners of new log
-    this.listeners.forEach(listener => {
-      try {
-        listener({ status: this.status, log: logEntry })
-      } catch (error) {
-        console.error('Error notifying log listener:', error)
-      }
-    })
-  }
-
-  // Get current status
-  getStatus() {
-    return {
-      status: this.status,
-      pid: this.process?.pid || null,
-      uptime: this.process ? Date.now() - this.startTime : 0
-    }
-  }
-
-  // Get recent logs
-  getLogs(limit = 100) {
-    return this.logs.slice(-limit)
-  }
-
-  // Find project root with infrastructure.js
-  async findProjectRoot(startPath = process.cwd()) {
-    let currentPath = startPath
-    
-    while (currentPath !== path.dirname(currentPath)) {
-      try {
-        const infraPath = path.join(currentPath, 'infrastructure.js')
-        await fs.access(infraPath)
-        return currentPath
-      } catch {
-        currentPath = path.dirname(currentPath)
-      }
-    }
-    
-    throw new Error('Could not find infrastructure.js file in project hierarchy')
-  }
-
-  // Start Frigg process
-  async start(options = {}) {
-    if (this.status === 'running') {
-      throw new Error('Frigg is already running')
-    }
-
-    if (this.status === 'starting') {
-      throw new Error('Frigg is already starting')
-    }
-
-    try {
-      this.notifyListeners('starting')
-      this.addLog('system', 'Starting Frigg server...')
-
-      // Find project root
-      const projectRoot = await this.findProjectRoot()
-      this.addLog('system', `Project root found: ${projectRoot}`)
-
-      // Suppress AWS SDK warning
-      const env = {
-        ...process.env,
-        AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE: '1'
-      }
-
-      // Build serverless command
-      const command = 'serverless'
-      const args = [
-        'offline',
-        '--config',
-        'infrastructure.js',
-        '--stage',
-        options.stage || 'dev'
-      ]
-
-      if (options.verbose) {
-        args.push('--verbose')
-      }
-
-      this.addLog('system', `Executing: ${command} ${args.join(' ')}`)
-      this.addLog('system', `Working directory: ${projectRoot}`)
-
-      // Spawn the process
-      this.process = spawn(command, args, {
-        cwd: projectRoot,
-        env,
-        stdio: ['pipe', 'pipe', 'pipe']
-      })
-
-      this.startTime = Date.now()
-
-      // Handle stdout
-      this.process.stdout.on('data', (data) => {
-        const message = data.toString().trim()
-        if (message) {
-          this.addLog('stdout', message)
-        }
-      })
-
-      // Handle stderr
-      this.process.stderr.on('data', (data) => {
-        const message = data.toString().trim()
-        if (message) {
-          this.addLog('stderr', message)
-        }
-      })
-
-      // Handle process events
-      this.process.on('spawn', () => {
-        this.addLog('system', `Process spawned with PID: ${this.process.pid}`)
-        this.notifyListeners('running', { pid: this.process.pid })
-      })
-
-      this.process.on('error', (error) => {
-        this.addLog('system', `Process error: ${error.message}`)
-        this.notifyListeners('stopped', { error: error.message })
-        this.cleanup()
-      })
-
-      this.process.on('close', (code, signal) => {
-        const message = signal 
-          ? `Process terminated by signal: ${signal}`
-          : `Process exited with code: ${code}`
-        
-        this.addLog('system', message)
-        this.notifyListeners('stopped', { code, signal })
-        this.cleanup()
-      })
-
-      // Return promise that resolves when process is fully started
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error('Timeout waiting for Frigg to start'))
-        }, 30000) // 30 second timeout
-
-        const checkStarted = () => {
-          if (this.status === 'running') {
-            clearTimeout(timeout)
-            resolve(this.getStatus())
-          } else if (this.status === 'stopped') {
-            clearTimeout(timeout)
-            reject(new Error('Failed to start Frigg'))
-          } else {
-            setTimeout(checkStarted, 100)
-          }
-        }
-
-        checkStarted()
-      })
-
-    } catch (error) {
-      this.addLog('system', `Failed to start: ${error.message}`)
-      this.notifyListeners('stopped', { error: error.message })
-      this.cleanup()
-      throw error
-    }
-  }
-
-  // Stop Frigg process
-  async stop(force = false) {
-    if (this.status === 'stopped') {
-      throw new Error('Frigg is already stopped')
-    }
-
-    return new Promise((resolve) => {
-      if (!this.process) {
-        this.notifyListeners('stopped')
-        resolve()
-        return
-      }
-
-      this.addLog('system', force ? 'Force stopping Frigg server...' : 'Stopping Frigg server...')
-      this.notifyListeners('stopping')
-
-      // Set up cleanup timeout
-      const timeout = setTimeout(() => {
-        if (this.process && !this.process.killed) {
-          this.addLog('system', 'Force killing process after timeout')
-          this.process.kill('SIGKILL')
-        }
-      }, 5000) // 5 second timeout for graceful shutdown
-
-      // Listen for process to actually exit
-      const onClose = () => {
-        clearTimeout(timeout)
-        resolve()
-      }
-
-      if (this.process.exitCode !== null || this.process.killed) {
-        // Process already exited
-        onClose()
-      } else {
-        this.process.once('close', onClose)
-        
-        // Send termination signal
-        if (force) {
-          this.process.kill('SIGKILL')
-        } else {
-          this.process.kill('SIGTERM')
-        }
-      }
-    })
-  }
-
-  // Restart Frigg process
-  async restart(options = {}) {
-    this.addLog('system', 'Restarting Frigg server...')
-    
-    if (this.status !== 'stopped') {
-      await this.stop()
-    }
-    
-    // Wait a bit before restarting
-    await new Promise(resolve => setTimeout(resolve, 1000))
-    
-    return this.start(options)
-  }
-
-  // Clean up process references
-  cleanup() {
-    if (this.process) {
-      this.process.removeAllListeners()
-      this.process = null
-    }
-    this.startTime = null
-  }
-
-  // Get process metrics
-  getMetrics() {
-    if (!this.process || this.status !== 'running') {
-      return null
-    }
-
-    return {
-      pid: this.process.pid,
-      uptime: Date.now() - this.startTime,
-      memoryUsage: process.memoryUsage(), // This is the manager's memory, not the child's
-      status: this.status
-    }
-  }
-}
-
-// Create singleton instance
-const processManager = new FriggProcessManager()
-
-export default processManager

package/management-ui/server/server.js

@@ -1,188 +0,0 @@
-import express from 'express'
-import { createServer } from 'http'
-import { Server } from 'socket.io'
-import cors from 'cors'
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-// Import middleware and utilities
-import { errorHandler } from './middleware/errorHandler.js'
-import { createStandardResponse } from './utils/response.js'
-import { setupWebSocket } from './websocket/handler.js'
-import { addLogEntry, LOG_LEVELS } from './api/logs.js'
-
-// Import API routes
-import projectRouter from './api/project.js'
-import integrationsRouter from './api/integrations.js'
-import environmentRouter from './api/environment.js'
-import usersRouter from './api/users.js'
-import connectionsRouter from './api/connections.js'
-import cliRouter from './api/cli.js'
-import logsRouter from './api/logs.js'
-import codegenRouter from './api/codegen.js'
-import discoveryRouter from './api/discovery.js'
-import monitoringRouter from './api/monitoring.js'
-import openIdeHandler from './api/open-ide.js'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-const app = express()
-const httpServer = createServer(app)
-const io = new Server(httpServer, {
-  cors: {
-    origin: ["http://localhost:5173", "http://localhost:3000"],
-    methods: ["GET", "POST", "PUT", "DELETE"],
-    credentials: true
-  }
-})
-
-// Store io instance in app for route access
-app.set('io', io)
-
-// Middleware
-app.use(cors({
-  origin: ["http://localhost:5173", "http://localhost:3000"],
-  credentials: true
-}))
-app.use(express.json({ limit: '10mb' }))
-app.use(express.urlencoded({ extended: true }))
-
-// Request logging middleware
-app.use((req, res, next) => {
-  const timestamp = new Date().toISOString()
-  console.log(`${timestamp} - ${req.method} ${req.path}`)
-  
-  // Log API requests
-  addLogEntry(LOG_LEVELS.INFO, `${req.method} ${req.path}`, 'api', {
-    method: req.method,
-    path: req.path,
-    query: req.query,
-    userAgent: req.get('User-Agent')
-  })
-  
-  next()
-})
-
-// Setup WebSocket handling
-setupWebSocket(io)
-
-// Health check endpoint
-app.get('/health', (req, res) => {
-  res.json(createStandardResponse({
-    status: 'healthy',
-    timestamp: new Date().toISOString(),
-    uptime: process.uptime(),
-    version: process.env.npm_package_version || '1.0.0'
-  }))
-})
-
-// Get initial repository info
-app.get('/api/repository/current', (req, res) => {
-  const repoInfo = process.env.REPOSITORY_INFO ?
-    JSON.parse(process.env.REPOSITORY_INFO) :
-    null
-  res.json(createStandardResponse({ repository: repoInfo }))
-})
-// API endpoints
-app.use('/api/project', projectRouter)
-app.use('/api/integrations', integrationsRouter)
-app.use('/api/environment', environmentRouter)
-app.use('/api/users', usersRouter)
-app.use('/api/connections', connectionsRouter)
-app.use('/api/cli', cliRouter)
-app.use('/api/logs', logsRouter)
-app.use('/api/monitoring', monitoringRouter)
-app.use('/api/codegen', codegenRouter)
-app.use('/api/discovery', discoveryRouter)
-app.post('/api/open-in-ide', openIdeHandler)
-
-// API documentation endpoint
-app.get('/api', (req, res) => {
-  res.json(createStandardResponse({
-    name: 'Frigg Management UI API',
-    version: '1.0.0',
-    description: 'REST API for Frigg CLI-GUI communication',
-    endpoints: {
-      project: '/api/project',
-      integrations: '/api/integrations',
-      environment: '/api/environment',
-      users: '/api/users',
-      connections: '/api/connections',
-      cli: '/api/cli',
-      logs: '/api/logs',
-      monitoring: '/api/monitoring',
-      codegen: '/api/codegen'
-    },
-    websocket: {
-      url: 'ws://localhost:3001',
-      events: [
-        'project:status',
-        'project:logs',
-        'integrations:update',
-        'environment:update',
-        'cli:output',
-        'cli:complete',
-        'logs:new',
-        'monitoring:metrics',
-        'monitoring:error'
-      ]
-    },
-    documentation: '/api-contract.md'
-  }))
-})
-
-// Serve static files in production
-if (process.env.NODE_ENV === 'production') {
-  app.use(express.static(path.join(__dirname, '../dist')))
-  app.get('*', (req, res) => {
-    res.sendFile(path.join(__dirname, '../dist/index.html'))
-  })
-}
-
-// 404 handler for API routes
-app.use('/api/*', (req, res) => {
-  res.status(404).json(createStandardResponse(null, `API endpoint not found: ${req.path}`))
-})
-
-// Error handling middleware (must be last)
-app.use(errorHandler)
-
-// Start server
-const PORT = process.env.PORT || 3001
-httpServer.listen(PORT, () => {
-  console.log(`🚀 Frigg Management UI server running on port ${PORT}`)
-  console.log(`📡 WebSocket server ready for connections`)
-  console.log(`📚 API documentation: http://localhost:${PORT}/api`)
-  console.log(`🏥 Health check: http://localhost:${PORT}/health`)
-  
-  // Log server startup
-  addLogEntry(LOG_LEVELS.INFO, `Server started on port ${PORT}`, 'server', {
-    port: PORT,
-    nodeVersion: process.version,
-    environment: process.env.NODE_ENV || 'development'
-  })
-})
-
-// Graceful shutdown
-process.on('SIGTERM', () => {
-  console.log('SIGTERM received, shutting down gracefully...')
-  addLogEntry(LOG_LEVELS.INFO, 'Server shutting down gracefully', 'server')
-  
-  httpServer.close(() => {
-    console.log('Server closed')
-    process.exit(0)
-  })
-})
-
-process.on('SIGINT', () => {
-  console.log('SIGINT received, shutting down gracefully...')
-  addLogEntry(LOG_LEVELS.INFO, 'Server interrupted, shutting down', 'server')
-  
-  httpServer.close(() => {
-    console.log('Server closed')
-    process.exit(0)
-  })
-})
-
-export default app