@friggframework/devtools 2.0.0-next.61 → 2.0.0-next.62

package/management-ui/server/api/users/sessions.js

@@ -1,371 +0,0 @@
-import express from 'express'
-import crypto from 'crypto'
-import { wsHandler } from '../../websocket/handler.js'
-
-const router = express.Router()
-
-// In-memory session store (for development only)
-const sessions = new Map()
-const sessionsByUser = new Map()
-
-// Session configuration
-const SESSION_DURATION = 3600000 // 1 hour
-const MAX_SESSIONS_PER_USER = 5
-
-// Create a new session
-router.post('/create', async (req, res) => {
-    const { userId, metadata = {} } = req.body
-    
-    if (!userId) {
-        return res.status(400).json({
-            error: 'userId is required'
-        })
-    }
-    
-    try {
-        // Clean up expired sessions for this user
-        cleanupUserSessions(userId)
-        
-        // Check session limit
-        const userSessions = sessionsByUser.get(userId) || []
-        if (userSessions.length >= MAX_SESSIONS_PER_USER) {
-            // Remove oldest session
-            const oldestSession = userSessions[0]
-            removeSession(oldestSession)
-        }
-        
-        // Create new session
-        const sessionId = `sess_${crypto.randomBytes(16).toString('hex')}`
-        const sessionToken = `token_${crypto.randomBytes(32).toString('hex')}`
-        
-        const session = {
-            id: sessionId,
-            userId,
-            token: sessionToken,
-            createdAt: new Date().toISOString(),
-            expiresAt: new Date(Date.now() + SESSION_DURATION).toISOString(),
-            lastActivity: new Date().toISOString(),
-            metadata,
-            active: true,
-            activities: []
-        }
-        
-        // Store session
-        sessions.set(sessionId, session)
-        
-        // Update user sessions
-        const updatedUserSessions = [...(sessionsByUser.get(userId) || []), sessionId]
-        sessionsByUser.set(userId, updatedUserSessions)
-        
-        // Broadcast session creation
-        wsHandler.broadcast('session:created', {
-            sessionId,
-            userId,
-            timestamp: new Date().toISOString()
-        })
-        
-        res.json({
-            status: 'success',
-            session: {
-                id: session.id,
-                token: session.token,
-                expiresAt: session.expiresAt
-            }
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to create session'
-        })
-    }
-})
-
-// Get session details
-router.get('/:sessionId', async (req, res) => {
-    const { sessionId } = req.params
-    const session = sessions.get(sessionId)
-    
-    if (!session) {
-        return res.status(404).json({
-            error: 'Session not found'
-        })
-    }
-    
-    // Check if expired
-    if (new Date(session.expiresAt) < new Date()) {
-        removeSession(sessionId)
-        return res.status(410).json({
-            error: 'Session expired'
-        })
-    }
-    
-    res.json({
-        session: {
-            id: session.id,
-            userId: session.userId,
-            createdAt: session.createdAt,
-            expiresAt: session.expiresAt,
-            lastActivity: session.lastActivity,
-            active: session.active,
-            metadata: session.metadata
-        }
-    })
-})
-
-// Get all sessions for a user
-router.get('/user/:userId', async (req, res) => {
-    const { userId } = req.params
-    
-    // Clean up expired sessions
-    cleanupUserSessions(userId)
-    
-    const userSessionIds = sessionsByUser.get(userId) || []
-    const userSessions = userSessionIds
-        .map(id => sessions.get(id))
-        .filter(session => session && new Date(session.expiresAt) > new Date())
-        .map(session => ({
-            id: session.id,
-            createdAt: session.createdAt,
-            expiresAt: session.expiresAt,
-            lastActivity: session.lastActivity,
-            active: session.active,
-            metadata: session.metadata
-        }))
-    
-    res.json({
-        sessions: userSessions,
-        total: userSessions.length
-    })
-})
-
-// Track activity in a session
-router.post('/:sessionId/activity', async (req, res) => {
-    const { sessionId } = req.params
-    const { action, data = {} } = req.body
-    
-    const session = sessions.get(sessionId)
-    
-    if (!session) {
-        return res.status(404).json({
-            error: 'Session not found'
-        })
-    }
-    
-    // Check if expired
-    if (new Date(session.expiresAt) < new Date()) {
-        removeSession(sessionId)
-        return res.status(410).json({
-            error: 'Session expired'
-        })
-    }
-    
-    try {
-        // Update last activity
-        session.lastActivity = new Date().toISOString()
-        
-        // Add activity to log
-        const activity = {
-            id: `act_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            action,
-            data,
-            timestamp: new Date().toISOString()
-        }
-        
-        session.activities.push(activity)
-        
-        // Keep only last 100 activities
-        if (session.activities.length > 100) {
-            session.activities = session.activities.slice(-100)
-        }
-        
-        // Broadcast activity
-        wsHandler.broadcast('session:activity', {
-            sessionId,
-            userId: session.userId,
-            activity,
-            timestamp: new Date().toISOString()
-        })
-        
-        res.json({
-            status: 'success',
-            activity
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to track activity'
-        })
-    }
-})
-
-// Refresh session (extend expiry)
-router.post('/:sessionId/refresh', async (req, res) => {
-    const { sessionId } = req.params
-    const session = sessions.get(sessionId)
-    
-    if (!session) {
-        return res.status(404).json({
-            error: 'Session not found'
-        })
-    }
-    
-    // Check if expired
-    if (new Date(session.expiresAt) < new Date()) {
-        removeSession(sessionId)
-        return res.status(410).json({
-            error: 'Session expired'
-        })
-    }
-    
-    try {
-        // Extend expiry
-        session.expiresAt = new Date(Date.now() + SESSION_DURATION).toISOString()
-        session.lastActivity = new Date().toISOString()
-        
-        // Generate new token
-        session.token = `token_${crypto.randomBytes(32).toString('hex')}`
-        
-        res.json({
-            status: 'success',
-            session: {
-                id: session.id,
-                token: session.token,
-                expiresAt: session.expiresAt
-            }
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to refresh session'
-        })
-    }
-})
-
-// End session
-router.delete('/:sessionId', async (req, res) => {
-    const { sessionId } = req.params
-    const session = sessions.get(sessionId)
-    
-    if (!session) {
-        return res.status(404).json({
-            error: 'Session not found'
-        })
-    }
-    
-    try {
-        removeSession(sessionId)
-        
-        // Broadcast session end
-        wsHandler.broadcast('session:ended', {
-            sessionId,
-            userId: session.userId,
-            timestamp: new Date().toISOString()
-        })
-        
-        res.json({
-            status: 'success',
-            message: 'Session ended'
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to end session'
-        })
-    }
-})
-
-// Get all active sessions
-router.get('/', async (req, res) => {
-    try {
-        // Clean up all expired sessions
-        cleanupAllSessions()
-        
-        const activeSessions = Array.from(sessions.values())
-            .filter(session => new Date(session.expiresAt) > new Date())
-            .map(session => ({
-                id: session.id,
-                userId: session.userId,
-                createdAt: session.createdAt,
-                expiresAt: session.expiresAt,
-                lastActivity: session.lastActivity,
-                active: session.active,
-                metadata: session.metadata
-            }))
-        
-        res.json({
-            sessions: activeSessions,
-            total: activeSessions.length,
-            byUser: getSessionCountByUser()
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to fetch sessions'
-        })
-    }
-})
-
-// Helper functions
-function removeSession(sessionId) {
-    const session = sessions.get(sessionId)
-    if (!session) return
-    
-    // Remove from sessions map
-    sessions.delete(sessionId)
-    
-    // Remove from user sessions
-    const userSessions = sessionsByUser.get(session.userId) || []
-    const filtered = userSessions.filter(id => id !== sessionId)
-    if (filtered.length === 0) {
-        sessionsByUser.delete(session.userId)
-    } else {
-        sessionsByUser.set(session.userId, filtered)
-    }
-}
-
-function cleanupUserSessions(userId) {
-    const userSessionIds = sessionsByUser.get(userId) || []
-    const now = new Date()
-    
-    userSessionIds.forEach(sessionId => {
-        const session = sessions.get(sessionId)
-        if (!session || new Date(session.expiresAt) < now) {
-            removeSession(sessionId)
-        }
-    })
-}
-
-function cleanupAllSessions() {
-    const now = new Date()
-    
-    Array.from(sessions.keys()).forEach(sessionId => {
-        const session = sessions.get(sessionId)
-        if (new Date(session.expiresAt) < now) {
-            removeSession(sessionId)
-        }
-    })
-}
-
-function getSessionCountByUser() {
-    const counts = {}
-    
-    sessionsByUser.forEach((sessionIds, userId) => {
-        const activeSessions = sessionIds.filter(id => {
-            const session = sessions.get(id)
-            return session && new Date(session.expiresAt) > new Date()
-        })
-        
-        if (activeSessions.length > 0) {
-            counts[userId] = activeSessions.length
-        }
-    })
-    
-    return counts
-}
-
-// Clean up expired sessions periodically
-setInterval(() => {
-    cleanupAllSessions()
-}, 300000) // Every 5 minutes
-
-export default router

package/management-ui/server/api/users/simulation.js

@@ -1,254 +0,0 @@
-import express from 'express'
-import { wsHandler } from '../../websocket/handler.js'
-
-const router = express.Router()
-
-// Store active simulation sessions
-const simulationSessions = new Map()
-
-// Simulate user authentication for integration testing
-router.post('/authenticate', async (req, res) => {
-    const { userId, integrationId } = req.body
-    
-    if (!userId || !integrationId) {
-        return res.status(400).json({
-            error: 'userId and integrationId are required'
-        })
-    }
-    
-    try {
-        // Create a simulated auth token
-        const sessionId = `sim_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-        const authToken = `sim_token_${userId}_${integrationId}_${Date.now()}`
-        
-        const session = {
-            sessionId,
-            userId,
-            integrationId,
-            authToken,
-            createdAt: new Date().toISOString(),
-            expiresAt: new Date(Date.now() + 3600000).toISOString(), // 1 hour
-            status: 'active'
-        }
-        
-        simulationSessions.set(sessionId, session)
-        
-        // Broadcast simulation event
-        wsHandler.broadcast('simulation:auth', {
-            action: 'authenticated',
-            session,
-            timestamp: new Date().toISOString()
-        })
-        
-        res.json({
-            status: 'success',
-            session
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to simulate authentication'
-        })
-    }
-})
-
-// Simulate user actions within an integration
-router.post('/action', async (req, res) => {
-    const { sessionId, action, payload } = req.body
-    
-    if (!sessionId || !action) {
-        return res.status(400).json({
-            error: 'sessionId and action are required'
-        })
-    }
-    
-    const session = simulationSessions.get(sessionId)
-    if (!session) {
-        return res.status(404).json({
-            error: 'Session not found'
-        })
-    }
-    
-    try {
-        const actionResult = {
-            actionId: `action_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            sessionId,
-            userId: session.userId,
-            integrationId: session.integrationId,
-            action,
-            payload,
-            timestamp: new Date().toISOString(),
-            result: 'success',
-            response: generateMockResponse(action, payload)
-        }
-        
-        // Broadcast action event
-        wsHandler.broadcast('simulation:action', {
-            action: 'performed',
-            actionResult,
-            timestamp: new Date().toISOString()
-        })
-        
-        res.json({
-            status: 'success',
-            actionResult
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to simulate action'
-        })
-    }
-})
-
-// Get active simulation sessions
-router.get('/sessions', async (req, res) => {
-    try {
-        const sessions = Array.from(simulationSessions.values())
-            .filter(session => new Date(session.expiresAt) > new Date())
-        
-        res.json({
-            sessions,
-            total: sessions.length
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to fetch sessions'
-        })
-    }
-})
-
-// End a simulation session
-router.delete('/sessions/:sessionId', async (req, res) => {
-    const { sessionId } = req.params
-    
-    if (!simulationSessions.has(sessionId)) {
-        return res.status(404).json({
-            error: 'Session not found'
-        })
-    }
-    
-    try {
-        const session = simulationSessions.get(sessionId)
-        simulationSessions.delete(sessionId)
-        
-        // Broadcast session end
-        wsHandler.broadcast('simulation:session', {
-            action: 'ended',
-            sessionId,
-            userId: session.userId,
-            timestamp: new Date().toISOString()
-        })
-        
-        res.json({
-            status: 'success',
-            message: 'Session ended'
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to end session'
-        })
-    }
-})
-
-// Simulate integration webhook events
-router.post('/webhook', async (req, res) => {
-    const { userId, integrationId, event, data } = req.body
-    
-    if (!userId || !integrationId || !event) {
-        return res.status(400).json({
-            error: 'userId, integrationId, and event are required'
-        })
-    }
-    
-    try {
-        const webhookEvent = {
-            eventId: `webhook_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            userId,
-            integrationId,
-            event,
-            data,
-            timestamp: new Date().toISOString(),
-            processed: false
-        }
-        
-        // Broadcast webhook event
-        wsHandler.broadcast('simulation:webhook', {
-            action: 'received',
-            webhookEvent,
-            timestamp: new Date().toISOString()
-        })
-        
-        // Simulate processing delay
-        setTimeout(() => {
-            webhookEvent.processed = true
-            wsHandler.broadcast('simulation:webhook', {
-                action: 'processed',
-                webhookEvent,
-                timestamp: new Date().toISOString()
-            })
-        }, 1000)
-        
-        res.json({
-            status: 'success',
-            webhookEvent
-        })
-    } catch (error) {
-        res.status(500).json({
-            error: error.message,
-            details: 'Failed to simulate webhook'
-        })
-    }
-})
-
-// Helper function to generate mock responses
-function generateMockResponse(action, payload) {
-    const mockResponses = {
-        'list': {
-            items: [
-                { id: '1', name: 'Item 1', created: new Date().toISOString() },
-                { id: '2', name: 'Item 2', created: new Date().toISOString() }
-            ],
-            total: 2
-        },
-        'create': {
-            id: `item_${Date.now()}`,
-            ...payload,
-            created: new Date().toISOString()
-        },
-        'update': {
-            id: payload?.id || `item_${Date.now()}`,
-            ...payload,
-            updated: new Date().toISOString()
-        },
-        'delete': {
-            success: true,
-            deleted: new Date().toISOString()
-        },
-        'sync': {
-            synced: Math.floor(Math.random() * 100),
-            failed: Math.floor(Math.random() * 10),
-            timestamp: new Date().toISOString()
-        }
-    }
-    
-    return mockResponses[action] || { 
-        success: true, 
-        action, 
-        timestamp: new Date().toISOString() 
-    }
-}
-
-// Clean up expired sessions periodically
-setInterval(() => {
-    const now = new Date()
-    for (const [sessionId, session] of simulationSessions.entries()) {
-        if (new Date(session.expiresAt) < now) {
-            simulationSessions.delete(sessionId)
-        }
-    }
-}, 60000) // Every minute
-
-export default router