tlc-claude-code 0.9.6 → 0.9.8

package/server/lib/dev-server-command.test.js

@@ -0,0 +1,326 @@
+import { describe, it, expect } from 'vitest';
+import {
+  analyzeProject,
+  detectInfrastructure,
+  generateDockerFiles,
+  formatAnalysis,
+  formatStackStatus,
+  createServerState,
+  getStartSequence,
+  getDashboardUrl,
+} from './dev-server-command.js';
+
+describe('dev-server-command', () => {
+  describe('analyzeProject', () => {
+    it('detects services from package.json', () => {
+      const files = {
+        'package.json': JSON.stringify({
+          name: 'my-app',
+          dependencies: { express: '4.18.0' },
+        }),
+      };
+
+      const analysis = analyzeProject(files);
+
+      expect(analysis.services).toHaveLength(1);
+      expect(analysis.services[0].type).toBe('express');
+    });
+
+    it('detects existing docker-compose', () => {
+      const files = {
+        'docker-compose.yml': 'services:\n  api:\n    build: .',
+        'package.json': JSON.stringify({ name: 'api' }),
+      };
+
+      const analysis = analyzeProject(files);
+
+      expect(analysis.hasDockerCompose).toBe(true);
+    });
+
+    it('identifies files needing generation', () => {
+      const files = {
+        'package.json': JSON.stringify({ name: 'app' }),
+      };
+
+      const analysis = analyzeProject(files);
+
+      expect(analysis.needsGeneration).toContain('docker-compose.yml');
+    });
+
+    it('detects monorepo services', () => {
+      const files = {
+        'services/api/package.json': JSON.stringify({ name: 'api' }),
+        'services/web/package.json': JSON.stringify({ name: 'web', dependencies: { vite: '5.0.0' } }),
+      };
+
+      const analysis = analyzeProject(files);
+
+      expect(analysis.services.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('detectInfrastructure', () => {
+    it('detects postgres requirement', () => {
+      const files = {
+        '.env': 'DATABASE_URL=postgres://localhost:5432/db',
+      };
+
+      const infra = detectInfrastructure(files);
+
+      expect(infra).toContain('postgres');
+    });
+
+    it('detects redis requirement', () => {
+      const files = {
+        'src/cache.js': 'import redis from "redis"',
+      };
+
+      const infra = detectInfrastructure(files);
+
+      expect(infra).toContain('redis');
+    });
+
+    it('detects minio/S3 requirement', () => {
+      const files = {
+        'src/storage.js': 'const S3_BUCKET = process.env.S3_BUCKET',
+      };
+
+      const infra = detectInfrastructure(files);
+
+      expect(infra).toContain('minio');
+    });
+
+    it('returns empty array when no infra detected', () => {
+      const files = {
+        'index.js': 'console.log("hello")',
+      };
+
+      const infra = detectInfrastructure(files);
+
+      expect(infra).toHaveLength(0);
+    });
+  });
+
+  describe('generateDockerFiles', () => {
+    it('generates docker-compose when needed', () => {
+      const analysis = {
+        services: [{ name: 'app', type: 'express', port: 3000 }],
+        needsGeneration: ['docker-compose.yml'],
+        infrastructure: [],
+      };
+
+      const files = generateDockerFiles(analysis);
+
+      expect(files['docker-compose.yml']).toBeDefined();
+      expect(files['docker-compose.yml']).toContain('services:');
+    });
+
+    it('generates Dockerfile when needed', () => {
+      const analysis = {
+        services: [{ name: 'api', type: 'express', port: 3000, path: '.' }],
+        needsGeneration: ['./Dockerfile'],
+        infrastructure: [],
+      };
+
+      const files = generateDockerFiles(analysis);
+
+      expect(files['./Dockerfile']).toBeDefined();
+      expect(files['./Dockerfile']).toContain('FROM node:');
+    });
+
+    it('skips files not in needsGeneration', () => {
+      const analysis = {
+        services: [{ name: 'app', type: 'nodejs', port: 3000 }],
+        needsGeneration: [],
+        infrastructure: [],
+      };
+
+      const files = generateDockerFiles(analysis);
+
+      expect(Object.keys(files)).toHaveLength(0);
+    });
+  });
+
+  describe('formatAnalysis', () => {
+    it('formats services table', () => {
+      const analysis = {
+        services: [
+          { name: 'api', type: 'express', port: 3000, path: './api' },
+          { name: 'web', type: 'vite', port: 5173, path: './web' },
+        ],
+        infrastructure: [],
+        needsGeneration: [],
+      };
+
+      const output = formatAnalysis(analysis);
+
+      expect(output).toContain('| api | express | 3000 | ./api |');
+      expect(output).toContain('| web | vite | 5173 | ./web |');
+    });
+
+    it('shows infrastructure when detected', () => {
+      const analysis = {
+        services: [],
+        infrastructure: ['postgres', 'redis'],
+        needsGeneration: [],
+      };
+
+      const output = formatAnalysis(analysis);
+
+      expect(output).toContain('## Infrastructure');
+      expect(output).toContain('postgres, redis');
+    });
+
+    it('lists files to generate', () => {
+      const analysis = {
+        services: [],
+        infrastructure: [],
+        needsGeneration: ['docker-compose.yml', './Dockerfile'],
+      };
+
+      const output = formatAnalysis(analysis);
+
+      expect(output).toContain('## Files to Generate');
+      expect(output).toContain('- docker-compose.yml');
+    });
+  });
+
+  describe('formatStackStatus', () => {
+    it('shows healthy status with icon', () => {
+      const health = {
+        status: 'healthy',
+        running: 2,
+        total: 2,
+        containers: [
+          { name: 'api', state: 'running' },
+          { name: 'web', state: 'running' },
+        ],
+      };
+
+      const output = formatStackStatus(health);
+
+      expect(output).toContain('✅');
+      expect(output).toContain('healthy');
+      expect(output).toContain('2/2');
+    });
+
+    it('shows degraded status', () => {
+      const health = {
+        status: 'degraded',
+        running: 1,
+        total: 2,
+        unhealthy: 1,
+        containers: [
+          { name: 'api', state: 'running' },
+          { name: 'db', state: 'exited' },
+        ],
+      };
+
+      const output = formatStackStatus(health);
+
+      expect(output).toContain('⚠️');
+      expect(output).toContain('degraded');
+    });
+
+    it('shows container list with states', () => {
+      const health = {
+        status: 'healthy',
+        running: 1,
+        total: 1,
+        containers: [{ name: 'api', state: 'running', health: 'healthy' }],
+      };
+
+      const output = formatStackStatus(health);
+
+      expect(output).toContain('| api |');
+      expect(output).toContain('🟢 running');
+    });
+  });
+
+  describe('createServerState', () => {
+    it('creates state manager with initial state', () => {
+      const state = createServerState();
+
+      expect(state.getState().services).toHaveLength(0);
+      expect(state.getState().isRunning).toBe(false);
+    });
+
+    it('sets services and creates log buffers', () => {
+      const state = createServerState();
+
+      state.setServices([{ name: 'api' }, { name: 'web' }]);
+
+      expect(state.getState().services).toHaveLength(2);
+      expect(state.getState().logBuffers.api).toBeDefined();
+      expect(state.getState().logBuffers.web).toBeDefined();
+    });
+
+    it('adds and retrieves logs', () => {
+      const state = createServerState();
+      state.setServices([{ name: 'api' }]);
+
+      state.addLog('api', { message: 'Server started', level: 'info' });
+      state.addLog('api', { message: 'Request received', level: 'debug' });
+
+      const logs = state.getLogs('api', 10);
+
+      expect(logs).toHaveLength(2);
+      expect(logs[0].message).toBe('Server started');
+    });
+
+    it('tracks running state and uptime', () => {
+      const state = createServerState();
+
+      state.setRunning(true);
+
+      expect(state.getState().isRunning).toBe(true);
+      expect(state.getUptime()).toBeGreaterThanOrEqual(0);
+
+      state.setRunning(false);
+
+      expect(state.getUptime()).toBeNull();
+    });
+
+    it('aggregates logs from all services', () => {
+      const state = createServerState();
+      state.setServices([{ name: 'api' }, { name: 'web' }]);
+
+      state.addLog('api', { message: 'API log', timestamp: '2024-01-15T10:00:01Z' });
+      state.addLog('web', { message: 'Web log', timestamp: '2024-01-15T10:00:00Z' });
+
+      const allLogs = state.getLogs(null, 10);
+
+      expect(allLogs).toHaveLength(2);
+      // Should be sorted by timestamp
+      expect(allLogs[0].message).toBe('Web log');
+    });
+  });
+
+  describe('getStartSequence', () => {
+    it('returns build command', () => {
+      const analysis = {
+        services: [{ name: 'app', type: 'express' }],
+      };
+
+      const commands = getStartSequence(analysis);
+
+      expect(commands).toHaveLength(1);
+      expect(commands[0].name).toBe('build');
+      expect(commands[0].command).toContain('docker compose');
+    });
+  });
+
+  describe('getDashboardUrl', () => {
+    it('returns default dashboard URL', () => {
+      const url = getDashboardUrl();
+
+      expect(url).toBe('http://localhost:3147');
+    });
+
+    it('uses custom host and port', () => {
+      const url = getDashboardUrl({ host: '192.168.1.100', port: 8080 });
+
+      expect(url).toBe('http://192.168.1.100:8080');
+    });
+  });
+});

package/server/lib/dev-server-runtime.js

@@ -0,0 +1,382 @@
+/**
+ * Dev Server Runtime Module
+ * Main entry point that integrates all Phase 3 components
+ */
+
+const { createServerState, analyzeProject, formatStackStatus } = require('./dev-server-command');
+const { getStartCommand, getStopCommand, getLogsCommand, parseComposeStatus, getStackHealth } = require('./container-orchestrator');
+const { createConnectionManager, createLogMessage, createStackStatusMessage, handleMessage, parseMessage } = require('./websocket-server');
+const { createWatcherOptions, createChangeEvent, getAffectedService, batchChanges } = require('./file-watcher');
+const { formatLogEntry, createLogBuffer } = require('./log-streamer');
+
+/**
+ * Server configuration defaults
+ */
+const DEFAULT_CONFIG = {
+  port: 3147,
+  host: 'localhost',
+  logBufferSize: 1000,
+  statusPollInterval: 5000,
+  logPollInterval: 1000,
+};
+
+/**
+ * Create the dev server runtime
+ * @param {Object} options - Runtime options
+ * @returns {Object} Runtime instance
+ */
+function createDevServerRuntime(options = {}) {
+  const config = { ...DEFAULT_CONFIG, ...options };
+  const state = createServerState();
+  const connections = createConnectionManager();
+  const logBuffer = createLogBuffer({ maxSize: config.logBufferSize });
+
+  let statusPollTimer = null;
+  let logPollTimer = null;
+  let isRunning = false;
+
+  return {
+    config,
+    state,
+    connections,
+
+    /**
+     * Get current runtime status
+     */
+    getStatus() {
+      return {
+        isRunning,
+        config,
+        connections: connections.getConnectionCount(),
+        services: state.getState().services,
+        health: state.getState().health,
+        uptime: state.getUptime(),
+      };
+    },
+
+    /**
+     * Initialize runtime with project analysis
+     * @param {Object} files - Project files map
+     */
+    initialize(files) {
+      const analysis = analyzeProject(files);
+      state.setServices(analysis.services);
+      return analysis;
+    },
+
+    /**
+     * Start polling for container status
+     * @param {Function} execCommand - Function to execute shell commands
+     */
+    startStatusPolling(execCommand) {
+      if (statusPollTimer) return;
+
+      const poll = async () => {
+        try {
+          const cmd = getStartCommand({ detached: true });
+          // In real implementation, this would use execCommand
+          // For now, we just update state
+        } catch (err) {
+          // Log error but continue polling
+        }
+      };
+
+      statusPollTimer = setInterval(poll, config.statusPollInterval);
+      poll(); // Initial poll
+    },
+
+    /**
+     * Stop status polling
+     */
+    stopStatusPolling() {
+      if (statusPollTimer) {
+        clearInterval(statusPollTimer);
+        statusPollTimer = null;
+      }
+    },
+
+    /**
+     * Update container status from docker compose ps output
+     * @param {string} output - JSON output from docker compose ps
+     */
+    updateContainerStatus(output) {
+      const containers = parseComposeStatus(output);
+      state.updateContainers(containers);
+
+      // Broadcast to subscribed clients
+      const health = state.getState().health;
+      const message = createStackStatusMessage(health);
+      this.broadcastToStatusSubscribers(message);
+
+      return health;
+    },
+
+    /**
+     * Add log entry and broadcast to subscribers
+     * @param {Object} entry - Log entry
+     */
+    addLogEntry(entry) {
+      const enrichedEntry = {
+        ...entry,
+        timestamp: entry.timestamp || new Date().toISOString(),
+      };
+
+      logBuffer.add(enrichedEntry);
+      state.addLog(entry.service || 'system', enrichedEntry);
+
+      // Broadcast to subscribed clients
+      const message = createLogMessage(enrichedEntry);
+      this.broadcastToLogSubscribers(entry.service, message);
+
+      return enrichedEntry;
+    },
+
+    /**
+     * Get recent logs
+     * @param {string} service - Optional service filter
+     * @param {number} count - Number of entries
+     */
+    getLogs(service, count = 100) {
+      // Use main log buffer - it contains all entries
+      const allLogs = logBuffer.getRecent(count * 2); // Get more to allow for filtering
+
+      if (service) {
+        return allLogs.filter(l => l.service === service).slice(-count);
+      }
+
+      return allLogs.slice(-count);
+    },
+
+    /**
+     * Handle WebSocket connection
+     * @param {Object} ws - WebSocket instance
+     */
+    handleConnection(ws) {
+      const client = connections.addClient();
+
+      ws.clientId = client.clientId;
+
+      ws.on('message', (raw) => {
+        const message = parseMessage(raw.toString());
+        if (!message) return;
+
+        const response = handleMessage(client, message);
+        if (response) {
+          ws.send(JSON.stringify(response));
+        }
+
+        // Send initial logs if subscribing
+        if (message.type === 'subscribe_logs') {
+          const recentLogs = this.getLogs(null, 50);
+          ws.send(JSON.stringify({
+            type: 'log_batch',
+            entries: recentLogs,
+          }));
+        }
+
+        // Send current status if subscribing
+        if (message.type === 'subscribe_status') {
+          const health = state.getState().health;
+          if (health) {
+            ws.send(createStackStatusMessage(health));
+          }
+        }
+      });
+
+      ws.on('close', () => {
+        connections.removeClient(client.clientId);
+      });
+
+      return client;
+    },
+
+    /**
+     * Broadcast message to log subscribers
+     * @param {string} service - Service name
+     * @param {string} message - JSON message
+     */
+    broadcastToLogSubscribers(service, message) {
+      const subscribers = connections.getLogSubscribers(service || '*');
+      // In real implementation, would send to actual WebSocket connections
+      return subscribers.length;
+    },
+
+    /**
+     * Broadcast message to status subscribers
+     * @param {string} message - JSON message
+     */
+    broadcastToStatusSubscribers(message) {
+      const subscribers = connections.getStatusSubscribers();
+      // In real implementation, would send to actual WebSocket connections
+      return subscribers.length;
+    },
+
+    /**
+     * Handle file change event
+     * @param {string} path - Changed file path
+     * @param {string} changeType - Type of change
+     */
+    handleFileChange(path, changeType) {
+      const services = state.getState().services;
+      const affectedService = getAffectedService(path, services);
+      const event = createChangeEvent(path, changeType, affectedService);
+
+      // Add log entry for the change
+      this.addLogEntry({
+        service: 'watcher',
+        level: 'info',
+        message: `File ${changeType}: ${path}`,
+      });
+
+      return event;
+    },
+
+    /**
+     * Mark runtime as started
+     */
+    start() {
+      isRunning = true;
+      state.setRunning(true);
+      this.addLogEntry({
+        service: 'system',
+        level: 'info',
+        message: 'Dev server started',
+      });
+    },
+
+    /**
+     * Mark runtime as stopped
+     */
+    stop() {
+      this.stopStatusPolling();
+      isRunning = false;
+      state.setRunning(false);
+      this.addLogEntry({
+        service: 'system',
+        level: 'info',
+        message: 'Dev server stopped',
+      });
+    },
+
+    /**
+     * Get commands for starting containers
+     */
+    getStartCommands() {
+      return {
+        start: getStartCommand({ build: true, detached: true }),
+        logs: getLogsCommand({ follow: true, timestamps: true }),
+      };
+    },
+
+    /**
+     * Get command for stopping containers
+     */
+    getStopCommand() {
+      return getStopCommand({ removeOrphans: true });
+    },
+  };
+}
+
+/**
+ * Create HTTP request handler for the dev server
+ * @param {Object} runtime - Dev server runtime
+ * @returns {Function} Request handler
+ */
+function createRequestHandler(runtime) {
+  return (req, res) => {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+
+    // API routes
+    if (url.pathname === '/api/status') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(runtime.getStatus()));
+      return;
+    }
+
+    if (url.pathname === '/api/logs') {
+      const service = url.searchParams.get('service');
+      const count = parseInt(url.searchParams.get('count') || '100', 10);
+      const logs = runtime.getLogs(service, count);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ logs }));
+      return;
+    }
+
+    if (url.pathname === '/api/services') {
+      const services = runtime.state.getState().services;
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ services }));
+      return;
+    }
+
+    // Health check
+    if (url.pathname === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'ok' }));
+      return;
+    }
+
+    // 404 for unknown routes
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not found' }));
+  };
+}
+
+/**
+ * Parse command line arguments
+ * @param {Array} args - Command line arguments
+ * @returns {Object} Parsed options
+ */
+function parseArgs(args) {
+  const options = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--port' || arg === '-p') {
+      options.port = parseInt(args[++i], 10);
+    } else if (arg === '--host' || arg === '-h') {
+      options.host = args[++i];
+    } else if (arg === '--build' || arg === '-b') {
+      options.build = true;
+    } else if (arg === '--no-watch') {
+      options.watch = false;
+    } else if (arg === '--help') {
+      options.help = true;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Format help text
+ * @returns {string} Help text
+ */
+function formatHelp() {
+  return `
+TLC Dev Server
+
+Usage: tlc start [options]
+
+Options:
+  -p, --port <port>    Server port (default: 3147)
+  -h, --host <host>    Server host (default: localhost)
+  -b, --build          Rebuild containers before starting
+  --no-watch           Disable file watching
+  --help               Show this help message
+
+Examples:
+  tlc start                    Start with defaults
+  tlc start --port 8080        Use custom port
+  tlc start --build            Rebuild containers first
+`.trim();
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  createDevServerRuntime,
+  createRequestHandler,
+  parseArgs,
+  formatHelp,
+};