@git.zone/cli 1.16.9 → 1.17.1

package/ts/mod_services/helpers.ts

@@ -0,0 +1,123 @@
+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: number): Promise<boolean> => {
+  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 (): Promise<number> => {
+  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 = (): string => {
+  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: string) => {
+  console.log();
+  logger.log('info', '═══════════════════════════════════════════════════════════════');
+  logger.log('info', `  ${title}`);
+  logger.log('info', '═══════════════════════════════════════════════════════════════');
+  console.log();
+};
+
+/**
+ * Format bytes to human readable string
+ */
+export const formatBytes = (bytes: number): string => {
+  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 (): Promise<string> => {
+  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';
+};

package/ts/mod_services/index.ts

@@ -0,0 +1,219 @@
+import * as plugins from './mod.plugins.js';
+import * as helpers from './helpers.js';
+import { ServiceManager } from './classes.servicemanager.js';
+import { logger } from '../gitzone.logging.js';
+
+export const run = async (argvArg: any) => {
+  const serviceManager = new ServiceManager();
+  await serviceManager.init();
+  
+  const command = argvArg._[1] || 'help';
+  const service = argvArg._[2] || 'all';
+  
+  switch (command) {
+    case 'start':
+      await handleStart(serviceManager, service);
+      break;
+      
+    case 'stop':
+      await handleStop(serviceManager, service);
+      break;
+      
+    case 'restart':
+      await handleRestart(serviceManager, service);
+      break;
+      
+    case 'status':
+      await serviceManager.showStatus();
+      break;
+      
+    case 'config':
+      await serviceManager.showConfig();
+      break;
+      
+    case 'compass':
+      await serviceManager.showCompassConnection();
+      break;
+      
+    case 'logs':
+      const lines = parseInt(argvArg._[3]) || 20;
+      await serviceManager.showLogs(service, lines);
+      break;
+      
+    case 'remove':
+      await handleRemove(serviceManager);
+      break;
+      
+    case 'clean':
+      await handleClean(serviceManager);
+      break;
+      
+    case 'help':
+    default:
+      showHelp();
+      break;
+  }
+};
+
+async function handleStart(serviceManager: ServiceManager, service: string) {
+  helpers.printHeader('Starting Services');
+  
+  switch (service) {
+    case 'mongo':
+    case 'mongodb':
+      await serviceManager.startMongoDB();
+      break;
+      
+    case 'minio':
+    case 's3':
+      await serviceManager.startMinIO();
+      break;
+      
+    case 'all':
+    case '':
+      await serviceManager.startMongoDB();
+      console.log();
+      await serviceManager.startMinIO();
+      break;
+      
+    default:
+      logger.log('error', `Unknown service: ${service}`);
+      logger.log('note', 'Use: mongo, s3, or all');
+      break;
+  }
+}
+
+async function handleStop(serviceManager: ServiceManager, service: string) {
+  helpers.printHeader('Stopping Services');
+  
+  switch (service) {
+    case 'mongo':
+    case 'mongodb':
+      await serviceManager.stopMongoDB();
+      break;
+      
+    case 'minio':
+    case 's3':
+      await serviceManager.stopMinIO();
+      break;
+      
+    case 'all':
+    case '':
+      await serviceManager.stopMongoDB();
+      console.log();
+      await serviceManager.stopMinIO();
+      break;
+      
+    default:
+      logger.log('error', `Unknown service: ${service}`);
+      logger.log('note', 'Use: mongo, s3, or all');
+      break;
+  }
+}
+
+async function handleRestart(serviceManager: ServiceManager, service: string) {
+  helpers.printHeader('Restarting Services');
+  
+  switch (service) {
+    case 'mongo':
+    case 'mongodb':
+      await serviceManager.stopMongoDB();
+      await plugins.smartdelay.delayFor(2000);
+      await serviceManager.startMongoDB();
+      break;
+      
+    case 'minio':
+    case 's3':
+      await serviceManager.stopMinIO();
+      await plugins.smartdelay.delayFor(2000);
+      await serviceManager.startMinIO();
+      break;
+      
+    case 'all':
+    case '':
+      await serviceManager.stopMongoDB();
+      await serviceManager.stopMinIO();
+      await plugins.smartdelay.delayFor(2000);
+      await serviceManager.startMongoDB();
+      console.log();
+      await serviceManager.startMinIO();
+      break;
+      
+    default:
+      logger.log('error', `Unknown service: ${service}`);
+      break;
+  }
+}
+
+async function handleRemove(serviceManager: ServiceManager) {
+  helpers.printHeader('Removing Containers');
+  logger.log('note', '⚠️  This will remove containers but preserve data');
+  
+  const shouldContinue = await plugins.smartinteract.SmartInteract.getCliConfirmation('Continue?', false);
+  
+  if (shouldContinue) {
+    await serviceManager.removeContainers();
+  } else {
+    logger.log('note', 'Cancelled');
+  }
+}
+
+async function handleClean(serviceManager: ServiceManager) {
+  helpers.printHeader('Clean All');
+  logger.log('error', '⚠️  WARNING: This will remove all containers and data!');
+  logger.log('error', 'This action cannot be undone!');
+  
+  const smartinteraction = new plugins.smartinteract.SmartInteract();
+  const confirmAnswer = await smartinteraction.askQuestion({
+    name: 'confirm',
+    type: 'input',
+    message: 'Type "yes" to confirm:',
+    default: 'no'
+  });
+  
+  if (confirmAnswer.value === 'yes') {
+    await serviceManager.removeContainers();
+    console.log();
+    await serviceManager.cleanData();
+    logger.log('ok', 'All cleaned ✓');
+  } else {
+    logger.log('note', 'Cancelled');
+  }
+}
+
+function showHelp() {
+  helpers.printHeader('GitZone Services Manager');
+  
+  logger.log('ok', 'Usage: gitzone services [command] [options]');
+  console.log();
+  
+  logger.log('note', 'Commands:');
+  logger.log('info', '  start [service]   Start services (mongo|s3|all)');
+  logger.log('info', '  stop [service]    Stop services (mongo|s3|all)');
+  logger.log('info', '  restart [service] Restart services (mongo|s3|all)');
+  logger.log('info', '  status            Show service status');
+  logger.log('info', '  config            Show current configuration');
+  logger.log('info', '  compass           Show MongoDB Compass connection string');
+  logger.log('info', '  logs [service]    Show logs (mongo|s3|all) [lines]');
+  logger.log('info', '  remove            Remove all containers');
+  logger.log('info', '  clean             Remove all containers and data ⚠️');
+  logger.log('info', '  help              Show this help message');
+  console.log();
+  
+  logger.log('note', 'Features:');
+  logger.log('info', '  • Auto-creates .nogit/env.json with smart defaults');
+  logger.log('info', '  • Random ports (20000-30000) to avoid conflicts');
+  logger.log('info', '  • Project-specific containers for multi-project support');
+  logger.log('info', '  • Preserves custom configuration values');
+  logger.log('info', '  • MongoDB Compass connection support');
+  console.log();
+  
+  logger.log('note', 'Examples:');
+  logger.log('info', '  gitzone services start          # Start all services');
+  logger.log('info', '  gitzone services start mongo    # Start only MongoDB');
+  logger.log('info', '  gitzone services stop           # Stop all services');
+  logger.log('info', '  gitzone services status         # Check service status');
+  logger.log('info', '  gitzone services config         # Show configuration');
+  logger.log('info', '  gitzone services compass        # Get MongoDB Compass connection');
+  logger.log('info', '  gitzone services logs mongo 50  # Show last 50 lines of MongoDB logs');
+}

package/ts/mod_services/mod.plugins.ts

@@ -0,0 +1,9 @@
+export * from '../plugins.js';
+
+import * as smartshell from '@push.rocks/smartshell';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartinteract from '@push.rocks/smartinteract';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import * as smartdelay from '@push.rocks/smartdelay';
+
+export { smartshell, smartfile, smartinteract, smartnetwork, smartdelay };

package/ts/plugins.ts

@@ -7,6 +7,11 @@ import * as smartcli from '@push.rocks/smartcli';
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartupdate from '@push.rocks/smartupdate';
+import * as smartshell from '@push.rocks/smartshell';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartinteract from '@push.rocks/smartinteract';
+import * as smartdelay from '@push.rocks/smartdelay';
 
 export {
   smartlog,
@@ -18,4 +23,9 @@ export {
   smartpath,
   smartpromise,
   smartupdate,
+  smartshell,
+  smartnetwork,
+  smartfile,
+  smartinteract,
+  smartdelay,
 };