tlc-claude-code 1.4.7 → 1.4.9

package/server/lib/vps/compose-orchestrator.js

@@ -0,0 +1,219 @@
+/**
+ * Docker Compose Orchestrator
+ * Docker Compose orchestration for production deployments
+ */
+
+import YAML from 'js-yaml';
+
+/**
+ * Generate a production Docker Compose configuration
+ * @param {Object} options - Compose configuration options
+ * @param {string[]} options.services - List of service names
+ * @param {string} [options.version='3.8'] - Compose file version
+ * @returns {string} Docker Compose YAML configuration
+ */
+export function generateProductionCompose(options = {}) {
+  const { services = [], version = '3.8' } = options;
+
+  const compose = {
+    version,
+    services: {},
+    networks: {
+      default: {
+        driver: 'bridge',
+      },
+    },
+  };
+
+  for (const serviceName of services) {
+    compose.services[serviceName] = {
+      image: `${serviceName}:latest`,
+      restart: 'always',
+      networks: ['default'],
+    };
+  }
+
+  return YAML.dump(compose);
+}
+
+/**
+ * Add health check configuration to a service
+ * @param {Object} options - Health check options
+ * @param {string} options.test - Health check command
+ * @param {string} [options.interval='30s'] - Check interval
+ * @param {string} [options.timeout='10s'] - Check timeout
+ * @param {number} [options.retries=3] - Number of retries
+ * @returns {Object} Service configuration with health check
+ */
+export function addHealthCheck(options = {}) {
+  const {
+    test,
+    interval = '30s',
+    timeout = '10s',
+    retries = 3,
+    startPeriod = '40s',
+  } = options;
+
+  return {
+    healthcheck: {
+      test: `CMD-SHELL ${test}`,
+      interval,
+      timeout,
+      retries,
+      start_period: startPeriod,
+    },
+  };
+}
+
+/**
+ * Set resource limits for a service
+ * @param {Object} options - Resource limit options
+ * @param {string} [options.memory] - Memory limit (e.g., '512M')
+ * @param {string} [options.cpus] - CPU limit (e.g., '0.5')
+ * @returns {Object} Service configuration with resource limits
+ */
+export function setResourceLimits(options = {}) {
+  const { memory, cpus } = options;
+
+  const limits = {};
+  const reservations = {};
+
+  if (memory) {
+    limits.memory = memory;
+    // Reserve half of the limit by default
+    reservations.memory = memory;
+  }
+
+  if (cpus) {
+    limits.cpus = cpus;
+  }
+
+  return {
+    deploy: {
+      resources: {
+        limits,
+        reservations,
+      },
+    },
+  };
+}
+
+/**
+ * Configure logging for a service
+ * @param {Object} options - Logging options
+ * @param {string} [options.driver='json-file'] - Logging driver
+ * @param {string} [options.maxSize='10m'] - Max log file size
+ * @param {string} [options.maxFile='3'] - Max number of log files
+ * @returns {Object} Service configuration with logging
+ */
+export function configureLogging(options = {}) {
+  const {
+    driver = 'json-file',
+    maxSize = '10m',
+    maxFile = '3',
+  } = options;
+
+  return {
+    logging: {
+      driver,
+      options: {
+        'max-size': maxSize,
+        'max-file': maxFile,
+      },
+    },
+  };
+}
+
+/**
+ * Create a Docker Compose orchestrator
+ * @returns {Object} Compose orchestrator with methods
+ */
+export function createComposeOrchestrator() {
+  const services = {};
+  let composeVersion = '3.8';
+
+  return {
+    /**
+     * Add a service to the compose configuration
+     * @param {string} name - Service name
+     * @param {Object} config - Service configuration
+     */
+    addService(name, config = {}) {
+      services[name] = {
+        image: config.image || `${name}:latest`,
+        restart: 'always',
+        ...config,
+      };
+    },
+
+    /**
+     * Set the compose file version
+     * @param {string} version - Compose version
+     */
+    setVersion(version) {
+      composeVersion = version;
+    },
+
+    /**
+     * Generate the complete Docker Compose configuration
+     * @returns {string} Docker Compose YAML
+     */
+    generate() {
+      const compose = {
+        version: composeVersion,
+        services,
+        networks: {
+          default: {
+            driver: 'bridge',
+          },
+        },
+      };
+
+      return YAML.dump(compose);
+    },
+
+    /**
+     * Get all configured services
+     * @returns {Object} Services configuration
+     */
+    getServices() {
+      return { ...services };
+    },
+
+    /**
+     * Add health check to a service
+     * @param {string} serviceName - Service name
+     * @param {Object} healthCheckOptions - Health check options
+     */
+    addHealthCheck(serviceName, healthCheckOptions) {
+      if (services[serviceName]) {
+        const healthConfig = addHealthCheck(healthCheckOptions);
+        services[serviceName] = { ...services[serviceName], ...healthConfig };
+      }
+    },
+
+    /**
+     * Set resource limits for a service
+     * @param {string} serviceName - Service name
+     * @param {Object} resourceOptions - Resource limit options
+     */
+    setResourceLimits(serviceName, resourceOptions) {
+      if (services[serviceName]) {
+        const resourceConfig = setResourceLimits(resourceOptions);
+        services[serviceName] = { ...services[serviceName], ...resourceConfig };
+      }
+    },
+
+    /**
+     * Configure logging for a service
+     * @param {string} serviceName - Service name
+     * @param {Object} loggingOptions - Logging options
+     */
+    configureLogging(serviceName, loggingOptions) {
+      if (services[serviceName]) {
+        const loggingConfig = configureLogging(loggingOptions);
+        services[serviceName] = { ...services[serviceName], ...loggingConfig };
+      }
+    },
+  };
+}

package/server/lib/vps/compose-orchestrator.test.js

@@ -0,0 +1,50 @@
+/**
+ * Docker Compose Orchestrator Tests
+ */
+import { describe, it, expect } from 'vitest';
+import { generateProductionCompose, addHealthCheck, setResourceLimits, configureLogging, createComposeOrchestrator } from './compose-orchestrator.js';
+
+describe('compose-orchestrator', () => {
+  describe('generateProductionCompose', () => {
+    it('generates production compose file', () => {
+      const config = generateProductionCompose({ services: ['app', 'db'] });
+      expect(config).toContain('version:');
+      expect(config).toContain('services:');
+    });
+
+    it('sets restart policy', () => {
+      const config = generateProductionCompose({ services: ['app'] });
+      expect(config).toContain('restart: always');
+    });
+  });
+
+  describe('addHealthCheck', () => {
+    it('adds health check config', () => {
+      const config = addHealthCheck({ test: 'curl -f http://localhost', interval: '30s' });
+      expect(config.healthcheck).toBeDefined();
+      expect(config.healthcheck.test).toContain('curl');
+    });
+  });
+
+  describe('setResourceLimits', () => {
+    it('sets memory limits', () => {
+      const config = setResourceLimits({ memory: '512M', cpus: '0.5' });
+      expect(config.deploy.resources.limits.memory).toBe('512M');
+    });
+  });
+
+  describe('configureLogging', () => {
+    it('configures logging driver', () => {
+      const config = configureLogging({ driver: 'json-file', maxSize: '10m' });
+      expect(config.logging.driver).toBe('json-file');
+    });
+  });
+
+  describe('createComposeOrchestrator', () => {
+    it('creates orchestrator', () => {
+      const orchestrator = createComposeOrchestrator();
+      expect(orchestrator.generate).toBeDefined();
+      expect(orchestrator.addService).toBeDefined();
+    });
+  });
+});

package/server/lib/vps/database-config.js

@@ -0,0 +1,208 @@
+/**
+ * Database Configuration Generator
+ * PostgreSQL and Redis configuration
+ */
+
+/**
+ * Generate PostgreSQL configuration
+ * @param {Object} options - PostgreSQL configuration options
+ * @param {boolean} [options.ssl=false] - Enable SSL
+ * @param {number} [options.maxConnections=100] - Maximum connections
+ * @param {string} [options.sharedBuffers='256MB'] - Shared buffers size
+ * @param {string} [options.workMem='4MB'] - Work memory size
+ * @returns {string} PostgreSQL configuration
+ */
+export function generatePostgresConfig(options = {}) {
+  const {
+    ssl = false,
+    maxConnections = 100,
+    sharedBuffers = '256MB',
+    workMem = '4MB',
+    effectiveCacheSize = '1GB',
+    maintenanceWorkMem = '64MB',
+  } = options;
+
+  const lines = [
+    '# PostgreSQL Configuration',
+    '# Generated by TLC Database Config',
+    '',
+    '# Connection Settings',
+    `max_connections = ${maxConnections}`,
+    '',
+    '# Memory Settings',
+    `shared_buffers = ${sharedBuffers}`,
+    `work_mem = ${workMem}`,
+    `effective_cache_size = ${effectiveCacheSize}`,
+    `maintenance_work_mem = ${maintenanceWorkMem}`,
+    '',
+    '# SSL Configuration',
+    `ssl = ${ssl ? 'on' : 'off'}`,
+  ];
+
+  if (ssl) {
+    lines.push("ssl_cert_file = '/etc/ssl/certs/server.crt'");
+    lines.push("ssl_key_file = '/etc/ssl/private/server.key'");
+  }
+
+  lines.push('');
+  lines.push('# Logging');
+  lines.push("log_destination = 'stderr'");
+  lines.push('logging_collector = on');
+  lines.push("log_directory = 'pg_log'");
+  lines.push("log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'");
+  lines.push('');
+  lines.push('# Performance');
+  lines.push('checkpoint_completion_target = 0.9');
+  lines.push('wal_buffers = 16MB');
+  lines.push('default_statistics_target = 100');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate pg_hba.conf configuration
+ * @param {Object} options - pg_hba configuration options
+ * @param {Array} options.rules - Authentication rules
+ * @returns {string} pg_hba.conf configuration
+ */
+export function generatePgHba(options = {}) {
+  const { rules = [] } = options;
+
+  const lines = [
+    '# PostgreSQL Client Authentication Configuration',
+    '# Generated by TLC Database Config',
+    '',
+    '# TYPE  DATABASE        USER            ADDRESS                 METHOD',
+    '',
+    '# Local connections',
+    'local   all             all                                     peer',
+    'local   all             postgres                                peer',
+    '',
+    '# IPv4 local connections',
+    'host    all             all             127.0.0.1/32            scram-sha-256',
+    '',
+    '# IPv6 local connections',
+    'host    all             all             ::1/128                 scram-sha-256',
+    '',
+    '# Custom rules',
+  ];
+
+  for (const rule of rules) {
+    const { type, database, user, address, method } = rule;
+    lines.push(`${type}\t${database}\t\t${user}\t\t${address}\t\t${method}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate Redis configuration
+ * @param {Object} options - Redis configuration options
+ * @param {string} [options.requirepass] - Password for authentication
+ * @param {boolean} [options.tls=false] - Enable TLS
+ * @param {number} [options.maxmemory] - Maximum memory in bytes
+ * @param {string} [options.maxmemoryPolicy='allkeys-lru'] - Eviction policy
+ * @returns {string} Redis configuration
+ */
+export function generateRedisConfig(options = {}) {
+  const {
+    requirepass,
+    tls = false,
+    maxmemory,
+    maxmemoryPolicy = 'allkeys-lru',
+    port = 6379,
+    bind = '127.0.0.1',
+  } = options;
+
+  const lines = [
+    '# Redis Configuration',
+    '# Generated by TLC Database Config',
+    '',
+    '# Network',
+    `bind ${bind}`,
+    `port ${tls ? 0 : port}`,
+    'protected-mode yes',
+    '',
+  ];
+
+  if (tls) {
+    lines.push('# TLS Configuration');
+    lines.push(`tls-port ${port}`);
+    lines.push('tls-cert-file /etc/redis/redis.crt');
+    lines.push('tls-key-file /etc/redis/redis.key');
+    lines.push('tls-ca-cert-file /etc/redis/ca.crt');
+    lines.push('');
+  }
+
+  if (requirepass) {
+    lines.push('# Security');
+    lines.push(`requirepass ${requirepass}`);
+    lines.push('');
+  }
+
+  lines.push('# Memory Management');
+  if (maxmemory) {
+    lines.push(`maxmemory ${maxmemory}`);
+  }
+  lines.push(`maxmemory-policy ${maxmemoryPolicy}`);
+  lines.push('');
+
+  lines.push('# Persistence');
+  lines.push('appendonly yes');
+  lines.push('appendfsync everysec');
+  lines.push('');
+
+  lines.push('# Logging');
+  lines.push('loglevel notice');
+  lines.push('logfile /var/log/redis/redis-server.log');
+
+  return lines.join('\n');
+}
+
+/**
+ * Create a database configuration manager
+ * @returns {Object} Database config manager with methods
+ */
+export function createDatabaseConfig() {
+  return {
+    /**
+     * Generate PostgreSQL configuration
+     * @param {Object} options - PostgreSQL options
+     * @returns {string} PostgreSQL configuration
+     */
+    generatePostgres(options = {}) {
+      return generatePostgresConfig(options);
+    },
+
+    /**
+     * Generate pg_hba.conf configuration
+     * @param {Object} options - pg_hba options
+     * @returns {string} pg_hba configuration
+     */
+    generatePgHba(options = {}) {
+      return generatePgHba(options);
+    },
+
+    /**
+     * Generate Redis configuration
+     * @param {Object} options - Redis options
+     * @returns {string} Redis configuration
+     */
+    generateRedis(options = {}) {
+      return generateRedisConfig(options);
+    },
+
+    /**
+     * Generate all database configurations
+     * @param {Object} options - Configuration options
+     * @returns {Object} All generated configurations
+     */
+    generateAll(options = {}) {
+      return {
+        postgres: generatePostgresConfig(options.postgres || {}),
+        pgHba: generatePgHba(options.pgHba || {}),
+        redis: generateRedisConfig(options.redis || {}),
+      };
+    },
+  };
+}

package/server/lib/vps/database-config.test.js

@@ -0,0 +1,47 @@
+/**
+ * Database Configuration Tests
+ */
+import { describe, it, expect } from 'vitest';
+import { generatePostgresConfig, generatePgHba, generateRedisConfig, createDatabaseConfig } from './database-config.js';
+
+describe('database-config', () => {
+  describe('generatePostgresConfig', () => {
+    it('enables SSL', () => {
+      const config = generatePostgresConfig({ ssl: true });
+      expect(config).toContain('ssl = on');
+    });
+
+    it('configures connection pooling', () => {
+      const config = generatePostgresConfig({ maxConnections: 100 });
+      expect(config).toContain('max_connections = 100');
+    });
+  });
+
+  describe('generatePgHba', () => {
+    it('configures authentication rules', () => {
+      const config = generatePgHba({ rules: [{ type: 'host', database: 'all', user: 'all', address: '0.0.0.0/0', method: 'md5' }] });
+      expect(config).toContain('host');
+      expect(config).toContain('md5');
+    });
+  });
+
+  describe('generateRedisConfig', () => {
+    it('enables auth', () => {
+      const config = generateRedisConfig({ requirepass: 'secret' });
+      expect(config).toContain('requirepass');
+    });
+
+    it('enables TLS', () => {
+      const config = generateRedisConfig({ tls: true });
+      expect(config).toContain('tls-port');
+    });
+  });
+
+  describe('createDatabaseConfig', () => {
+    it('creates config manager', () => {
+      const manager = createDatabaseConfig();
+      expect(manager.generatePostgres).toBeDefined();
+      expect(manager.generateRedis).toBeDefined();
+    });
+  });
+});