@git.zone/cli 1.16.8 → 1.17.1

package/dist_ts/mod_services/classes.dockercontainer.js

@@ -0,0 +1,194 @@
+import * as plugins from './mod.plugins.js';
+import * as helpers from './helpers.js';
+import { logger } from '../gitzone.logging.js';
+export class DockerContainer {
+    constructor() {
+        this.smartshell = new plugins.smartshell.Smartshell({
+            executor: 'bash',
+        });
+    }
+    /**
+     * Check if Docker is installed and available
+     */
+    async checkDocker() {
+        try {
+            const result = await this.smartshell.exec('docker --version');
+            return result.exitCode === 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get container status
+     */
+    async getStatus(containerName) {
+        try {
+            // Check if running
+            const runningResult = await this.smartshell.exec(`docker ps --format '{{.Names}}' | grep -q "^${containerName}$"`);
+            if (runningResult.exitCode === 0) {
+                return 'running';
+            }
+            // Check if exists but stopped
+            const existsResult = await this.smartshell.exec(`docker ps -a --format '{{.Names}}' | grep -q "^${containerName}$"`);
+            if (existsResult.exitCode === 0) {
+                return 'stopped';
+            }
+            return 'not_exists';
+        }
+        catch (error) {
+            return 'not_exists';
+        }
+    }
+    /**
+     * Start a container
+     */
+    async start(containerName) {
+        try {
+            const result = await this.smartshell.exec(`docker start ${containerName}`);
+            return result.exitCode === 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Stop a container
+     */
+    async stop(containerName) {
+        try {
+            const result = await this.smartshell.exec(`docker stop ${containerName}`);
+            return result.exitCode === 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Remove a container
+     */
+    async remove(containerName, force = false) {
+        try {
+            const forceFlag = force ? '-f' : '';
+            const result = await this.smartshell.exec(`docker rm ${forceFlag} ${containerName}`);
+            return result.exitCode === 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Run a new container
+     */
+    async run(options) {
+        let command = 'docker run -d';
+        // Add name
+        command += ` --name ${options.name}`;
+        // Add ports
+        if (options.ports) {
+            for (const [hostPort, containerPort] of Object.entries(options.ports)) {
+                command += ` -p ${hostPort}:${containerPort}`;
+            }
+        }
+        // Add volumes
+        if (options.volumes) {
+            for (const [hostPath, containerPath] of Object.entries(options.volumes)) {
+                command += ` -v "${hostPath}:${containerPath}"`;
+            }
+        }
+        // Add environment variables
+        if (options.environment) {
+            for (const [key, value] of Object.entries(options.environment)) {
+                command += ` -e ${key}="${value}"`;
+            }
+        }
+        // Add restart policy
+        if (options.restart) {
+            command += ` --restart ${options.restart}`;
+        }
+        // Add image
+        command += ` ${options.image}`;
+        // Add command if provided
+        if (options.command) {
+            command += ` ${options.command}`;
+        }
+        try {
+            const result = await this.smartshell.exec(command);
+            return result.exitCode === 0;
+        }
+        catch (error) {
+            logger.log('error', `Failed to run container: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Execute a command in a running container
+     */
+    async exec(containerName, command) {
+        try {
+            const result = await this.smartshell.exec(`docker exec ${containerName} ${command}`);
+            if (result.exitCode === 0) {
+                return result.stdout;
+            }
+            return '';
+        }
+        catch (error) {
+            return '';
+        }
+    }
+    /**
+     * Get container logs
+     */
+    async logs(containerName, lines) {
+        try {
+            const tailFlag = lines ? `--tail ${lines}` : '';
+            const result = await this.smartshell.exec(`docker logs ${tailFlag} ${containerName}`);
+            return result.stdout;
+        }
+        catch (error) {
+            return `Error getting logs: ${error.message}`;
+        }
+    }
+    /**
+     * Check if a container exists
+     */
+    async exists(containerName) {
+        const status = await this.getStatus(containerName);
+        return status !== 'not_exists';
+    }
+    /**
+     * Check if a container is running
+     */
+    async isRunning(containerName) {
+        const status = await this.getStatus(containerName);
+        return status === 'running';
+    }
+    /**
+     * Wait for a container to be ready
+     */
+    async waitForReady(containerName, maxAttempts = 30) {
+        for (let i = 0; i < maxAttempts; i++) {
+            if (await this.isRunning(containerName)) {
+                return true;
+            }
+            await plugins.smartdelay.delayFor(1000);
+        }
+        return false;
+    }
+    /**
+     * Get container information
+     */
+    async inspect(containerName) {
+        try {
+            const result = await this.smartshell.exec(`docker inspect ${containerName}`);
+            if (result.exitCode === 0) {
+                return JSON.parse(result.stdout);
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,69 @@
+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 declare class ServiceConfiguration {
+    private configPath;
+    private config;
+    constructor();
+    /**
+     * Load or create the configuration
+     */
+    loadOrCreate(): Promise<IServiceConfig>;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): IServiceConfig;
+    /**
+     * Save the configuration to file
+     */
+    saveConfig(): Promise<void>;
+    /**
+     * Ensure .nogit directory exists
+     */
+    private ensureNogitDirectory;
+    /**
+     * Check if configuration file exists
+     */
+    private configExists;
+    /**
+     * Load configuration from file
+     */
+    private loadConfig;
+    /**
+     * Create default configuration
+     */
+    private createDefaultConfig;
+    /**
+     * Update missing fields in existing configuration
+     */
+    private updateMissingFields;
+    /**
+     * Get MongoDB connection string
+     */
+    getMongoConnectionString(useNetworkIp?: boolean): string;
+    /**
+     * Get container names
+     */
+    getContainerNames(): {
+        mongo: string;
+        minio: string;
+    };
+    /**
+     * Get data directories
+     */
+    getDataDirectories(): {
+        mongo: string;
+        minio: string;
+    };
+}

package/dist_ts/mod_services/classes.serviceconfiguration.js

@@ -0,0 +1,195 @@
+import * as plugins from './mod.plugins.js';
+import * as helpers from './helpers.js';
+import { logger } from '../gitzone.logging.js';
+export class ServiceConfiguration {
+    constructor() {
+        this.configPath = plugins.path.join(process.cwd(), '.nogit', 'env.json');
+    }
+    /**
+     * Load or create the configuration
+     */
+    async loadOrCreate() {
+        await this.ensureNogitDirectory();
+        if (await this.configExists()) {
+            await this.loadConfig();
+            await this.updateMissingFields();
+        }
+        else {
+            await this.createDefaultConfig();
+        }
+        return this.config;
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Save the configuration to file
+     */
+    async saveConfig() {
+        await plugins.smartfile.memory.toFs(JSON.stringify(this.config, null, 2), this.configPath);
+    }
+    /**
+     * Ensure .nogit directory exists
+     */
+    async ensureNogitDirectory() {
+        const nogitPath = plugins.path.join(process.cwd(), '.nogit');
+        await plugins.smartfile.fs.ensureDir(nogitPath);
+    }
+    /**
+     * Check if configuration file exists
+     */
+    async configExists() {
+        return plugins.smartfile.fs.fileExists(this.configPath);
+    }
+    /**
+     * Load configuration from file
+     */
+    async loadConfig() {
+        const configContent = await plugins.smartfile.fs.toStringSync(this.configPath);
+        this.config = JSON.parse(configContent);
+    }
+    /**
+     * Create default configuration
+     */
+    async createDefaultConfig() {
+        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
+     */
+    async updateMissingFields() {
+        const projectName = helpers.getProjectName();
+        let updated = false;
+        const fieldsAdded = [];
+        // 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
+     */
+    getMongoConnectionString(useNetworkIp = false) {
+        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
+     */
+    getContainerNames() {
+        return {
+            mongo: `${this.config.PROJECT_NAME}-mongodb`,
+            minio: `${this.config.PROJECT_NAME}-minio`
+        };
+    }
+    /**
+     * Get data directories
+     */
+    getDataDirectories() {
+        return {
+            mongo: plugins.path.join(process.cwd(), '.nogit', 'mongodata'),
+            minio: plugins.path.join(process.cwd(), '.nogit', 'miniodata')
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.serviceconfiguration.js","sourceRoot":"","sources":["../../ts/mod_services/classes.serviceconfiguration.ts"],"names":[],"mappings":"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"}

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>;
+}