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

package/management-ui/server/index.js

@@ -1,428 +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 { spawn } from 'child_process'
-import fs from 'fs/promises'
-import processManager from './processManager.js'
-import cliIntegration from './utils/cliIntegration.js'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-class FriggManagementServer {
-  constructor(options = {}) {
-    this.port = options.port || process.env.PORT || 3001
-    this.projectRoot = options.projectRoot || process.cwd()
-    this.repositoryInfo = options.repositoryInfo || null
-    this.app = null
-    this.httpServer = null
-    this.io = null
-    this.mockIntegrations = []
-    this.mockUsers = []
-    this.mockConnections = []
-    this.envVariables = {}
-  }
-
-  async start() {
-    this.app = express()
-    this.httpServer = createServer(this.app)
-    this.io = new Server(this.httpServer, {
-      cors: {
-        origin: ["http://localhost:5173", "http://localhost:3000"],
-        methods: ["GET", "POST"]
-      }
-    })
-
-    this.setupMiddleware()
-    this.setupSocketIO()
-    this.setupRoutes()
-    this.setupStaticFiles()
-
-    return new Promise((resolve, reject) => {
-      this.httpServer.listen(this.port, (err) => {
-        if (err) {
-          reject(err)
-        } else {
-          console.log(`Management UI server running on port ${this.port}`)
-          if (this.repositoryInfo) {
-            console.log(`Connected to repository: ${this.repositoryInfo.name}`)
-          }
-          resolve()
-        }
-      })
-    })
-  }
-
-  setupMiddleware() {
-    this.app.use(cors())
-    this.app.use(express.json())
-  }
-
-  setupSocketIO() {
-    // Set up process manager listeners
-    processManager.addStatusListener((data) => {
-      this.io.emit('frigg:status', data)
-      
-      // Also emit logs if present
-      if (data.log) {
-        this.io.emit('frigg:log', data.log)
-      }
-    })
-
-    // Socket.IO connection handling
-    this.io.on('connection', (socket) => {
-      console.log('Client connected:', socket.id)
-      
-      // Send initial status
-      socket.emit('frigg:status', processManager.getStatus())
-      
-      // Send recent logs
-      const recentLogs = processManager.getLogs(50)
-      if (recentLogs.length > 0) {
-        socket.emit('frigg:logs', recentLogs)
-      }
-      
-      socket.on('disconnect', () => {
-        console.log('Client disconnected:', socket.id)
-      })
-    })
-  }
-
-  setupRoutes() {
-    const app = this.app
-    const io = this.io
-    const mockIntegrations = this.mockIntegrations
-    const mockUsers = this.mockUsers
-    const mockConnections = this.mockConnections
-    const envVariables = this.envVariables
-
-    // API Routes
-
-// Frigg server control
-app.get('/api/frigg/status', (req, res) => {
-  res.json(processManager.getStatus())
-})
-
-app.get('/api/frigg/logs', (req, res) => {
-  const limit = parseInt(req.query.limit) || 100
-  res.json({ logs: processManager.getLogs(limit) })
-})
-
-app.get('/api/frigg/metrics', (req, res) => {
-  res.json(processManager.getMetrics())
-})
-
-app.post('/api/frigg/start', async (req, res) => {
-  try {
-    const options = {
-      stage: req.body.stage || 'dev',
-      verbose: req.body.verbose || false
-    }
-    
-    const result = await processManager.start(options)
-    res.json({ 
-      message: 'Frigg started successfully',
-      status: result
-    })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-app.post('/api/frigg/stop', async (req, res) => {
-  try {
-    const force = req.body.force || false
-    await processManager.stop(force)
-    res.json({ message: 'Frigg stopped successfully' })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-app.post('/api/frigg/restart', async (req, res) => {
-  try {
-    const options = {
-      stage: req.body.stage || 'dev',
-      verbose: req.body.verbose || false
-    }
-    
-    const result = await processManager.restart(options)
-    res.json({ 
-      message: 'Frigg restarted successfully',
-      status: result
-    })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-// Integrations
-app.get('/api/integrations', (req, res) => {
-  res.json({ integrations: mockIntegrations })
-})
-
-app.post('/api/integrations/install', async (req, res) => {
-  const { name } = req.body
-  
-  try {
-    // In real implementation, this would run frigg install command
-    const newIntegration = {
-      id: Date.now().toString(),
-      name,
-      displayName: name.charAt(0).toUpperCase() + name.slice(1),
-      description: `${name} integration`,
-      installed: true,
-      installedAt: new Date().toISOString()
-    }
-    
-    mockIntegrations.push(newIntegration)
-    io.emit('integrations:update', { integrations: mockIntegrations })
-    
-    res.json({ integration: newIntegration })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-// Environment variables
-app.get('/api/environment', async (req, res) => {
-  try {
-    // In real implementation, read from .env file
-    res.json({ variables: envVariables })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-app.put('/api/environment', async (req, res) => {
-  const { key, value } = req.body
-  
-  try {
-    envVariables[key] = value
-    // In real implementation, write to .env file
-    res.json({ message: 'Environment variable updated' })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-// Users
-app.get('/api/users', (req, res) => {
-  res.json({ users: mockUsers })
-})
-
-app.post('/api/users', (req, res) => {
-  const newUser = {
-    id: Date.now().toString(),
-    ...req.body,
-    createdAt: new Date().toISOString()
-  }
-  
-  mockUsers.push(newUser)
-  res.json({ user: newUser })
-})
-
-// Connections
-app.get('/api/connections', (req, res) => {
-  res.json({ connections: mockConnections })
-})
-
-// CLI Integration endpoints
-app.get('/api/cli/info', async (req, res) => {
-  try {
-    const isAvailable = await cliIntegration.validateCLI()
-    const info = isAvailable ? await cliIntegration.getInfo() : null
-    
-    res.json({ 
-      available: isAvailable,
-      info,
-      cliPath: cliIntegration.cliPath
-    })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-app.post('/api/cli/build', async (req, res) => {
-  try {
-    const options = {
-      stage: req.body.stage || 'dev',
-      verbose: req.body.verbose || false,
-      cwd: req.body.cwd || process.cwd()
-    }
-    
-    const result = await cliIntegration.buildProject(options)
-    res.json({ 
-      message: 'Build completed successfully',
-      output: result.stdout,
-      errors: result.stderr
-    })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-app.post('/api/cli/deploy', async (req, res) => {
-  try {
-    const options = {
-      stage: req.body.stage || 'dev',
-      verbose: req.body.verbose || false,
-      cwd: req.body.cwd || process.cwd()
-    }
-    
-    const result = await cliIntegration.deployProject(options)
-    res.json({ 
-      message: 'Deploy completed successfully',
-      output: result.stdout,
-      errors: result.stderr
-    })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-app.post('/api/cli/create-integration', async (req, res) => {
-  try {
-    const integrationName = req.body.name
-    const options = {
-      cwd: req.body.cwd || process.cwd(),
-      verbose: req.body.verbose || false
-    }
-    
-    const result = await cliIntegration.createIntegration(integrationName, options)
-    res.json({ 
-      message: 'Integration created successfully',
-      output: result.stdout,
-      errors: result.stderr
-    })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-app.post('/api/cli/generate-iam', async (req, res) => {
-  try {
-    const options = {
-      output: req.body.output,
-      user: req.body.user,
-      stackName: req.body.stackName,
-      verbose: req.body.verbose || false,
-      cwd: req.body.cwd || process.cwd()
-    }
-    
-    const result = await cliIntegration.generateIAM(options)
-    res.json({ 
-      message: 'IAM template generated successfully',
-      output: result.stdout,
-      errors: result.stderr
-    })
-  } catch (error) {
-    res.status(500).json({ error: error.message })
-  }
-})
-
-  }
-
-  setupStaticFiles() {
-    // Serve static files in production
-    if (process.env.NODE_ENV === 'production') {
-      this.app.use(express.static(path.join(__dirname, '../dist')))
-      this.app.get('*', (req, res) => {
-        res.sendFile(path.join(__dirname, '../dist/index.html'))
-      })
-    } else {
-      // In development, provide helpful message
-      this.app.get('/', (req, res) => {
-        res.send(`
-          <!DOCTYPE html>
-          <html>
-          <head>
-            <title>Frigg Management UI - Development Mode</title>
-            <style>
-              body {
-                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-                display: flex;
-                justify-content: center;
-                align-items: center;
-                height: 100vh;
-                margin: 0;
-                background: #f5f5f5;
-              }
-              .container {
-                text-align: center;
-                padding: 2rem;
-                background: white;
-                border-radius: 8px;
-                box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-                max-width: 600px;
-              }
-              h1 { color: #333; }
-              p { color: #666; line-height: 1.6; }
-              code {
-                background: #f0f0f0;
-                padding: 0.2rem 0.4rem;
-                border-radius: 3px;
-                font-family: 'Consolas', 'Monaco', monospace;
-              }
-              .status { 
-                margin: 1rem 0;
-                padding: 1rem;
-                background: #e3f2fd;
-                border-radius: 4px;
-                color: #1976d2;
-              }
-            </style>
-          </head>
-          <body>
-            <div class="container">
-              <h1>Frigg Management UI</h1>
-              <div class="status">
-                <strong>Backend API Server is running on port ${this.port}</strong>
-              </div>
-              <p>
-                The Management UI requires both the backend server (running now) and the frontend development server.
-              </p>
-              <p>
-                To start the complete Management UI, run the following commands in the management-ui directory:
-              </p>
-              <p>
-                <code>cd ${path.join(__dirname, '..')}</code><br>
-                <code>npm run dev:server</code>
-              </p>
-              <p>
-                This will start both the backend API server and the Vite frontend dev server.
-                The UI will be available at <strong>http://localhost:5173</strong>
-              </p>
-            </div>
-          </body>
-          </html>
-        `)
-      })
-    }
-  }
-
-  stop() {
-    return new Promise((resolve) => {
-      if (this.httpServer) {
-        this.httpServer.close(() => {
-          console.log('Management UI server stopped')
-          resolve()
-        })
-      } else {
-        resolve()
-      }
-    })
-  }
-}
-
-// Export the class for use as a module
-export { FriggManagementServer }
-
-// If run directly, start the server
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new FriggManagementServer()
-  server.start().catch(console.error)
-}

package/management-ui/server/middleware/errorHandler.js

@@ -1,70 +0,0 @@
-import { createErrorResponse, ERROR_CODES } from '../utils/response.js'
-
-/**
- * Enhanced error handler middleware that creates standardized error responses
- * @param {Error} err - The error object
- * @param {Request} req - Express request object
- * @param {Response} res - Express response object
- * @param {Function} next - Express next function
- */
-const errorHandler = (err, req, res, next) => {
-    console.error('API Error:', {
-        error: err.message,
-        stack: err.stack,
-        path: req.path,
-        method: req.method,
-        timestamp: new Date().toISOString()
-    });
-
-    // Default error response
-    let status = 500;
-    let code = ERROR_CODES.INTERNAL_ERROR;
-    let message = 'Internal Server Error';
-    let details = null;
-
-    // Handle specific error types
-    if (err.code === 'ENOENT') {
-        status = 404;
-        code = ERROR_CODES.NOT_FOUND;
-        message = 'File or resource not found';
-    } else if (err.code === 'EACCES') {
-        status = 403;
-        code = ERROR_CODES.FORBIDDEN;
-        message = 'Permission denied';
-    } else if (err.name === 'ValidationError') {
-        status = 400;
-        code = ERROR_CODES.INVALID_REQUEST;
-        message = err.message;
-    } else if (err.status && err.code) {
-        // Custom application errors
-        status = err.status;
-        code = err.code;
-        message = err.message;
-        details = err.details;
-    } else if (err.status || err.statusCode) {
-        status = err.status || err.statusCode;
-        message = err.message;
-    }
-
-    // Include stack trace in development
-    if (process.env.NODE_ENV === 'development') {
-        details = {
-            ...details,
-            stack: err.stack
-        };
-    }
-
-    const errorResponse = createErrorResponse(code, message, details);
-    res.status(status).json(errorResponse);
-};
-
-/**
- * Async handler wrapper to catch errors in async route handlers
- * @param {Function} fn - Async route handler function
- * @returns {Function} Express middleware function
- */
-const asyncHandler = (fn) => (req, res, next) => {
-    Promise.resolve(fn(req, res, next)).catch(next);
-};
-
-export { errorHandler, asyncHandler };

package/management-ui/server/middleware/security.js

@@ -1,32 +0,0 @@
-/**
- * Security middleware to ensure the server is only accessible from localhost
- */
-const securityMiddleware = (req, res, next) => {
-    const clientIp = req.ip || req.connection.remoteAddress;
-    
-    // Extract the actual IP if it's in IPv6 format
-    const actualIp = clientIp.includes('::ffff:') 
-        ? clientIp.split('::ffff:')[1] 
-        : clientIp;
-    
-    // Allow only localhost connections
-    const allowedIps = ['127.0.0.1', 'localhost', '::1'];
-    
-    if (!allowedIps.includes(actualIp)) {
-        console.warn(`Blocked connection attempt from ${actualIp}`);
-        return res.status(403).json({
-            error: 'Forbidden',
-            message: 'This server is only accessible from localhost'
-        });
-    }
-    
-    // Add security headers
-    res.setHeader('X-Content-Type-Options', 'nosniff');
-    res.setHeader('X-Frame-Options', 'DENY');
-    res.setHeader('X-XSS-Protection', '1; mode=block');
-    res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
-    
-    next();
-};
-
-export { securityMiddleware };