@friggframework/devtools 2.0.0--canary.398.7664c46.0 → 2.0.0--canary.400.bed3308.0

package/management-ui/server/processManager.js

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

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