debug-time-machine-cli/bundled/backend-server.js

🚀 Debug Time Machine CLI - 완전 자동화된 React 디버깅 도구

#!/usr/bin/env node

// 번들된 백엔드 서버 (apps/backend를 기반으로 함)
const express = require('express');
const http = require('http');
const WebSocket = require('ws');
const cors = require('cors');
const helmet = require('helmet');
const compression = require('compression');
const path = require('path');

const app = express();
const port = process.env.PORT || 4000;

// 미들웨어 설정
app.use(helmet());
app.use(compression());
app.use(cors({
  origin: true,
  credentials: true
}));
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));

// 클라이언트 연결 관리
const clients = new Map();

// Health check 엔드포인트
app.get('/health', (req, res) => {
  res.json({ 
    status: 'ok', 
    timestamp: Date.now(),
    clients: clients.size,
    uptime: process.uptime()
  });
});

// Info 엔드포인트
app.get('/info', (req, res) => {
  res.json({
    name: 'Debug Time Machine Backend',
    version: '1.0.0',
    environment: process.env.NODE_ENV || 'development',
    port: port,
    clients: clients.size,
    uptime: process.uptime()
  });
});

// HTTP 서버 생성
const server = http.createServer(app);

// WebSocket 서버 설정
const wss = new WebSocket.Server({ 
  server,
  path: '/ws'
});

// 클라이언트 ID 생성
function generateClientId() {
  return `client_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
}

// 브로드캐스트 함수
function broadcast(message, excludeClient = null) {
  const messageStr = typeof message === 'string' ? message : JSON.stringify(message);
  
  clients.forEach((clientInfo, ws) => {
    if (ws !== excludeClient && ws.readyState === WebSocket.OPEN) {
      try {
        ws.send(messageStr);
      } catch (error) {
        console.error('브로드캐스트 오류:', error.message);
        clients.delete(ws);
      }
    }
  });
}

// WebSocket 연결 처리
wss.on('connection', (ws, req) => {
  const clientId = generateClientId();
  const clientIP = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
  
  const clientInfo = {
    id: clientId,
    ip: clientIP,
    connectedAt: new Date(),
    lastSeen: new Date(),
    userAgent: req.headers['user-agent'],
    messagesReceived: 0,
    messagesSent: 0
  };
  
  clients.set(ws, clientInfo);
  
  console.log(`🔗 클라이언트 연결: ${clientId} (${clientIP})`);
  console.log(`📊 총 연결된 클라이언트: ${clients.size}`);
  
  // Welcome 메시지 전송
  const welcomeMessage = {
    type: 'CONNECTION',
    payload: {
      type: 'welcome',
      clientId: clientId,
      serverTime: Date.now(),
      message: 'Debug Time Machine에 연결되었습니다!'
    },
    timestamp: Date.now()
  };
  
  try {
    ws.send(JSON.stringify(welcomeMessage));
    clientInfo.messagesSent++;
  } catch (error) {
    console.error('Welcome 메시지 전송 실패:', error.message);
  }
  
  // 메시지 수신 처리
  ws.on('message', (data) => {
    try {
      const message = JSON.parse(data.toString());
      clientInfo.lastSeen = new Date();
      clientInfo.messagesReceived++;
      
      console.log(`📨 [${clientId}] 메시지 수신: ${message.type}`);
      
      // 메시지 타입별 처리
      switch (message.type) {
        case 'CONNECTION':
          console.log(`🤝 [${clientId}] 연결 확인:`, message.payload?.type);
          break;
          
        case 'USER_ACTION':
          console.log(`👆 [${clientId}] 사용자 액션:`, message.payload?.actionType);
          // 다른 클라이언트들에게 브로드캐스트
          broadcast({
            type: 'USER_ACTION_BROADCAST',
            payload: message.payload,
            from: clientId,
            timestamp: Date.now()
          }, ws);
          break;
          
        case 'STATE_CHANGE':
          console.log(`🔄 [${clientId}] 상태 변경:`, message.payload?.componentName);
          broadcast({
            type: 'STATE_CHANGE_BROADCAST',
            payload: message.payload,
            from: clientId,
            timestamp: Date.now()
          }, ws);
          break;
          
        case 'ERROR':
          console.log(`🔴 [${clientId}] 에러:`, message.payload?.message);
          broadcast({
            type: 'ERROR_BROADCAST',
            payload: message.payload,
            from: clientId,
            timestamp: Date.now()
          }, ws);
          break;
          
        case 'PING':
          // PONG 응답
          ws.send(JSON.stringify({
            type: 'PONG',
            payload: {},
            timestamp: Date.now()
          }));
          clientInfo.messagesSent++;
          break;
          
        case 'PONG':
          console.log(`🏓 [${clientId}] PONG 수신`);
          break;
          
        default:
          console.log(`❓ [${clientId}] 알 수 없는 메시지 타입: ${message.type}`);
      }
      
    } catch (error) {
      console.error(`❌ [${clientId}] 메시지 파싱 오류:`, error.message);
      console.error('원본 데이터:', data.toString());
    }
  });
  
  // 연결 종료 처리
  ws.on('close', (code, reason) => {
    clients.delete(ws);
    console.log(`🔌 클라이언트 연결 해제: ${clientId} (코드: ${code}, 이유: ${reason || '없음'})`);
    console.log(`📊 남은 클라이언트: ${clients.size}`);
    
    // 연결 해제 알림 브로드캐스트
    broadcast({
      type: 'CLIENT_DISCONNECTED',
      payload: {
        clientId: clientId,
        timestamp: Date.now()
      }
    });
  });
  
  // 에러 처리
  ws.on('error', (error) => {
    console.error(`❌ [${clientId}] WebSocket 오류:`, error.message);
    clients.delete(ws);
  });
});

// Ping 타이머 (30초마다)
setInterval(() => {
  const pingMessage = {
    type: 'PING',
    payload: {},
    timestamp: Date.now()
  };
  
  clients.forEach((clientInfo, ws) => {
    if (ws.readyState === WebSocket.OPEN) {
      try {
        ws.send(JSON.stringify(pingMessage));
        clientInfo.messagesSent++;
      } catch (error) {
        console.error('PING 전송 실패:', error.message);
        clients.delete(ws);
      }
    } else {
      clients.delete(ws);
    }
  });
  
  if (clients.size > 0) {
    console.log(`🏓 PING 전송 (${clients.size}개 클라이언트)`);
  }
}, 30000);

// 서버 시작
server.listen(port, () => {
  console.log('');
  console.log('🚀 Debug Time Machine Backend Server');
  console.log(`📍 Port: ${port}`);
  console.log(`🔗 Health: http://localhost:${port}/health`);
  console.log(`🔗 WebSocket: ws://localhost:${port}/ws`);
  console.log(`🕐 Started: ${new Date().toISOString()}`);
  console.log('');
});

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('🛑 SIGTERM 신호 수신, 서버 종료 중...');
  
  // 모든 클라이언트에게 종료 알림
  broadcast({
    type: 'SERVER_SHUTDOWN',
    payload: {
      message: '서버가 종료됩니다.',
      timestamp: Date.now()
    }
  });
  
  // 연결 종료
  clients.forEach((_, ws) => {
    ws.close(1001, 'Server shutdown');
  });
  
  server.close(() => {
    console.log('✅ 서버가 정상적으로 종료되었습니다.');
    process.exit(0);
  });
});

process.on('SIGINT', () => {
  console.log('\n🛑 SIGINT 신호 수신, 서버 종료 중...');
  process.emit('SIGTERM');
});