@git.zone/cli 1.16.9 → 1.17.2

package/ts/mod_services/classes.serviceconfiguration.ts

@@ -0,0 +1,246 @@
+import * as plugins from './mod.plugins.js';
+import * as helpers from './helpers.js';
+import { logger } from '../gitzone.logging.js';
+
+export interface IServiceConfig {
+  PROJECT_NAME: string;
+  MONGODB_HOST: string;
+  MONGODB_NAME: string;
+  MONGODB_PORT: string;
+  MONGODB_USER: string;
+  MONGODB_PASS: string;
+  S3_HOST: string;
+  S3_PORT: string;
+  S3_CONSOLE_PORT: string;
+  S3_USER: string;
+  S3_PASS: string;
+  S3_BUCKET: string;
+}
+
+export class ServiceConfiguration {
+  private configPath: string;
+  private config: IServiceConfig;
+  
+  constructor() {
+    this.configPath = plugins.path.join(process.cwd(), '.nogit', 'env.json');
+  }
+  
+  /**
+   * Load or create the configuration
+   */
+  public async loadOrCreate(): Promise<IServiceConfig> {
+    await this.ensureNogitDirectory();
+    
+    if (await this.configExists()) {
+      await this.loadConfig();
+      await this.updateMissingFields();
+    } else {
+      await this.createDefaultConfig();
+    }
+    
+    return this.config;
+  }
+  
+  /**
+   * Get the current configuration
+   */
+  public getConfig(): IServiceConfig {
+    return this.config;
+  }
+  
+  /**
+   * Save the configuration to file
+   */
+  public async saveConfig(): Promise<void> {
+    await plugins.smartfile.memory.toFs(
+      JSON.stringify(this.config, null, 2),
+      this.configPath
+    );
+  }
+  
+  /**
+   * Ensure .nogit directory exists
+   */
+  private async ensureNogitDirectory(): Promise<void> {
+    const nogitPath = plugins.path.join(process.cwd(), '.nogit');
+    await plugins.smartfile.fs.ensureDir(nogitPath);
+  }
+  
+  /**
+   * Check if configuration file exists
+   */
+  private async configExists(): Promise<boolean> {
+    return plugins.smartfile.fs.fileExists(this.configPath);
+  }
+  
+  /**
+   * Load configuration from file
+   */
+  private async loadConfig(): Promise<void> {
+    const configContent = await plugins.smartfile.fs.toStringSync(this.configPath);
+    this.config = JSON.parse(configContent);
+  }
+  
+  /**
+   * Create default configuration
+   */
+  private async createDefaultConfig(): Promise<void> {
+    const projectName = helpers.getProjectName();
+    const mongoPort = await helpers.getRandomAvailablePort();
+    const s3Port = await helpers.getRandomAvailablePort();
+    let s3ConsolePort = s3Port + 1;
+    
+    // Ensure console port is also available
+    while (!(await helpers.isPortAvailable(s3ConsolePort))) {
+      s3ConsolePort++;
+    }
+    
+    this.config = {
+      PROJECT_NAME: projectName,
+      MONGODB_HOST: 'localhost',
+      MONGODB_NAME: projectName,
+      MONGODB_PORT: mongoPort.toString(),
+      MONGODB_USER: 'defaultadmin',
+      MONGODB_PASS: 'defaultpass',
+      S3_HOST: 'localhost',
+      S3_PORT: s3Port.toString(),
+      S3_CONSOLE_PORT: s3ConsolePort.toString(),
+      S3_USER: 'defaultadmin',
+      S3_PASS: 'defaultpass',
+      S3_BUCKET: `${projectName}-documents`
+    };
+    
+    await this.saveConfig();
+    
+    logger.log('ok', '✅ Created .nogit/env.json with project defaults');
+    logger.log('info', `📍 MongoDB port: ${mongoPort}`);
+    logger.log('info', `📍 S3 API port: ${s3Port}`);
+    logger.log('info', `📍 S3 Console port: ${s3ConsolePort}`);
+  }
+  
+  /**
+   * Update missing fields in existing configuration
+   */
+  private async updateMissingFields(): Promise<void> {
+    const projectName = helpers.getProjectName();
+    let updated = false;
+    const fieldsAdded: string[] = [];
+    
+    // Check and add missing fields
+    if (!this.config.PROJECT_NAME) {
+      this.config.PROJECT_NAME = projectName;
+      fieldsAdded.push('PROJECT_NAME');
+      updated = true;
+    }
+    
+    if (!this.config.MONGODB_HOST) {
+      this.config.MONGODB_HOST = 'localhost';
+      fieldsAdded.push('MONGODB_HOST');
+      updated = true;
+    }
+    
+    if (!this.config.MONGODB_NAME) {
+      this.config.MONGODB_NAME = projectName;
+      fieldsAdded.push('MONGODB_NAME');
+      updated = true;
+    }
+    
+    if (!this.config.MONGODB_PORT) {
+      const port = await helpers.getRandomAvailablePort();
+      this.config.MONGODB_PORT = port.toString();
+      fieldsAdded.push(`MONGODB_PORT(${port})`);
+      updated = true;
+    }
+    
+    if (!this.config.MONGODB_USER) {
+      this.config.MONGODB_USER = 'defaultadmin';
+      fieldsAdded.push('MONGODB_USER');
+      updated = true;
+    }
+    
+    if (!this.config.MONGODB_PASS) {
+      this.config.MONGODB_PASS = 'defaultpass';
+      fieldsAdded.push('MONGODB_PASS');
+      updated = true;
+    }
+    
+    if (!this.config.S3_HOST) {
+      this.config.S3_HOST = 'localhost';
+      fieldsAdded.push('S3_HOST');
+      updated = true;
+    }
+    
+    if (!this.config.S3_PORT) {
+      const port = await helpers.getRandomAvailablePort();
+      this.config.S3_PORT = port.toString();
+      fieldsAdded.push(`S3_PORT(${port})`);
+      updated = true;
+    }
+    
+    if (!this.config.S3_CONSOLE_PORT) {
+      const s3Port = parseInt(this.config.S3_PORT);
+      let consolePort = s3Port + 1;
+      
+      while (!(await helpers.isPortAvailable(consolePort))) {
+        consolePort++;
+      }
+      
+      this.config.S3_CONSOLE_PORT = consolePort.toString();
+      fieldsAdded.push(`S3_CONSOLE_PORT(${consolePort})`);
+      updated = true;
+    }
+    
+    if (!this.config.S3_USER) {
+      this.config.S3_USER = 'defaultadmin';
+      fieldsAdded.push('S3_USER');
+      updated = true;
+    }
+    
+    if (!this.config.S3_PASS) {
+      this.config.S3_PASS = 'defaultpass';
+      fieldsAdded.push('S3_PASS');
+      updated = true;
+    }
+    
+    if (!this.config.S3_BUCKET) {
+      this.config.S3_BUCKET = `${projectName}-documents`;
+      fieldsAdded.push('S3_BUCKET');
+      updated = true;
+    }
+    
+    if (updated) {
+      await this.saveConfig();
+      logger.log('ok', `✅ Added missing fields: ${fieldsAdded.join(', ')}`);
+    } else {
+      logger.log('ok', '✅ Configuration complete');
+    }
+  }
+  
+  /**
+   * Get MongoDB connection string
+   */
+  public getMongoConnectionString(useNetworkIp: boolean = false): string {
+    const host = useNetworkIp ? '${networkIp}' : this.config.MONGODB_HOST;
+    return `mongodb://${this.config.MONGODB_USER}:${this.config.MONGODB_PASS}@${host}:${this.config.MONGODB_PORT}/${this.config.MONGODB_NAME}?authSource=admin`;
+  }
+  
+  /**
+   * Get container names
+   */
+  public getContainerNames() {
+    return {
+      mongo: `${this.config.PROJECT_NAME}-mongodb`,
+      minio: `${this.config.PROJECT_NAME}-minio`
+    };
+  }
+  
+  /**
+   * Get data directories
+   */
+  public getDataDirectories() {
+    return {
+      mongo: plugins.path.join(process.cwd(), '.nogit', 'mongodata'),
+      minio: plugins.path.join(process.cwd(), '.nogit', 'miniodata')
+    };
+  }
+}

package/ts/mod_services/classes.servicemanager.ts

@@ -0,0 +1,424 @@
+import * as plugins from './mod.plugins.js';
+import * as helpers from './helpers.js';
+import { ServiceConfiguration } from './classes.serviceconfiguration.js';
+import { DockerContainer } from './classes.dockercontainer.js';
+import { logger } from '../gitzone.logging.js';
+
+export class ServiceManager {
+  private config: ServiceConfiguration;
+  private docker: DockerContainer;
+  
+  constructor() {
+    this.config = new ServiceConfiguration();
+    this.docker = new DockerContainer();
+  }
+  
+  /**
+   * Initialize the service manager
+   */
+  public async init(): Promise<void> {
+    // Check Docker availability
+    if (!(await this.docker.checkDocker())) {
+      logger.log('error', 'Error: Docker is not installed. Please install Docker first.');
+      process.exit(1);
+    }
+    
+    // Load or create configuration
+    await this.config.loadOrCreate();
+    logger.log('info', `📋 Project: ${this.config.getConfig().PROJECT_NAME}`);
+  }
+  
+  /**
+   * Start MongoDB service
+   */
+  public async startMongoDB(): Promise<void> {
+    logger.log('note', '📦 MongoDB:');
+    
+    const config = this.config.getConfig();
+    const containers = this.config.getContainerNames();
+    const directories = this.config.getDataDirectories();
+    
+    // Ensure data directory exists
+    await plugins.smartfile.fs.ensureDir(directories.mongo);
+    
+    const status = await this.docker.getStatus(containers.mongo);
+    
+    switch (status) {
+      case 'running':
+        logger.log('ok', '  Already running ✓');
+        break;
+        
+      case 'stopped':
+        if (await this.docker.start(containers.mongo)) {
+          logger.log('ok', '  Started ✓');
+        } else {
+          logger.log('error', '  Failed to start');
+        }
+        break;
+        
+      case 'not_exists':
+        logger.log('note', '  Creating container...');
+        
+        const success = await this.docker.run({
+          name: containers.mongo,
+          image: 'mongo:7.0',
+          ports: {
+            [`0.0.0.0:${config.MONGODB_PORT}`]: '27017'
+          },
+          volumes: {
+            [directories.mongo]: '/data/db'
+          },
+          environment: {
+            MONGO_INITDB_ROOT_USERNAME: config.MONGODB_USER,
+            MONGO_INITDB_ROOT_PASSWORD: config.MONGODB_PASS,
+            MONGO_INITDB_DATABASE: config.MONGODB_NAME
+          },
+          restart: 'unless-stopped',
+          command: '--bind_ip_all'
+        });
+        
+        if (success) {
+          logger.log('ok', '  Created and started ✓');
+        } else {
+          logger.log('error', '  Failed to create container');
+        }
+        break;
+    }
+    
+    logger.log('info', `  Container: ${containers.mongo}`);
+    logger.log('info', `  Port: ${config.MONGODB_PORT}`);
+    logger.log('info', `  Connection: ${this.config.getMongoConnectionString()}`);
+    
+    // Show Compass connection string
+    const networkIp = await helpers.getLocalNetworkIp();
+    const compassString = `mongodb://${config.MONGODB_USER}:${config.MONGODB_PASS}@${networkIp}:${config.MONGODB_PORT}/${config.MONGODB_NAME}?authSource=admin`;
+    logger.log('ok', `  Compass: ${compassString}`);
+  }
+  
+  /**
+   * Start MinIO service
+   */
+  public async startMinIO(): Promise<void> {
+    logger.log('note', '📦 S3/MinIO:');
+    
+    const config = this.config.getConfig();
+    const containers = this.config.getContainerNames();
+    const directories = this.config.getDataDirectories();
+    
+    // Ensure data directory exists
+    await plugins.smartfile.fs.ensureDir(directories.minio);
+    
+    const status = await this.docker.getStatus(containers.minio);
+    
+    switch (status) {
+      case 'running':
+        logger.log('ok', '  Already running ✓');
+        break;
+        
+      case 'stopped':
+        if (await this.docker.start(containers.minio)) {
+          logger.log('ok', '  Started ✓');
+        } else {
+          logger.log('error', '  Failed to start');
+        }
+        break;
+        
+      case 'not_exists':
+        logger.log('note', '  Creating container...');
+        
+        const success = await this.docker.run({
+          name: containers.minio,
+          image: 'minio/minio',
+          ports: {
+            [config.S3_PORT]: '9000',
+            [config.S3_CONSOLE_PORT]: '9001'
+          },
+          volumes: {
+            [directories.minio]: '/data'
+          },
+          environment: {
+            MINIO_ROOT_USER: config.S3_USER,
+            MINIO_ROOT_PASSWORD: config.S3_PASS
+          },
+          restart: 'unless-stopped',
+          command: 'server /data --console-address ":9001"'
+        });
+        
+        if (success) {
+          logger.log('ok', '  Created and started ✓');
+          
+          // Wait for MinIO to be ready
+          await plugins.smartdelay.delayFor(3000);
+          
+          // Create default bucket
+          await this.docker.exec(
+            containers.minio,
+            `mc alias set local http://localhost:9000 ${config.S3_USER} ${config.S3_PASS}`
+          );
+          
+          await this.docker.exec(
+            containers.minio,
+            `mc mb local/${config.S3_BUCKET}`
+          );
+          
+          logger.log('ok', `  Bucket '${config.S3_BUCKET}' created ✓`);
+        } else {
+          logger.log('error', '  Failed to create container');
+        }
+        break;
+    }
+    
+    logger.log('info', `  Container: ${containers.minio}`);
+    logger.log('info', `  Port: ${config.S3_PORT}`);
+    logger.log('info', `  Bucket: ${config.S3_BUCKET}`);
+    logger.log('info', `  API: http://${config.S3_HOST}:${config.S3_PORT}`);
+    logger.log('info', `  Console: http://${config.S3_HOST}:${config.S3_CONSOLE_PORT} (login: ${config.S3_USER}/***)`);
+  }
+  
+  /**
+   * Stop MongoDB service
+   */
+  public async stopMongoDB(): Promise<void> {
+    logger.log('note', '📦 MongoDB:');
+    
+    const containers = this.config.getContainerNames();
+    const status = await this.docker.getStatus(containers.mongo);
+    
+    if (status === 'running') {
+      if (await this.docker.stop(containers.mongo)) {
+        logger.log('ok', '  Stopped ✓');
+      } else {
+        logger.log('error', '  Failed to stop');
+      }
+    } else {
+      logger.log('note', '  Not running');
+    }
+  }
+  
+  /**
+   * Stop MinIO service
+   */
+  public async stopMinIO(): Promise<void> {
+    logger.log('note', '📦 S3/MinIO:');
+    
+    const containers = this.config.getContainerNames();
+    const status = await this.docker.getStatus(containers.minio);
+    
+    if (status === 'running') {
+      if (await this.docker.stop(containers.minio)) {
+        logger.log('ok', '  Stopped ✓');
+      } else {
+        logger.log('error', '  Failed to stop');
+      }
+    } else {
+      logger.log('note', '  Not running');
+    }
+  }
+  
+  /**
+   * Show service status
+   */
+  public async showStatus(): Promise<void> {
+    helpers.printHeader('Service Status');
+    
+    const config = this.config.getConfig();
+    const containers = this.config.getContainerNames();
+    
+    logger.log('info', `Project: ${config.PROJECT_NAME}`);
+    console.log();
+    
+    // MongoDB status
+    const mongoStatus = await this.docker.getStatus(containers.mongo);
+    switch (mongoStatus) {
+      case 'running':
+        logger.log('ok', '📦 MongoDB: 🟢 Running');
+        logger.log('info', `   ├─ Container: ${containers.mongo}`);
+        logger.log('info', `   ├─ Connection: ${this.config.getMongoConnectionString()}`);
+        
+        // Show Compass connection string
+        const networkIp = await helpers.getLocalNetworkIp();
+        const compassString = `mongodb://${config.MONGODB_USER}:${config.MONGODB_PASS}@${networkIp}:${config.MONGODB_PORT}/${config.MONGODB_NAME}?authSource=admin`;
+        logger.log('ok', `   └─ Compass: ${compassString}`);
+        break;
+      case 'stopped':
+        logger.log('note', '📦 MongoDB: 🟡 Stopped');
+        logger.log('info', `   └─ Container: ${containers.mongo}`);
+        break;
+      case 'not_exists':
+        logger.log('info', '📦 MongoDB: ⚪ Not installed');
+        break;
+    }
+    
+    // MinIO status
+    const minioStatus = await this.docker.getStatus(containers.minio);
+    switch (minioStatus) {
+      case 'running':
+        logger.log('ok', '📦 S3/MinIO: 🟢 Running');
+        logger.log('info', `   ├─ Container: ${containers.minio}`);
+        logger.log('info', `   ├─ API: http://${config.S3_HOST}:${config.S3_PORT}`);
+        logger.log('info', `   ├─ Console: http://${config.S3_HOST}:${config.S3_CONSOLE_PORT}`);
+        logger.log('info', `   └─ Bucket: ${config.S3_BUCKET}`);
+        break;
+      case 'stopped':
+        logger.log('note', '📦 S3/MinIO: 🟡 Stopped');
+        logger.log('info', `   └─ Container: ${containers.minio}`);
+        break;
+      case 'not_exists':
+        logger.log('info', '📦 S3/MinIO: ⚪ Not installed');
+        break;
+    }
+  }
+  
+  /**
+   * Show configuration
+   */
+  public async showConfig(): Promise<void> {
+    helpers.printHeader('Current Configuration');
+    
+    const config = this.config.getConfig();
+    
+    logger.log('info', `Project: ${config.PROJECT_NAME}`);
+    console.log();
+    
+    logger.log('note', 'MongoDB:');
+    logger.log('info', `  Host: ${config.MONGODB_HOST}:${config.MONGODB_PORT}`);
+    logger.log('info', `  Database: ${config.MONGODB_NAME}`);
+    logger.log('info', `  User: ${config.MONGODB_USER}`);
+    logger.log('info', '  Password: ***');
+    logger.log('info', `  Container: ${this.config.getContainerNames().mongo}`);
+    logger.log('info', `  Data: ${this.config.getDataDirectories().mongo}`);
+    logger.log('info', `  Connection: ${this.config.getMongoConnectionString()}`);
+    
+    console.log();
+    logger.log('note', 'S3/MinIO:');
+    logger.log('info', `  Host: ${config.S3_HOST}`);
+    logger.log('info', `  API Port: ${config.S3_PORT}`);
+    logger.log('info', `  Console Port: ${config.S3_CONSOLE_PORT}`);
+    logger.log('info', `  User: ${config.S3_USER}`);
+    logger.log('info', '  Password: ***');
+    logger.log('info', `  Bucket: ${config.S3_BUCKET}`);
+    logger.log('info', `  Container: ${this.config.getContainerNames().minio}`);
+    logger.log('info', `  Data: ${this.config.getDataDirectories().minio}`);
+    logger.log('info', `  API URL: http://${config.S3_HOST}:${config.S3_PORT}`);
+    logger.log('info', `  Console URL: http://${config.S3_HOST}:${config.S3_CONSOLE_PORT}`);
+  }
+  
+  /**
+   * Show MongoDB Compass connection string
+   */
+  public async showCompassConnection(): Promise<void> {
+    helpers.printHeader('MongoDB Compass Connection');
+    
+    const config = this.config.getConfig();
+    const networkIp = await helpers.getLocalNetworkIp();
+    
+    const connectionString = `mongodb://${config.MONGODB_USER}:${config.MONGODB_PASS}@${networkIp}:${config.MONGODB_PORT}/${config.MONGODB_NAME}?authSource=admin`;
+    
+    logger.log('info', 'MongoDB Compass is a GUI tool for MongoDB. To connect:');
+    console.log();
+    logger.log('info', '1. Download MongoDB Compass from:');
+    logger.log('info', '   https://www.mongodb.com/products/compass');
+    console.log();
+    logger.log('info', '2. Open Compass and paste this connection string:');
+    logger.log('ok', `   ${connectionString}`);
+    console.log();
+    logger.log('note', 'Connection Details:');
+    logger.log('info', `  Network IP: ${networkIp}`);
+    logger.log('info', `  Port: ${config.MONGODB_PORT}`);
+    logger.log('info', `  Database: ${config.MONGODB_NAME}`);
+    logger.log('info', `  Username: ${config.MONGODB_USER}`);
+    logger.log('info', `  Auth Source: admin`);
+  }
+  
+  /**
+   * Show logs for a service
+   */
+  public async showLogs(service: string, lines: number = 20): Promise<void> {
+    const containers = this.config.getContainerNames();
+    
+    switch (service) {
+      case 'mongo':
+      case 'mongodb':
+        if (await this.docker.isRunning(containers.mongo)) {
+          helpers.printHeader(`MongoDB Logs (last ${lines} lines)`);
+          const logs = await this.docker.logs(containers.mongo, lines);
+          console.log(logs);
+        } else {
+          logger.log('note', 'MongoDB container is not running');
+        }
+        break;
+        
+      case 'minio':
+      case 's3':
+        if (await this.docker.isRunning(containers.minio)) {
+          helpers.printHeader(`S3/MinIO Logs (last ${lines} lines)`);
+          const logs = await this.docker.logs(containers.minio, lines);
+          console.log(logs);
+        } else {
+          logger.log('note', 'S3/MinIO container is not running');
+        }
+        break;
+        
+      case 'all':
+      case '':
+        await this.showLogs('mongo', lines);
+        console.log();
+        await this.showLogs('minio', lines);
+        break;
+        
+      default:
+        logger.log('note', 'Usage: gitzone services logs [mongo|s3|all] [lines]');
+        break;
+    }
+  }
+  
+  /**
+   * Remove containers
+   */
+  public async removeContainers(): Promise<void> {
+    const containers = this.config.getContainerNames();
+    let removed = false;
+    
+    if (await this.docker.exists(containers.mongo)) {
+      if (await this.docker.remove(containers.mongo, true)) {
+        logger.log('ok', '  MongoDB container removed ✓');
+        removed = true;
+      }
+    }
+    
+    if (await this.docker.exists(containers.minio)) {
+      if (await this.docker.remove(containers.minio, true)) {
+        logger.log('ok', '  S3/MinIO container removed ✓');
+        removed = true;
+      }
+    }
+    
+    if (!removed) {
+      logger.log('note', '  No containers to remove');
+    }
+  }
+  
+  /**
+   * Clean data directories
+   */
+  public async cleanData(): Promise<void> {
+    const directories = this.config.getDataDirectories();
+    let cleaned = false;
+    
+    if (await plugins.smartfile.fs.fileExists(directories.mongo)) {
+      await plugins.smartfile.fs.remove(directories.mongo);
+      logger.log('ok', '  MongoDB data removed ✓');
+      cleaned = true;
+    }
+    
+    if (await plugins.smartfile.fs.fileExists(directories.minio)) {
+      await plugins.smartfile.fs.remove(directories.minio);
+      logger.log('ok', '  S3/MinIO data removed ✓');
+      cleaned = true;
+    }
+    
+    if (!cleaned) {
+      logger.log('note', '  No data to clean');
+    }
+  }
+}