tlc-claude-code 1.4.8 → 1.4.9

package/server/lib/dashboard/api-server.js

@@ -0,0 +1,155 @@
+/**
+ * Dashboard API Server
+ * Express server mounting all dashboard APIs
+ */
+
+import express from 'express';
+
+/**
+ * Creates a standardized error response
+ * @param {string} message - Error message
+ * @param {number} statusCode - HTTP status code
+ * @returns {Object} Error response object
+ */
+export function createErrorResponse(message, statusCode = 500) {
+  return {
+    error: message,
+    statusCode,
+    timestamp: new Date().toISOString()
+  };
+}
+
+/**
+ * CORS middleware for handling cross-origin requests
+ * @param {Object} req - Express request
+ * @param {Object} res - Express response
+ * @param {Function} next - Next middleware
+ * @param {Object} options - CORS options
+ */
+export function corsMiddleware(req, res, next, options = {}) {
+  const origin = options.origin || '*';
+
+  res.header('Access-Control-Allow-Origin', origin);
+  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+
+  if (req.method === 'OPTIONS') {
+    res.sendStatus(200);
+    return;
+  }
+
+  next();
+}
+
+/**
+ * Request logger middleware
+ * @param {Object} req - Express request
+ * @param {Object} res - Express response
+ * @param {Function} next - Next middleware
+ * @param {Object} options - Logger options
+ */
+export function requestLogger(req, res, next, options = {}) {
+  const logger = options.logger || console;
+  const startTime = Date.now();
+
+  logger.info(`${req.method} ${req.url}`);
+
+  res.on('finish', () => {
+    const duration = Date.now() - startTime;
+    logger.info(`${req.method} ${req.url} ${res.statusCode} ${duration}ms`);
+  });
+
+  next();
+}
+
+/**
+ * Error handler middleware
+ * @param {Error} error - Error object
+ * @param {Object} req - Express request
+ * @param {Object} res - Express response
+ * @param {Function} next - Next middleware
+ * @param {Object} options - Error handler options
+ */
+export function handleError(error, req, res, next, options = {}) {
+  const statusCode = error.statusCode || 500;
+  const response = {
+    error: error.message || 'Internal server error'
+  };
+
+  if (options.env !== 'production') {
+    response.stack = error.stack;
+  }
+
+  res.status(statusCode).json(response);
+}
+
+/**
+ * Mounts all API routes on the Express app
+ * @param {Object} app - Express app or router
+ * @param {Object} options - Route options
+ */
+export function mountRoutes(app, options = {}) {
+  // Tasks API
+  app.get('/api/tasks', (req, res) => {
+    res.json({ tasks: [] });
+  });
+
+  app.post('/api/tasks', (req, res) => {
+    res.status(201).json({ task: {} });
+  });
+
+  if (app.patch) {
+    app.patch('/api/tasks/:id', (req, res) => {
+      res.json({ task: {} });
+    });
+  }
+
+  if (app.delete) {
+    app.delete('/api/tasks/:id', (req, res) => {
+      res.status(204).send();
+    });
+  }
+
+  // Health API
+  app.get('/api/health', (req, res) => {
+    res.json({ status: 'ok', timestamp: new Date().toISOString() });
+  });
+
+  // Notes API
+  app.get('/api/notes', (req, res) => {
+    res.json({ notes: [] });
+  });
+
+  if (app.put) {
+    app.put('/api/notes', (req, res) => {
+      res.json({ note: {} });
+    });
+  }
+
+  // Router API
+  app.get('/api/router/status', (req, res) => {
+    res.json({ status: 'running' });
+  });
+}
+
+/**
+ * Creates the Express API server
+ * @param {Object} options - Server options
+ * @param {string} options.basePath - Base path for serving files
+ * @returns {Object} Express app
+ */
+export function createApiServer(options = {}) {
+  const app = express();
+
+  // Middleware
+  app.use(express.json());
+  app.use((req, res, next) => corsMiddleware(req, res, next));
+
+  // Mount routes
+  mountRoutes(app, options);
+
+  // Error handler
+  app.use((err, req, res, next) => handleError(err, req, res, next, options));
+
+  return app;
+}

package/server/lib/dashboard/api-server.test.js

@@ -0,0 +1,155 @@
+/**
+ * Dashboard API Server Tests
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { createApiServer, mountRoutes, handleError, corsMiddleware, requestLogger, createErrorResponse } from './api-server.js';
+
+describe('api-server', () => {
+  describe('createApiServer', () => {
+    it('creates Express app', () => {
+      const app = createApiServer({ basePath: '/test' });
+      expect(app.listen).toBeDefined();
+      expect(app.use).toBeDefined();
+    });
+
+    it('mounts API routes', () => {
+      const app = createApiServer({ basePath: '/test' });
+      // Routes should be mounted at /api/*
+      expect(app._router).toBeDefined();
+    });
+  });
+
+  describe('mountRoutes', () => {
+    it('mounts tasks API', () => {
+      const mockApp = { get: vi.fn(), post: vi.fn(), put: vi.fn(), patch: vi.fn(), delete: vi.fn() };
+      mountRoutes(mockApp, { basePath: '/test' });
+      expect(mockApp.get).toHaveBeenCalledWith('/api/tasks', expect.any(Function));
+      expect(mockApp.post).toHaveBeenCalledWith('/api/tasks', expect.any(Function));
+    });
+
+    it('mounts health API', () => {
+      const mockApp = { get: vi.fn(), post: vi.fn(), put: vi.fn(), patch: vi.fn(), delete: vi.fn() };
+      mountRoutes(mockApp, { basePath: '/test' });
+      expect(mockApp.get).toHaveBeenCalledWith('/api/health', expect.any(Function));
+    });
+
+    it('mounts notes API', () => {
+      const mockApp = { get: vi.fn(), post: vi.fn(), put: vi.fn(), patch: vi.fn(), delete: vi.fn() };
+      mountRoutes(mockApp, { basePath: '/test' });
+      expect(mockApp.get).toHaveBeenCalledWith('/api/notes', expect.any(Function));
+      expect(mockApp.put).toHaveBeenCalledWith('/api/notes', expect.any(Function));
+    });
+
+    it('mounts router API', () => {
+      const mockApp = { get: vi.fn(), post: vi.fn(), put: vi.fn(), patch: vi.fn(), delete: vi.fn() };
+      mountRoutes(mockApp, { basePath: '/test' });
+      expect(mockApp.get).toHaveBeenCalledWith('/api/router/status', expect.any(Function));
+    });
+  });
+
+  describe('handleError', () => {
+    it('returns error response', () => {
+      const mockRes = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn()
+      };
+      const error = new Error('Test error');
+      handleError(error, {}, mockRes, () => {});
+      expect(mockRes.status).toHaveBeenCalledWith(500);
+      expect(mockRes.json).toHaveBeenCalledWith(
+        expect.objectContaining({ error: expect.any(String) })
+      );
+    });
+
+    it('uses error status code', () => {
+      const mockRes = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn()
+      };
+      const error = new Error('Not found');
+      error.statusCode = 404;
+      handleError(error, {}, mockRes, () => {});
+      expect(mockRes.status).toHaveBeenCalledWith(404);
+    });
+
+    it('hides stack trace in production', () => {
+      const mockRes = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn()
+      };
+      const error = new Error('Error');
+      handleError(error, {}, mockRes, () => {}, { env: 'production' });
+      const response = mockRes.json.mock.calls[0][0];
+      expect(response.stack).toBeUndefined();
+    });
+  });
+
+  describe('corsMiddleware', () => {
+    it('sets CORS headers', () => {
+      const mockRes = {
+        header: vi.fn()
+      };
+      const mockNext = vi.fn();
+      corsMiddleware({}, mockRes, mockNext);
+      expect(mockRes.header).toHaveBeenCalledWith('Access-Control-Allow-Origin', expect.any(String));
+      expect(mockNext).toHaveBeenCalled();
+    });
+
+    it('handles preflight requests', () => {
+      const mockReq = { method: 'OPTIONS' };
+      const mockRes = {
+        header: vi.fn(),
+        sendStatus: vi.fn()
+      };
+      corsMiddleware(mockReq, mockRes, () => {});
+      expect(mockRes.sendStatus).toHaveBeenCalledWith(200);
+    });
+
+    it('allows configurable origins', () => {
+      const mockRes = { header: vi.fn() };
+      const mockNext = vi.fn();
+      corsMiddleware({}, mockRes, mockNext, { origin: 'http://localhost:3000' });
+      expect(mockRes.header).toHaveBeenCalledWith('Access-Control-Allow-Origin', 'http://localhost:3000');
+    });
+  });
+
+  describe('requestLogger', () => {
+    it('logs requests', () => {
+      const mockLogger = { info: vi.fn() };
+      const mockReq = { method: 'GET', url: '/api/tasks' };
+      const mockRes = { on: vi.fn() };
+      const mockNext = vi.fn();
+
+      requestLogger(mockReq, mockRes, mockNext, { logger: mockLogger });
+      expect(mockLogger.info).toHaveBeenCalled();
+      expect(mockNext).toHaveBeenCalled();
+    });
+
+    it('logs response time', () => {
+      const mockLogger = { info: vi.fn() };
+      const mockReq = { method: 'GET', url: '/test' };
+      let finishCallback;
+      const mockRes = {
+        on: vi.fn((event, cb) => { if (event === 'finish') finishCallback = cb; }),
+        statusCode: 200
+      };
+
+      requestLogger(mockReq, mockRes, () => {}, { logger: mockLogger });
+      finishCallback();
+      expect(mockLogger.info).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('createErrorResponse', () => {
+    it('creates standard error format', () => {
+      const response = createErrorResponse('Not found', 404);
+      expect(response.error).toBe('Not found');
+      expect(response.statusCode).toBe(404);
+    });
+
+    it('includes timestamp', () => {
+      const response = createErrorResponse('Error');
+      expect(response.timestamp).toBeDefined();
+    });
+  });
+});

package/server/lib/dashboard/health-api.js

@@ -0,0 +1,199 @@
+/**
+ * Health API Module
+ * Health check endpoint
+ */
+import { promises as defaultFs } from 'fs';
+import os from 'os';
+import path from 'path';
+
+const startTime = Date.now();
+
+/**
+ * Get health status
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Health status
+ */
+export async function getHealthStatus(options = {}) {
+  const checkDeps = options.checkDeps || (() => Promise.resolve({ healthy: true }));
+
+  const depsResult = await checkDeps();
+
+  const status = depsResult.healthy ? 'healthy' : 'degraded';
+  const uptime = Math.floor((Date.now() - startTime) / 1000);
+
+  const result = {
+    status,
+    timestamp: new Date().toISOString(),
+    uptime
+  };
+
+  if (!depsResult.healthy && depsResult.issues) {
+    result.issues = depsResult.issues;
+  }
+
+  return result;
+}
+
+/**
+ * Get system metrics
+ * @returns {Object} System metrics
+ */
+export function getSystemMetrics() {
+  const memUsage = process.memoryUsage();
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+  const cpus = os.cpus();
+
+  // Calculate CPU usage (simple average of all cores)
+  let cpuUsage = 0;
+  if (cpus.length > 0) {
+    const totalCpuTime = cpus.reduce((acc, cpu) => {
+      const total = Object.values(cpu.times).reduce((sum, time) => sum + time, 0);
+      const idle = cpu.times.idle;
+      return acc + ((total - idle) / total);
+    }, 0);
+    cpuUsage = totalCpuTime / cpus.length;
+  }
+
+  return {
+    memory: {
+      used: memUsage.heapUsed,
+      total: memUsage.heapTotal,
+      systemUsed: totalMem - freeMem,
+      systemTotal: totalMem
+    },
+    cpu: {
+      usage: cpuUsage,
+      cores: cpus.length,
+      model: cpus[0]?.model || 'unknown'
+    },
+    pid: process.pid,
+    nodeVersion: process.version,
+    platform: process.platform,
+    uptime: process.uptime()
+  };
+}
+
+/**
+ * Check dependencies
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Dependency status
+ */
+export async function checkDependencies(options = {}) {
+  const fs = options.fs || defaultFs;
+  const basePath = options.basePath || process.cwd();
+
+  const result = {
+    filesystem: false,
+    issues: []
+  };
+
+  // Check filesystem access
+  try {
+    await fs.access(basePath);
+    result.filesystem = true;
+  } catch {
+    result.filesystem = false;
+    result.issues.push('Filesystem not accessible');
+  }
+
+  // Aggregate health status
+  result.healthy = result.filesystem;
+
+  return result;
+}
+
+/**
+ * Run test suite
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Test results
+ */
+export async function runTestSuite(options = {}) {
+  const exec = options.exec;
+
+  if (!exec) {
+    return { error: 'No exec function provided' };
+  }
+
+  try {
+    const { stdout, stderr } = await exec('npm test');
+
+    // Parse test output
+    let passed = 0;
+    let failed = 0;
+    let total = 0;
+
+    // Try to parse different test output formats
+    // Format: "Tests: X passed | Y failed"
+    const testMatch = stdout.match(/Tests?:\s*(\d+)\s*passed(?:\s*\|\s*(\d+)\s*failed)?/i);
+    if (testMatch) {
+      passed = parseInt(testMatch[1], 10);
+      failed = testMatch[2] ? parseInt(testMatch[2], 10) : 0;
+      total = passed + failed;
+    } else {
+      // Format: "X passed"
+      const passedMatch = stdout.match(/(\d+)\s*passed/i);
+      if (passedMatch) {
+        passed = parseInt(passedMatch[1], 10);
+        total = passed;
+      }
+
+      const failedMatch = stdout.match(/(\d+)\s*failed/i);
+      if (failedMatch) {
+        failed = parseInt(failedMatch[1], 10);
+        total = passed + failed;
+      }
+    }
+
+    return {
+      passed,
+      failed,
+      total,
+      stdout,
+      stderr
+    };
+  } catch (error) {
+    return {
+      error: error.message,
+      passed: 0,
+      failed: 0,
+      total: 0
+    };
+  }
+}
+
+/**
+ * Create Health API handler
+ * @param {Object} options - Options
+ * @returns {Object} API handler
+ */
+export function createHealthApi(options = {}) {
+  const { basePath = process.cwd(), fs: fileSystem = defaultFs, cacheMs = 5000 } = options;
+  const checkDeps = options.checkDeps || (() => checkDependencies({ fs: fileSystem, basePath }));
+
+  let cachedStatus = null;
+  let cacheTime = 0;
+
+  return {
+    async get() {
+      const now = Date.now();
+
+      if (cachedStatus && (now - cacheTime) < cacheMs) {
+        return cachedStatus;
+      }
+
+      cachedStatus = await getHealthStatus({ checkDeps });
+      cacheTime = now;
+
+      return cachedStatus;
+    },
+
+    getMetrics() {
+      return getSystemMetrics();
+    },
+
+    async runTests(execFn) {
+      return runTestSuite({ exec: execFn });
+    }
+  };
+}

package/server/lib/dashboard/health-api.test.js

@@ -0,0 +1,122 @@
+/**
+ * Health API Module Tests
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { getHealthStatus, getSystemMetrics, checkDependencies, runTestSuite, createHealthApi } from './health-api.js';
+
+describe('health-api', () => {
+  describe('getHealthStatus', () => {
+    it('returns healthy status', async () => {
+      const status = await getHealthStatus({
+        checkDeps: vi.fn().mockResolvedValue({ healthy: true })
+      });
+      expect(status.status).toBe('healthy');
+      expect(status.timestamp).toBeDefined();
+    });
+
+    it('returns degraded on dependency issues', async () => {
+      const status = await getHealthStatus({
+        checkDeps: vi.fn().mockResolvedValue({ healthy: false, issues: ['db down'] })
+      });
+      expect(status.status).toBe('degraded');
+      expect(status.issues).toContain('db down');
+    });
+
+    it('includes uptime', async () => {
+      const status = await getHealthStatus({
+        checkDeps: vi.fn().mockResolvedValue({ healthy: true })
+      });
+      expect(status.uptime).toBeDefined();
+      expect(typeof status.uptime).toBe('number');
+    });
+  });
+
+  describe('getSystemMetrics', () => {
+    it('returns memory metrics', () => {
+      const metrics = getSystemMetrics();
+      expect(metrics.memory).toBeDefined();
+      expect(metrics.memory.used).toBeDefined();
+      expect(metrics.memory.total).toBeDefined();
+    });
+
+    it('returns cpu metrics', () => {
+      const metrics = getSystemMetrics();
+      expect(metrics.cpu).toBeDefined();
+    });
+
+    it('returns process info', () => {
+      const metrics = getSystemMetrics();
+      expect(metrics.pid).toBeDefined();
+      expect(metrics.nodeVersion).toBeDefined();
+    });
+  });
+
+  describe('checkDependencies', () => {
+    it('checks file system access', async () => {
+      const mockFs = {
+        access: vi.fn().mockResolvedValue(undefined)
+      };
+      const result = await checkDependencies({ fs: mockFs, basePath: '/test' });
+      expect(result.filesystem).toBe(true);
+    });
+
+    it('reports missing directories', async () => {
+      const mockFs = {
+        access: vi.fn().mockRejectedValue(new Error('ENOENT'))
+      };
+      const result = await checkDependencies({ fs: mockFs, basePath: '/test' });
+      expect(result.filesystem).toBe(false);
+    });
+
+    it('aggregates health status', async () => {
+      const mockFs = {
+        access: vi.fn().mockResolvedValue(undefined)
+      };
+      const result = await checkDependencies({ fs: mockFs, basePath: '/test' });
+      expect(result.healthy).toBe(true);
+    });
+  });
+
+  describe('runTestSuite', () => {
+    it('returns test results', async () => {
+      const mockExec = vi.fn().mockResolvedValue({
+        stdout: '5541 passed',
+        stderr: ''
+      });
+      const result = await runTestSuite({ exec: mockExec });
+      expect(result.passed).toBeDefined();
+      expect(result.total).toBeDefined();
+    });
+
+    it('parses test output', async () => {
+      const mockExec = vi.fn().mockResolvedValue({
+        stdout: 'Tests: 100 passed | 5 failed',
+        stderr: ''
+      });
+      const result = await runTestSuite({ exec: mockExec });
+      expect(result.passed).toBe(100);
+      expect(result.failed).toBe(5);
+    });
+
+    it('handles test errors', async () => {
+      const mockExec = vi.fn().mockRejectedValue(new Error('Command failed'));
+      const result = await runTestSuite({ exec: mockExec });
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('createHealthApi', () => {
+    it('creates API handler', () => {
+      const api = createHealthApi({ basePath: '/test' });
+      expect(api.get).toBeDefined();
+    });
+
+    it('caches health status briefly', async () => {
+      const mockCheck = vi.fn().mockResolvedValue({ healthy: true });
+      const api = createHealthApi({ checkDeps: mockCheck, cacheMs: 1000 });
+      await api.get();
+      await api.get();
+      expect(mockCheck).toHaveBeenCalledTimes(1);
+    });
+  });
+});