@git.zone/cli 1.16.9 → 1.17.1

package/dist_ts/mod_services/classes.servicemanager.d.ts

@@ -0,0 +1,49 @@
+export declare class ServiceManager {
+    private config;
+    private docker;
+    constructor();
+    /**
+     * Initialize the service manager
+     */
+    init(): Promise<void>;
+    /**
+     * Start MongoDB service
+     */
+    startMongoDB(): Promise<void>;
+    /**
+     * Start MinIO service
+     */
+    startMinIO(): Promise<void>;
+    /**
+     * Stop MongoDB service
+     */
+    stopMongoDB(): Promise<void>;
+    /**
+     * Stop MinIO service
+     */
+    stopMinIO(): Promise<void>;
+    /**
+     * Show service status
+     */
+    showStatus(): Promise<void>;
+    /**
+     * Show configuration
+     */
+    showConfig(): Promise<void>;
+    /**
+     * Show MongoDB Compass connection string
+     */
+    showCompassConnection(): Promise<void>;
+    /**
+     * Show logs for a service
+     */
+    showLogs(service: string, lines?: number): Promise<void>;
+    /**
+     * Remove containers
+     */
+    removeContainers(): Promise<void>;
+    /**
+     * Clean data directories
+     */
+    cleanData(): Promise<void>;
+}

package/dist_ts/mod_services/classes.servicemanager.js

@@ -0,0 +1,363 @@
+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 {
+    constructor() {
+        this.config = new ServiceConfiguration();
+        this.docker = new DockerContainer();
+    }
+    /**
+     * Initialize the service manager
+     */
+    async init() {
+        // 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
+     */
+    async startMongoDB() {
+        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'
+                });
+                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
+     */
+    async startMinIO() {
+        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
+     */
+    async stopMongoDB() {
+        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
+     */
+    async stopMinIO() {
+        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
+     */
+    async showStatus() {
+        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
+     */
+    async showConfig() {
+        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
+     */
+    async showCompassConnection() {
+        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
+     */
+    async showLogs(service, lines = 20) {
+        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
+     */
+    async removeContainers() {
+        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
+     */
+    async cleanData() {
+        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');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.servicemanager.js","sourceRoot":"","sources":["../../ts/mod_services/classes.servicemanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_services/helpers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Check if a port is available
+ */
+export declare const isPortAvailable: (port: number) => Promise<boolean>;
+/**
+ * Get a random available port between 20000 and 30000
+ */
+export declare const getRandomAvailablePort: () => Promise<number>;
+/**
+ * Get the project name from package.json or directory
+ */
+export declare const getProjectName: () => string;
+/**
+ * Print a header with decorative lines
+ */
+export declare const printHeader: (title: string) => void;
+/**
+ * Format bytes to human readable string
+ */
+export declare const formatBytes: (bytes: number) => string;
+/**
+ * Get the local network IP address
+ */
+export declare const getLocalNetworkIp: () => Promise<string>;

package/dist_ts/mod_services/helpers.js

@@ -0,0 +1,108 @@
+import * as plugins from './mod.plugins.js';
+import * as net from 'net';
+import { logger } from '../gitzone.logging.js';
+/**
+ * Check if a port is available
+ */
+export const isPortAvailable = async (port) => {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => {
+            resolve(false);
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port, '0.0.0.0');
+    });
+};
+/**
+ * Get a random available port between 20000 and 30000
+ */
+export const getRandomAvailablePort = async () => {
+    const maxAttempts = 100;
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = Math.floor(Math.random() * 10001) + 20000;
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    // Fallback: let the system assign a port
+    return 0;
+};
+/**
+ * Get the project name from package.json or directory
+ */
+export const getProjectName = () => {
+    try {
+        const packageJsonPath = plugins.path.join(process.cwd(), 'package.json');
+        if (plugins.smartfile.fs.fileExistsSync(packageJsonPath)) {
+            const packageJson = plugins.smartfile.fs.toObjectSync(packageJsonPath);
+            if (packageJson.name) {
+                // Sanitize: @fin.cx/skr → fin-cx-skr
+                return packageJson.name.replace(/@/g, '').replace(/[\/\.]/g, '-');
+            }
+        }
+    }
+    catch (error) {
+        // Ignore errors and fall back to directory name
+    }
+    return plugins.path.basename(process.cwd());
+};
+/**
+ * Print a header with decorative lines
+ */
+export const printHeader = (title) => {
+    console.log();
+    logger.log('info', '═══════════════════════════════════════════════════════════════');
+    logger.log('info', `  ${title}`);
+    logger.log('info', '═══════════════════════════════════════════════════════════════');
+    console.log();
+};
+/**
+ * Format bytes to human readable string
+ */
+export const formatBytes = (bytes) => {
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+    return `${size.toFixed(2)} ${units[unitIndex]}`;
+};
+/**
+ * Get the local network IP address
+ */
+export const getLocalNetworkIp = async () => {
+    const smartnetworkInstance = new plugins.smartnetwork.SmartNetwork();
+    const gateways = await smartnetworkInstance.getGateways();
+    // Find the best local IP from network interfaces
+    for (const interfaceName of Object.keys(gateways)) {
+        const interfaces = gateways[interfaceName];
+        for (const iface of interfaces) {
+            // Skip loopback and internal interfaces
+            if (!iface.internal && iface.family === 'IPv4') {
+                const address = iface.address;
+                // Prefer LAN IPs
+                if (address.startsWith('192.168.') || address.startsWith('10.') || address.startsWith('172.')) {
+                    return address;
+                }
+            }
+        }
+    }
+    // Fallback: try to get any non-internal IPv4
+    for (const interfaceName of Object.keys(gateways)) {
+        const interfaces = gateways[interfaceName];
+        for (const iface of interfaces) {
+            if (!iface.internal && iface.family === 'IPv4') {
+                return iface.address;
+            }
+        }
+    }
+    // Last resort: localhost
+    return 'localhost';
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_services/index.d.ts

@@ -0,0 +1 @@
+export declare const run: (argvArg: any) => Promise<void>;