@fenwave/agent 1.1.0

package/cli-commands.js

@@ -0,0 +1,1185 @@
+import os from 'os';
+import Table from 'cli-table3';
+import net from 'net';
+import chalk from 'chalk';
+import ora from 'ora';
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import containerManager from './containerManager.js';
+import registryStore from './store/registryStore.js';
+import agentStore from './store/agentStore.js';
+import { docker, formatContainer } from './docker-actions/containers.js';
+import { loadSession, isSessionValid, clearSession } from './auth.js';
+import packageJson from './package.json' with { type: 'json' };
+import {
+  formatSize,
+  formatCreatedTime,
+  formatUptime,
+} from './helper-functions.js';
+import { ensureEnvironmentFiles } from './utils/envSetup.js';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const WS_PORT = Number(process.env.WS_PORT) || 3001;
+
+// ES module helpers
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Check if agent is actually running by trying to connect to its port
+ */
+function checkAgentRunning(port = WS_PORT) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+
+    socket.setTimeout(1000);
+
+    socket.on('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+
+    socket.on('timeout', () => {
+      socket.destroy();
+      resolve(false);
+    });
+
+    socket.on('error', () => {
+      resolve(false);
+    });
+
+    socket.connect(port, 'localhost');
+  });
+}
+
+function setupCLICommands(program, startServerFunction) {
+  // Login (create session)
+  program
+    .command('login')
+    .description('authenticate Fenwave agent to backstage')
+    .option('-p, --port <port>', 'Port to listen on', String(WS_PORT))
+    .action(async (options) => {
+      console.log(chalk.blue('🚀 Initializing Fenwave Agent...'));
+      
+      // Show environment file status during login
+      ensureEnvironmentFiles(__dirname, true);
+      
+      try {
+        const result = await startServerFunction(parseInt(options.port));
+
+        // Store server instances for graceful shutdown in global scope
+        global.serverInstances = result;
+      } catch (error) {
+        console.error(chalk.red('❌ Failed to start Fenwave Agent:'), error.message);
+        if (
+          error.message.includes('ECONNREFUSED') ||
+          error.message.includes('fetch') ||
+          error.message.includes('ENOTFOUND')
+        ) {
+          // Check if we have a stored session
+          const existingSession = loadSession();
+          if (existingSession && isSessionValid(existingSession)) {
+            // We have a valid session but Backstage is offline - this should be fine for independent operation
+            console.error(
+              chalk.yellow('⚠️ Warning: Cannot connect to Backstage backend')
+            );
+            // Don't exit, let it continue with the cached session
+          } else {
+            // No valid session and Backstage offline - authentication required but impossible
+            console.error(chalk.red('❌ Cannot connect to Backstage backend'));
+            console.log(
+              chalk.yellow(
+                '💡 Please ensure Backstage is running and you are properly authenticated, then try again.'
+              )
+            );
+            process.exit(1);
+          }
+        } else {
+          process.exit(1);
+        }
+      }
+    });
+
+  // Logout (clear session)
+  program
+    .command('logout')
+    .description('clear stored session and logout')
+    .action(() => {
+      const session = loadSession();
+      if (session) {
+        clearSession();
+        console.log(chalk.green('✅ Agent disconnected successfully'));
+        process.exit(0);
+      } else {
+        console.log(chalk.yellow('ℹ️ No active session found'));
+        process.exit(0);
+      }
+    });
+
+  // Check Auth session and device registration status
+  program
+    .command('status')
+    .description('check current session status and device registration')
+    .action(async () => {
+      try {
+        const { loadDeviceCredential, isDeviceRegistered } = await import('./store/deviceCredentialStore.js');
+        const { hasNpmToken } = await import('./store/npmTokenStore.js');
+
+        console.log(chalk.bold('\n📊 Fenwave Agent Status\n'));
+
+        // Session status
+        const session = loadSession();
+        if (session && isSessionValid(session)) {
+          console.log(chalk.green('✅ Session: Active'));
+          console.log(chalk.gray(`   User: ${session.userEntityRef || 'N/A'}`));
+          console.log(chalk.gray(`   Expires: ${new Date(session.expiresAt).toLocaleString()}`));
+        } else {
+          console.log(chalk.yellow('⚠️  Session: Inactive'));
+          console.log(chalk.gray('   Run "fenwave login" to authenticate'));
+        }
+
+        console.log('');
+
+        // Device registration status
+        if (isDeviceRegistered()) {
+          const deviceCred = loadDeviceCredential();
+          console.log(chalk.green('✅ Device: Registered'));
+          console.log(chalk.gray(`   Device ID: ${deviceCred.deviceId}`));
+          console.log(chalk.gray(`   Device Name: ${deviceCred.deviceName}`));
+          console.log(chalk.gray(`   Platform: ${deviceCred.platform}`));
+          
+          let deviceUser;
+          if (deviceCred.userEntityRef && deviceCred.userEntityRef !== 'unknown') {
+            deviceUser = deviceCred.userEntityRef;
+          } else {
+            deviceUser = session?.userEntityRef || 'N/A';
+          }
+
+          console.log(chalk.gray(`   User: ${deviceUser}`));
+          console.log(chalk.gray(`   Registered: ${new Date(deviceCred.registeredAt).toLocaleString()}`));
+        } else {
+          console.log(chalk.yellow('⚠️  Device: Not Registered'));
+          console.log(chalk.gray('   Run "fenwave init" or "fenwave register" to register your device'));
+        }
+
+        console.log('');
+
+        // NPM token status
+        if (hasNpmToken()) {
+          console.log(chalk.green('✅ NPM Token: Configured'));
+        } else {
+          console.log(chalk.yellow('⚠️  NPM Token: Not Configured'));
+        }
+
+        console.log('');
+
+        // Agent running status
+        const isRunning = await checkAgentRunning(WS_PORT);
+        if (isRunning) {
+          console.log(chalk.green(`✅ Agent: Running (port ${WS_PORT})`));
+        } else {
+          console.log(chalk.yellow('⚠️  Agent: Not Running'));
+          console.log(chalk.gray('   Run "fenwave login" to start the agent'));
+        }
+
+        console.log('');
+        process.exit(0);
+      } catch (error) {
+        console.error(chalk.red('❌ Error checking status:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Interactive Setup Wizard
+  program
+    .command('init')
+    .description('interactive setup wizard for Fenwave agent')
+    .option('-t, --token <token>', 'Registration token from Backstage')
+    .option('--skip-prerequisites', 'Skip prerequisites check')
+    .option('--backend-url <url>', 'Backstage backend URL', 'http://localhost:7007')
+    .option('--frontend-url <url>', 'Backstage frontend URL', 'http://localhost:3000')
+    .option('--aws-region <region>', 'AWS region for ECR', 'eu-west-1')
+    .option('--aws-account-id <id>', 'AWS account ID for ECR')
+    .action(async (options) => {
+      try {
+        const { runSetupWizard } = await import('./setup/setupWizard.js');
+        await runSetupWizard({
+          token: options.token,
+          skipPrerequisites: options.skipPrerequisites,
+          backendUrl: options.backendUrl,
+          frontendUrl: options.frontendUrl,
+          awsRegion: options.awsRegion,
+          awsAccountId: options.awsAccountId,
+        });
+      } catch (error) {
+        console.error(chalk.red('Setup failed:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Register Device
+  program
+    .command('register')
+    .description('register device with Backstage')
+    .option('-t, --token <token>', 'Registration token from Backstage')
+    .option('--backend-url <url>', 'Backstage backend URL', 'http://localhost:7007')
+    .action(async (options) => {
+      const spinner = ora('Registering device...').start();
+
+      try {
+        const { getDeviceMetadata } = await import('./utils/deviceInfo.js');
+        const { saveDeviceCredential, isDeviceRegistered } = await import('./store/deviceCredentialStore.js');
+        const { saveNpmToken } = await import('./store/npmTokenStore.js');
+
+        // Check if already registered
+        if (isDeviceRegistered()) {
+          spinner.warn('Device is already registered');
+          const inquirer = (await import('inquirer')).default;
+          const { confirmed } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirmed',
+              message: 'Re-register (this will replace existing credentials)?',
+              default: false,
+            },
+          ]);
+
+          if (!confirmed) {
+            console.log(chalk.yellow('Registration cancelled'));
+            process.exit(0);
+          }
+        }
+
+        // Get registration token
+        let token = options.token;
+        if (!token) {
+          const inquirer = (await import('inquirer')).default;
+          const answers = await inquirer.prompt([
+            {
+              type: 'password',
+              name: 'token',
+              message: 'Enter registration token:',
+              mask: '*',
+              validate: (input) => input && input.length >= 32 ? true : 'Invalid token format',
+            },
+          ]);
+          token = answers.token;
+        }
+
+        // Collect device info
+        const deviceMetadata = await getDeviceMetadata();
+
+        // Register with backend
+        const response = await axios.post(
+          `${options.backendUrl}/api/agent-cli/register`,
+          {
+            installToken: token,
+            deviceInfo: {
+              deviceName: deviceMetadata.deviceName,
+              platform: deviceMetadata.platform,
+              osVersion: deviceMetadata.osVersion,
+              agentVersion: deviceMetadata.agentVersion,
+              metadata: deviceMetadata.metadata,
+            },
+          },
+          { timeout: 10000 }
+        );
+
+        // Save credentials
+        saveDeviceCredential({
+          deviceId: response.data.deviceId,
+          deviceCredential: response.data.deviceCredential,
+          userEntityRef: response.data.userEntityRef || 'unknown',
+          deviceName: deviceMetadata.deviceName,
+          platform: deviceMetadata.platform,
+          agentVersion: deviceMetadata.agentVersion,
+        });
+
+        // Save NPM token if provided
+        if (response.data.npmToken) {
+          saveNpmToken(response.data.npmToken);
+        }
+
+        spinner.succeed('Device registered successfully');
+        console.log(chalk.green('\n✅ Registration Complete'));
+        console.log(chalk.gray(`   Device ID: ${response.data.deviceId}`));
+        console.log(chalk.gray(`   Device Name: ${deviceMetadata.deviceName}\n`));
+
+      } catch (error) {
+        spinner.fail('Registration failed');
+        if (error.response?.status === 401) {
+          console.error(chalk.red('❌ Invalid or expired registration token'));
+          console.log(chalk.yellow('💡 Get a new token from Backstage at /agent-installer'));
+        } else if (error.response?.status === 429) {
+          console.error(chalk.red('❌ Rate limit exceeded'));
+          console.log(chalk.yellow('💡 Too many attempts. Please wait and try again.'));
+        } else {
+          console.error(chalk.red('❌ Error:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+
+  // Rotate Device Credentials
+  program
+    .command('rotate-credentials')
+    .description('rotate device credentials')
+    .option('--backend-url <url>', 'Backstage backend URL', 'http://localhost:7007')
+    .action(async (options) => {
+      const spinner = ora('Rotating credentials...').start();
+
+      try {
+        const { loadDeviceCredential, saveDeviceCredential, isDeviceRegistered } = await import('./store/deviceCredentialStore.js');
+
+        if (!isDeviceRegistered()) {
+          spinner.fail('Device is not registered');
+          console.log(chalk.yellow('💡 Run "fenwave register" first'));
+          process.exit(1);
+        }
+
+        const deviceCred = loadDeviceCredential();
+
+        // Rotate credentials with backend
+        const response = await axios.post(
+          `${options.backendUrl}/api/agent-cli/rotate-credentials`,
+          {
+            deviceId: deviceCred.deviceId,
+            deviceCredential: deviceCred.deviceCredential,
+          },
+          { timeout: 10000 }
+        );
+
+        // Update stored credentials
+        saveDeviceCredential({
+          ...deviceCred,
+          deviceCredential: response.data.deviceCredential,
+        });
+
+        spinner.succeed('Credentials rotated successfully');
+        console.log(chalk.green('✅ New credentials saved securely\n'));
+
+      } catch (error) {
+        spinner.fail('Credential rotation failed');
+        if (error.response?.status === 401) {
+          console.error(chalk.red('❌ Invalid current credentials'));
+          console.log(chalk.yellow('💡 Your device may have been revoked. Run "fenwave register" to re-register.'));
+        } else if (error.response?.status === 429) {
+          console.error(chalk.red('❌ Rate limit exceeded'));
+          console.log(chalk.yellow('💡 Too many rotation attempts. Please wait and try again.'));
+        } else {
+          console.error(chalk.red('❌ Error:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+
+  // Uninstall Agent
+  program
+    .command('uninstall')
+    .description('uninstall Fenwave agent and clean up')
+    .option('--keep-data', 'Keep configuration and data files')
+    .action(async (options) => {
+      try {
+        const inquirer = (await import('inquirer')).default;
+
+        // Confirmation
+        const { confirmed } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirmed',
+            message: 'Are you sure you want to uninstall the Fenwave agent?',
+            default: false,
+          },
+        ]);
+
+        if (!confirmed) {
+          console.log(chalk.yellow('Uninstall cancelled'));
+          process.exit(0);
+        }
+
+        const spinner = ora('Uninstalling Fenwave agent...').start();
+
+        // Stop agent if running
+        try {
+          const isRunning = await checkAgentRunning(WS_PORT);
+          if (isRunning) {
+            spinner.text = 'Stopping agent...';
+            // Agent will be stopped when process exits
+          }
+        } catch (error) {
+          // Ignore
+        }
+
+        // Clear credentials unless --keep-data
+        if (!options.keepData) {
+          spinner.text = 'Clearing credentials...';
+          const { clearDeviceCredential } = await import('./store/deviceCredentialStore.js');
+          const { clearNpmToken } = await import('./store/npmTokenStore.js');
+          const { clearSetupState } = await import('./store/setupState.js');
+
+          clearDeviceCredential();
+          clearNpmToken();
+          clearSetupState();
+          clearSession();
+          const fwDir = path.join(os.homedir(), '.fenwave');
+
+          if (fs.existsSync(fwDir)) {
+            fs.rmSync(fwDir, { recursive: true, force: true });
+          }
+        }
+
+        spinner.succeed('Agent uninstalled');
+        console.log(chalk.green('\n✅ Fenwave agent uninstalled successfully\n'));
+
+        if (!options.keepData) {
+          console.log(chalk.gray('All configuration and data files have been removed.'));
+        } else {
+          console.log(chalk.gray('Configuration and data files have been preserved.'));
+        }
+
+        console.log(chalk.gray('\nTo reinstall: npm install -g @fenwave/dev-agent\n'));
+
+        process.exit(0);
+      } catch (error) {
+        console.error(chalk.red('❌ Uninstall error:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Container commands
+  program
+    .command('containers')
+    .alias('ps')
+    .description('list containers')
+    .option('-a, --all', 'Show all containers (default shows just running)')
+    .action(async (options) => {
+      const spinner = ora('Fetching containers...').start();
+
+      try {
+        const containers = await docker.listContainers({ all: options.all });
+
+        if (containers.length === 0) {
+          spinner.succeed('No containers found');
+          return;
+        }
+
+        const containerPromises = containers.map((container) =>
+          formatContainer(docker.getContainer(container.Id))
+        );
+
+        const formattedContainers = await Promise.all(containerPromises);
+
+        const containerText =
+          containers.length === 1 ? 'container' : 'containers';
+        spinner.succeed(`Found ${containers.length} ${containerText}`);
+
+        // Create a table for display
+        const table = new Table({
+          head: [
+            chalk.blue('ID'),
+            chalk.blue('Name'),
+            chalk.blue('Image'),
+            chalk.blue('Status'),
+            chalk.blue('Ports'),
+            chalk.blue('CPU %'),
+            chalk.blue('MEM %'),
+          ],
+          colWidths: [15, 25, 30, 10, 20, 10, 10],
+        });
+
+        formattedContainers.forEach((container) => {
+          const status =
+            container.status === 'running'
+              ? chalk.green(container.status)
+              : chalk.red(container.status);
+
+          table.push([
+            container.id.substring(0, 12),
+            container.name,
+            container.image,
+            status,
+            container.ports.join(', '),
+            `${container.cpu}%`,
+            `${container.memory}%`,
+          ]);
+        });
+
+        console.log(table.toString());
+        process.exit(0);
+      } catch (error) {
+        spinner.fail(`Failed to fetch containers: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Start container(s) - supports multiple containers
+  program
+    .command('start <containerId(s)...>')
+    .description('start one or more containers')
+    .action(async (containerIds) => {
+      const spinner = ora(`Starting ${containerIds.length} ${containerIds.length === 1 ? 'container' : 'containers'}...`).start();
+
+      try {
+        const results = [];
+        for (const containerId of containerIds) {
+          try {
+            const container = docker.getContainer(containerId);
+            await container.start();
+            results.push({ id: containerId, success: true });
+          } catch (error) {
+            results.push({ id: containerId, success: false, error: error.message });
+          }
+        }
+
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+
+        if (failed.length === 0) {
+          spinner.succeed(`Successfully started ${succeeded.length} ${succeeded.length === 1 ? 'container' : 'containers'}`);
+        } else if (succeeded.length === 0) {
+          spinner.fail(`Failed to start all containers`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        } else {
+          spinner.warn(`Started ${succeeded.length}/${containerIds.length} ${succeeded.length === 1 ? 'container' : 'containers'}`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        }
+        process.exit(failed.length > 0 ? 1 : 0);
+      } catch (error) {
+        spinner.fail(`Failed to start containers: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Stop container(s) - supports multiple containers
+  program
+    .command('stop <containerId(s)...>')
+    .description('stop one or more containers')
+    .action(async (containerIds) => {
+      const spinner = ora(`Stopping ${containerIds.length} ${containerIds.length === 1 ? 'container' : 'containers'}...`).start();
+
+      try {
+        const results = [];
+        for (const containerId of containerIds) {
+          try {
+            const container = docker.getContainer(containerId);
+            await container.stop();
+            results.push({ id: containerId, success: true });
+          } catch (error) {
+            results.push({ id: containerId, success: false, error: error.message });
+          }
+        }
+
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+
+        if (failed.length === 0) {
+          spinner.succeed(`Successfully stopped ${succeeded.length} ${succeeded.length === 1 ? 'container' : 'containers'}`);
+        } else if (succeeded.length === 0) {
+          spinner.fail(`Failed to stop all containers`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        } else {
+          spinner.warn(`Stopped ${succeeded.length}/${containerIds.length} ${succeeded.length === 1 ? 'container' : 'containers'}`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        }
+        process.exit(failed.length > 0 ? 1 : 0);
+      } catch (error) {
+        spinner.fail(`Failed to stop containers: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Restart container(s) - supports multiple containers
+  program
+    .command('restart <containerId(s)...>')
+    .description('restart one or more containers')
+    .action(async (containerIds) => {
+      const spinner = ora(`Restarting ${containerIds.length} ${containerIds.length === 1 ? 'container' : 'containers'}...`).start();
+
+      try {
+        const results = [];
+        for (const containerId of containerIds) {
+          try {
+            const container = docker.getContainer(containerId);
+            await container.restart();
+            results.push({ id: containerId, success: true });
+          } catch (error) {
+            results.push({ id: containerId, success: false, error: error.message });
+          }
+        }
+
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+
+        if (failed.length === 0) {
+          spinner.succeed(`Successfully restarted ${succeeded.length} ${succeeded.length === 1 ? 'container' : 'containers'}`);
+        } else if (succeeded.length === 0) {
+          spinner.fail(`Failed to restart all containers`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        } else {
+          spinner.warn(`Restarted ${succeeded.length}/${containerIds.length} ${succeeded.length === 1 ? 'container' : 'containers'}`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        }
+        process.exit(failed.length > 0 ? 1 : 0);
+      } catch (error) {
+        spinner.fail(`Failed to restart containers: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Remove container(s) - supports multiple containers
+  program
+    .command('rm <containerId(s)...>')
+    .description('remove one or more containers')
+    .option('-f, --force', 'Force remove the container(s)')
+    .action(async (containerIds, options) => {
+      const spinner = ora(`Removing ${containerIds.length} ${containerIds.length === 1 ? 'container' : 'containers'}...`).start();
+
+      try {
+        const results = [];
+        for (const containerId of containerIds) {
+          try {
+            const container = docker.getContainer(containerId);
+            await container.remove({ force: options.force });
+            results.push({ id: containerId, success: true });
+          } catch (error) {
+            results.push({ id: containerId, success: false, error: error.message });
+          }
+        }
+
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+
+        if (failed.length === 0) {
+          spinner.succeed(`Successfully removed ${succeeded.length} ${succeeded.length === 1 ? 'container' : 'containers'}`);
+        } else if (succeeded.length === 0) {
+          spinner.fail(`Failed to remove all containers`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        } else {
+          spinner.warn(`Removed ${succeeded.length}/${containerIds.length} ${succeeded.length === 1 ? 'container' : 'containers'}`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        }
+        process.exit(failed.length > 0 ? 1 : 0);
+      } catch (error) {
+        spinner.fail(`Failed to remove containers: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Image commands
+  program
+    .command('images')
+    .description('list images')
+    .action(async () => {
+      const spinner = ora('Fetching images...').start();
+
+      try {
+        const images = await docker.listImages();
+
+        if (images.length === 0) {
+          spinner.succeed('No images found');
+          return;
+        }
+
+        spinner.succeed(`Found ${images.length} ${images.length === 1 ? 'image' : 'images'}`);
+
+        // Create a table for display
+        const table = new Table({
+          head: [
+            chalk.blue('ID'),
+            chalk.blue('Repository'),
+            chalk.blue('Tag'),
+            chalk.blue('Size'),
+            chalk.blue('Created'),
+          ],
+          colWidths: [15, 30, 15, 15, 15],
+        });
+
+        images.forEach((image) => {
+          // Extract repository and tag
+          let name = '<none>';
+          let tag = '<none>';
+
+          if (image.RepoTags && image.RepoTags.length > 0) {
+            const [repoTag] = image.RepoTags;
+            const parts = repoTag.split(':');
+            name = parts[0];
+            tag = parts.length > 1 ? parts[1] : 'latest';
+          }
+
+          table.push([
+            image.Id.substring(7, 19),
+            name,
+            tag,
+            formatSize(image.Size),
+            formatCreatedTime(image.Created),
+          ]);
+        });
+
+        console.log(table.toString());
+        process.exit(0);
+      } catch (error) {
+        spinner.fail(`Failed to fetch images: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Pull image(s) - supports multiple images
+  program
+    .command('pull <imageTags...>')
+    .description('pull one or more images')
+    .action(async (imageTags) => {
+      const spinner = ora(`Pulling ${imageTags.length} ${imageTags.length === 1 ? 'image' : 'images'}...`).start();
+
+      try {
+        const results = [];
+        for (const imageTag of imageTags) {
+          try {
+            // Split image tag into name and tag
+            const [name, tag = 'latest'] = imageTag.split(':');
+            spinner.text = `Pulling ${imageTag}...`;
+
+            // Pull the image
+            const stream = await docker.pull(`${name}:${tag}`);
+
+            // Track progress
+            await new Promise((resolve, reject) => {
+              docker.modem.followProgress(
+                stream,
+                (err, output) => {
+                  if (err) {
+                    reject(err);
+                    return;
+                  }
+                  resolve(output);
+                },
+                (event) => {
+                  if (event.progress) {
+                    spinner.text = `Pulling ${imageTag}: ${event.progress}`;
+                  } else if (event.status) {
+                    spinner.text = `Pulling ${imageTag}: ${event.status}`;
+                  }
+                }
+              );
+            });
+
+            results.push({ tag: imageTag, success: true });
+          } catch (error) {
+            results.push({ tag: imageTag, success: false, error: error.message });
+          }
+        }
+
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+
+        if (failed.length === 0) {
+          spinner.succeed(`Successfully pulled ${succeeded.length} ${succeeded.length === 1 ? 'image' : 'images'}`);
+        } else if (succeeded.length === 0) {
+          spinner.fail(`Failed to pull all images`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.tag}: ${r.error}`)));
+        } else {
+          spinner.warn(`Pulled ${succeeded.length}/${imageTags.length} ${succeeded.length === 1 ? 'image' : 'images'}`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.tag}: ${r.error}`)));
+        }
+        process.exit(failed.length > 0 ? 1 : 0);
+      } catch (error) {
+        spinner.fail(`Failed to pull images: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Remove image(s) - supports multiple images
+  program
+    .command('rmi <imageIds...>')
+    .description('remove one or more images')
+    .option('-f, --force', 'Force remove the image(s)')
+    .action(async (imageIds, options) => {
+      const spinner = ora(`Removing ${imageIds.length} ${imageIds.length === 1 ? 'image' : 'images'}...`).start();
+
+      try {
+        const results = [];
+        for (const imageId of imageIds) {
+          try {
+            const image = docker.getImage(imageId);
+            await image.remove({ force: options.force });
+            results.push({ id: imageId, success: true });
+          } catch (error) {
+            results.push({ id: imageId, success: false, error: error.message });
+          }
+        }
+
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+
+        if (failed.length === 0) {
+          spinner.succeed(`Successfully removed ${succeeded.length} ${succeeded.length === 1 ? 'image' : 'images'}`);
+        } else if (succeeded.length === 0) {
+          spinner.fail(`Failed to remove all images`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        } else {
+          spinner.warn(`Removed ${succeeded.length}/${imageIds.length} ${succeeded.length === 1 ? 'image' : 'images'}`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.id}: ${r.error}`)));
+        }
+        process.exit(failed.length > 0 ? 1 : 0);
+      } catch (error) {
+        spinner.fail(`Failed to remove images: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Volume commands
+  program
+    .command('volumes')
+    .description('list volumes')
+    .action(async () => {
+      const spinner = ora('Fetching volumes...').start();
+
+      try {
+        const { Volumes } = await docker.listVolumes();
+
+        if (Volumes.length === 0) {
+          spinner.succeed('No volumes found');
+          return;
+        }
+
+        spinner.succeed(`Found ${Volumes.length} ${Volumes.length === 1 ? 'volume' : 'volumes'}`);
+
+        // Create a table for display
+        const table = new Table({
+          head: [
+            chalk.blue('Name'),
+            chalk.blue('Driver'),
+            chalk.blue('Mountpoint'),
+          ],
+          colWidths: [30, 15, 50],
+        });
+
+        Volumes.forEach((volume) => {
+          table.push([volume.Name, volume.Driver, volume.Mountpoint]);
+        });
+
+        console.log(table.toString());
+        process.exit(0);
+      } catch (error) {
+        spinner.fail(`Failed to fetch volumes: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Create volume(s) - supports multiple volumes
+  program
+    .command('volume-create <names...>')
+    .description('create one or more volumes')
+    .option('-d, --driver <driver>', 'Volume driver', 'local')
+    .action(async (names, options) => {
+      const spinner = ora(`Creating ${names.length} ${names.length === 1 ? 'volume' : 'volumes'}...`).start();
+
+      try {
+        const results = [];
+        for (const name of names) {
+          try {
+            await docker.createVolume({
+              Name: name,
+              Driver: options.driver,
+            });
+            results.push({ name, success: true });
+          } catch (error) {
+            results.push({ name, success: false, error: error.message });
+          }
+        }
+
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+
+        if (failed.length === 0) {
+          spinner.succeed(`Successfully created ${succeeded.length} ${succeeded.length === 1 ? 'volume' : 'volumes'}`);
+        } else if (succeeded.length === 0) {
+          spinner.fail(`Failed to create all volumes`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.name}: ${r.error}`)));
+        } else {
+          spinner.warn(`Created ${succeeded.length}/${names.length} ${succeeded.length === 1 ? 'volume' : 'volumes'}`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.name}: ${r.error}`)));
+        }
+        process.exit(failed.length > 0 ? 1 : 0);
+      } catch (error) {
+        spinner.fail(`Failed to create volumes: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Remove volume(s) - supports multiple volumes
+  program
+    .command('volume-rm <names...>')
+    .description('remove one or more volumes')
+    .action(async (names) => {
+      const spinner = ora(`Removing ${names.length} ${names.length === 1 ? 'volume' : 'volumes'}...`).start();
+
+      try {
+        const results = [];
+        for (const name of names) {
+          try {
+            const volume = docker.getVolume(name);
+            await volume.remove();
+            results.push({ name, success: true });
+          } catch (error) {
+            results.push({ name, success: false, error: error.message });
+          }
+        }
+
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+
+        if (failed.length === 0) {
+          spinner.succeed(`Successfully removed ${succeeded.length} ${succeeded.length === 1 ? 'volume' : 'volumes'}`);
+        } else if (succeeded.length === 0) {
+          spinner.fail(`Failed to remove all volumes`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.name}: ${r.error}`)));
+        } else {
+          spinner.warn(`Removed ${succeeded.length}/${names.length} ${succeeded.length === 1 ? 'volume' : 'volumes'}`);
+          failed.forEach(r => console.log(chalk.red(`  ✗ ${r.name}: ${r.error}`)));
+        }
+        process.exit(failed.length > 0 ? 1 : 0);
+      } catch (error) {
+        spinner.fail(`Failed to remove volumes: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Logs command
+  program
+    .command('logs <containerId>')
+    .description('fetch container logs')
+    .option('-f, --follow', 'Follow log output')
+    .option('-t, --tail <lines>', 'Number of lines to show from the end', '100')
+    .action(async (containerId, options) => {
+      try {
+        const container = docker.getContainer(containerId);
+
+        if (options.follow) {
+          console.log(
+            chalk.blue(`Following logs for container ${containerId}...`)
+          );
+          console.log(chalk.blue('Press Ctrl+C to exit'));
+
+          const logStream = await container.logs({
+            follow: true,
+            stdout: true,
+            stderr: true,
+            tail: Number.parseInt(options.tail, 10),
+          });
+
+          logStream.on('data', (chunk) => {
+            process.stdout.write(chunk.toString());
+          });
+
+          // Handle Ctrl+C
+          process.on('SIGINT', () => {
+            console.log(chalk.blue('\nStopping log stream...'));
+            process.exit(0);
+          });
+        } else {
+          const spinner = ora(
+            `Fetching logs for container ${containerId}...`
+          ).start();
+
+          const logs = await container.logs({
+            stdout: true,
+            stderr: true,
+            tail: Number.parseInt(options.tail, 10),
+          });
+
+          spinner.stop();
+          console.log(logs.toString());
+          process.exit(0);
+        }
+      } catch (error) {
+        console.error(chalk.red(`Failed to fetch logs: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  // Local-env app commands
+  program
+    .command('local-env')
+    .description('manage local-env app container')
+    .option('--start', 'start the local-env app')
+    .option('--stop', 'stop the local-env app')
+    .option('--status', 'show local-env app status')
+    .option('--logs', 'show local-env app logs')
+    .option('--logs-follow', 'follow local-env app logs')
+    .action(async (options) => {
+      try {
+        if (options.start) {
+          const spinner = ora('Starting local-env app...').start();
+          try {
+            await containerManager.startContainer();
+            spinner.succeed('Local-env app started successfully');
+          } catch (error) {
+            spinner.fail(`Failed to start local-env app: ${error.message}`);
+            process.exit(1);
+          }
+        } else if (options.stop) {
+          const spinner = ora('Stopping local-env app...').start();
+          try {
+            await containerManager.stopContainerGracefully();
+            spinner.succeed('Local-env app stopped successfully');
+          } catch (error) {
+            spinner.fail(`Failed to stop local-env app: ${error.message}`);
+            process.exit(1);
+          }
+        } else if (options.status) {
+          const status = await containerManager.getStatus();
+          console.log(chalk.bold('\nLocal-env App Status:'));
+          console.log(chalk.blue('Container:'), status.containerName);
+          console.log(
+            chalk.blue('Running:'),
+            status.isRunning ? chalk.green('Yes') : chalk.red('No')
+          );
+          console.log(chalk.blue('Port:'), status.port);
+          console.log(chalk.blue('Data Directory:'), status.dataDirectory);
+          if (status.isRunning) {
+            console.log(
+              chalk.blue('URL:'),
+              chalk.underline(`http://localhost:${status.port}`)
+            );
+          }
+        } else if (options.logs) {
+          console.log(chalk.blue('📋 Showing local-env app logs...'));
+          containerManager.showLogs(false);
+        } else if (options.logsFollow) {
+          console.log(
+            chalk.blue(
+              '📋 Following local-env app logs... (Press Ctrl+C to stop)'
+            )
+          );
+          containerManager.showLogs(true);
+        } else {
+          console.log(
+            chalk.yellow(
+              'Please specify an action: --start, --stop, --status, --logs, or --logs-follow'
+            )
+          );
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error(chalk.red('❌ Error:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  // Registry commands
+  program
+    .command('registries')
+    .description('list registries')
+    .action(async () => {
+      const spinner = ora('Fetching registries...').start();
+
+      try {
+        await registryStore.initialize();
+        const registries = await registryStore.getAllRegistries();
+
+        if (registries.length === 0) {
+          spinner.succeed('No registries found');
+          return;
+        }
+
+        const registryText =
+          registries.length === 1 ? 'registry' : 'registries';
+        spinner.succeed(`Found ${registries.length} ${registryText}`);
+
+        const table = new Table({
+          head: ['ID', 'Name', 'Type', 'URL', 'Connected'].map((h) =>
+            chalk.cyan(h)
+          ),
+          style: { head: [], border: [] },
+        });
+
+        for (const registry of registries) {
+          table.push([
+            registry.id.substring(0, 12) + '...',
+            registry.name,
+            registry.type,
+            registry.url,
+            registry.connected ? chalk.green('✓') : chalk.red('✗'),
+          ]);
+        }
+
+        console.log(chalk.bold('\nConnected Registries:'));
+        console.log(table.toString());
+        process.exit(0);
+      } catch (error) {
+        spinner.fail(`Failed to fetch registries: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Agent info command
+  program
+    .command('info')
+    .description('display agent informations')
+    .action(async () => {
+      const spinner = ora('Fetching agent informations...').start();
+
+      try {
+        // Get Docker version
+        const dockerVersion = await docker.version();
+
+        // Display agent informations
+        spinner.stop();
+        const { version } = packageJson;
+
+        console.log(chalk.bold('\nFenwave Agent Informations:'));
+        console.log(chalk.blue('Version:'), version);
+        console.log(chalk.blue('Hostname:'), os.hostname());
+        console.log(chalk.blue('Platform:'), os.platform());
+        console.log(chalk.blue('Architecture:'), os.arch());
+        console.log(chalk.blue('Node.js Version:'), process.version);
+        console.log(chalk.blue('Docker Version:'), dockerVersion.Version);
+        console.log(chalk.blue('CPU Cores:'), os.cpus().length);
+        console.log(
+          chalk.blue('Memory:'),
+          `${Math.round(os.totalmem() / (1024 * 1024 * 1024))} GB`
+        );
+
+        // Check if agent is actually running
+        const isAgentRunning = await checkAgentRunning(WS_PORT);
+
+        if (isAgentRunning) {
+          // Agent is running, try to get uptime from stored data
+          try {
+            const agentStartTime = await agentStore.loadAgentStartTime();
+            if (agentStartTime) {
+              const currentTime = Date.now();
+              const agentUptimeMs = currentTime - agentStartTime.getTime();
+              console.log(chalk.blue('Uptime:'), formatUptime(agentUptimeMs));
+            } else {
+              console.log(chalk.blue('Uptime:'), '0 seconds');
+            }
+          } catch (error) {
+            console.log(chalk.blue('Uptime:'), '0 seconds');
+          }
+        } else {
+          // Agent is not running
+          console.log(chalk.blue('Status:'), chalk.red('Agent Disconnected'));
+
+          // Clean up stale agent info file if it exists
+          try {
+            await agentStore.clearAgentInfo();
+          } catch (error) {
+            // Ignore cleanup errors
+          }
+        }
+        process.exit(0);
+      } catch (error) {
+        spinner.fail(`Failed to fetch agent informations: ${error.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+export {
+  setupCLICommands,
+};