@oussema_mili/test-pkg-123 1.1.32

package/cli-commands.js

@@ -0,0 +1,1921 @@
+import os from "os";
+import http from "http";
+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 crypto from "crypto";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import { spawn } from "child_process";
+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,
+  createSession,
+  saveSession,
+} from "./auth.js";
+import { hasNpmToken } from "./store/npmTokenStore.js";
+import packageJson from "./package.json" with { type: "json" };
+import {
+  formatSize,
+  formatCreatedTime,
+  formatUptime,
+} from "./helper-functions.js";
+import { ensureEnvironmentFiles } from "./utils/envSetup.js";
+import { loadConfig } from "./store/configStore.js";
+import { runAgent, setupSignalHandlers } from "./daemon/agentRunner.js";
+import {
+  startDaemon,
+  stopDaemon,
+  restartDaemon,
+  getDaemonStatus,
+  formatUptime as formatDaemonUptime,
+} from "./daemon/daemonManager.js";
+import { readLogs, getLogPath } from "./daemon/logManager.js";
+import { getDaemonState } from "./store/daemonStore.js";
+import dotenv from "dotenv";
+dotenv.config();
+
+// Load configuration
+const config = loadConfig();
+const WS_PORT = config.wsPort;
+const BACKEND_URL = config.backendUrl;
+const FRONTEND_URL = config.frontendUrl;
+const AUTH_TIMEOUT_MS = config.authTimeoutMs;
+
+// 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 (authentication only - does NOT start the agent)
+  program
+    .command("login")
+    .description("authenticate with Fenwave (does not start the agent)")
+    .option("--backend-url <url>", "Fenwave backend URL (overrides config)")
+    .option("--frontend-url <url>", "Fenwave frontend URL (overrides config)")
+    .option("--save", "Save the provided URLs to agent configuration")
+    .action(async (options) => {
+      // Determine URLs: CLI options > saved config > defaults
+      let backendUrl = options.backendUrl || BACKEND_URL;
+      let frontendUrl = options.frontendUrl || FRONTEND_URL;
+
+      // If --save flag is provided, persist the URLs to config
+      if (options.save && (options.backendUrl || options.frontendUrl)) {
+        const { updateConfig } = await import("./store/configStore.js");
+        const updates = {};
+        if (options.backendUrl) updates.backendUrl = options.backendUrl;
+        if (options.frontendUrl) updates.frontendUrl = options.frontendUrl;
+        updateConfig(updates);
+        console.log(chalk.green("Configuration saved!"));
+      }
+      console.log(chalk.blue("Authenticating with Fenwave..."));
+      console.log(chalk.gray(`   Backend URL: ${backendUrl}`));
+      console.log(chalk.gray(`   Frontend URL: ${frontendUrl}`));
+
+      // Show environment file status during login
+      ensureEnvironmentFiles(__dirname, true);
+
+      // Check for existing valid session
+      const existingSession = loadSession();
+      if (existingSession && isSessionValid(existingSession)) {
+        console.log(chalk.green("Already authenticated!"));
+        console.log(chalk.gray(`   User: ${existingSession.userEntityRef}`));
+        console.log(
+          chalk.gray(
+            `   Expires: ${new Date(existingSession.expiresAt).toLocaleString()}`,
+          ),
+        );
+        console.log(chalk.yellow("\nTo start the agent, run:"));
+        console.log(chalk.cyan("   fenwave service start   # Background mode"));
+        console.log(chalk.cyan("   fenwave service run     # Foreground mode"));
+        process.exit(0);
+        return;
+      }
+
+      // Pre-check: Test Fenwave connectivity before opening browser
+      try {
+        await axios.get(`${backendUrl}`, {
+          timeout: 5000,
+          validateStatus: () => true,
+        });
+      } catch (connectivityError) {
+        console.error(
+          chalk.red(`Cannot connect to Fenwave backend at ${backendUrl}`),
+        );
+        console.log(
+          chalk.yellow("Please check the URL and ensure Fenwave is running."),
+        );
+        console.log(
+          chalk.yellow(
+            "You can specify a different URL with: fenwave login --backend-url <url> --frontend-url <url>",
+          ),
+        );
+        process.exit(1);
+      }
+
+      console.log(
+        chalk.blue("Redirecting to the browser for authentication..."),
+      );
+
+      // Set up authentication timeout
+      const authTimeout = setTimeout(() => {
+        console.log(chalk.red("Authorization timed out"));
+        console.log(
+          chalk.yellow(
+            "Please ensure Fenwave is running and you are properly authenticated, then try again.",
+          ),
+        );
+        process.exit(1);
+      }, AUTH_TIMEOUT_MS);
+
+      // Start a local HTTP server to handle the loopback redirect on a random available port
+      const loopbackServer = http.createServer(async (req, res) => {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+
+        if (url.pathname === "/auth-callback" && req.method === "GET") {
+          // Serve the auth callback HTML page that reads credentials from URL fragment
+          const htmlPath = path.join(__dirname, "auth-callback.html");
+          fs.readFile(htmlPath, "utf8", (err, htmlContent) => {
+            if (err) {
+              res.writeHead(500, { "Content-Type": "text/plain" });
+              res.end("Error loading authentication page");
+              return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(htmlContent);
+          });
+        } else if (url.pathname === "/auth-complete" && req.method === "POST") {
+          // Handle POST with credentials from fragment reader page
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk;
+          });
+          req.on("end", async () => {
+            try {
+              const { jwt, entityRef } = JSON.parse(body);
+
+              if (!jwt || !entityRef) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(
+                  JSON.stringify({
+                    success: false,
+                    error: "Missing JWT or user information",
+                  }),
+                );
+                return;
+              }
+
+              clearTimeout(authTimeout);
+              console.log(chalk.green("Authentication successful!"));
+
+              // Create session with Fenwave backend
+              console.log(
+                chalk.blue("Creating session with Fenwave backend..."),
+              );
+              const sessionData = await createSession(jwt, backendUrl);
+
+              // Save session locally
+              saveSession(sessionData.token, sessionData.expiresAt, entityRef);
+
+              // Generate and save WebSocket token for later use
+              const wsToken = crypto.randomBytes(32).toString("hex");
+              const wsTokenPath = path.join(
+                os.homedir(),
+                config.agentRootDir,
+                "ws-token",
+              );
+              const wsTokenDir = path.dirname(wsTokenPath);
+              if (!fs.existsSync(wsTokenDir)) {
+                fs.mkdirSync(wsTokenDir, { recursive: true, mode: 0o700 });
+              }
+              fs.writeFileSync(wsTokenPath, wsToken, { mode: 0o600 });
+
+              // Return success with redirect URL
+              const successParams = new URLSearchParams({
+                wsToken,
+                wsPort: String(config.wsPort),
+                containerPort: String(config.containerPort),
+              });
+
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(
+                JSON.stringify({
+                  success: true,
+                  redirectUrl: `/auth-success?${successParams.toString()}`,
+                }),
+              );
+
+              // Schedule cleanup after redirect completes
+              setTimeout(() => {
+                loopbackServer.close();
+
+                console.log(chalk.green("\n" + "=".repeat(50)));
+                console.log(chalk.green("  Authentication Complete"));
+                console.log(chalk.green("=".repeat(50) + "\n"));
+                console.log(chalk.white("  User:"), chalk.cyan(entityRef));
+                console.log(
+                  chalk.white("  Expires:"),
+                  chalk.cyan(new Date(sessionData.expiresAt).toLocaleString()),
+                );
+                console.log(chalk.green("\n" + "=".repeat(50) + "\n"));
+                console.log(chalk.yellow("To start the agent, run one of:"));
+                console.log(
+                  chalk.cyan(
+                    "   fenwave service start   # Background daemon mode",
+                  ),
+                );
+                console.log(
+                  chalk.cyan(
+                    "   fenwave service run     # Foreground mode (for development)\n",
+                  ),
+                );
+
+                process.exit(0);
+              }, 3000);
+            } catch (sessionError) {
+              console.error(
+                chalk.red("Failed to create session:"),
+                sessionError.message,
+              );
+              res.writeHead(500, { "Content-Type": "application/json" });
+              res.end(
+                JSON.stringify({
+                  success: false,
+                  error: `Session creation failed: ${sessionError.message}`,
+                }),
+              );
+              setTimeout(() => {
+                loopbackServer.close();
+                clearTimeout(authTimeout);
+                process.exit(1);
+              }, 3000);
+            }
+          });
+        } else if (url.pathname === "/auth-success") {
+          // Serve the authentication success page (index.html handles localStorage via query params)
+          const htmlPath = path.join(__dirname, "index.html");
+          fs.readFile(htmlPath, "utf8", (err, htmlContent) => {
+            if (err) {
+              res.writeHead(500, { "Content-Type": "text/plain" });
+              res.end("Error loading success page");
+              return;
+            }
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(htmlContent);
+          });
+        } else if (url.pathname === "/dist/styles.css") {
+          // Serve the compiled Tailwind CSS file
+          const cssPath = path.join(__dirname, "dist", "styles.css");
+          fs.readFile(cssPath, (err, data) => {
+            if (err) {
+              res.writeHead(404, { "Content-Type": "text/plain" });
+              res.end("CSS file not found");
+              return;
+            }
+            res.writeHead(200, { "Content-Type": "text/css" });
+            res.end(data);
+          });
+        } else {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("Not Found");
+        }
+      });
+
+      // Find an available port dynamically (starting from 49152 - ephemeral port range)
+      const { findAvailablePort } = await import("./utils/portUtils.js");
+      const loopbackPort = await findAvailablePort(49152, 100);
+
+      loopbackServer.listen(loopbackPort, async () => {
+        const open = (await import("open")).default;
+        // Pass redirect_uri to the frontend so it knows where to redirect after auth
+        const redirectUri = encodeURIComponent(
+          `http://localhost:${loopbackPort}/auth-callback`,
+        );
+        const authUrl = `${frontendUrl}/agent-cli?redirect_uri=${redirectUri}`;
+        console.log(chalk.gray(`   Loopback server on port: ${loopbackPort}`));
+        console.log(chalk.gray(`   Opening: ${authUrl}`));
+        open(authUrl);
+      });
+    });
+
+  // Service subcommand
+  const serviceCommand = program
+    .command("service")
+    .description("manage the Fenwave agent service");
+
+  // fenwave service run - foreground mode
+  serviceCommand
+    .command("run")
+    .description("run the agent in foreground mode (for development)")
+    .option("-p, --port <port>", "WebSocket port to listen on", String(WS_PORT))
+    .action(async (options) => {
+      console.log(chalk.blue("Starting Fenwave Agent in foreground mode..."));
+
+      // Show environment file status
+      ensureEnvironmentFiles(__dirname, true);
+
+      // Setup signal handlers for graceful shutdown
+      setupSignalHandlers();
+
+      try {
+        await runAgent({
+          preferredPort: parseInt(options.port, 10),
+          isDaemon: false,
+        });
+      } catch (error) {
+        console.error(chalk.red(`Failed to start agent: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  // fenwave service start - background daemon mode
+  serviceCommand
+    .command("start")
+    .description("start the agent as a background daemon")
+    .option("-p, --port <port>", "WebSocket port to listen on", String(WS_PORT))
+    .action(async (options) => {
+      const spinner = ora("Starting Fenwave Agent daemon...").start();
+
+      try {
+        // Check for valid session first
+        const session = loadSession();
+        if (!session || !isSessionValid(session)) {
+          spinner.fail("No valid session found");
+          console.log(
+            chalk.yellow(
+              '\nPlease run "fenwave login" first to authenticate.\n',
+            ),
+          );
+          process.exit(1);
+        }
+
+        const daemonInfo = await startDaemon({
+          port: options.port ? parseInt(options.port, 10) : undefined,
+        });
+
+        spinner.succeed("Fenwave Agent daemon started");
+        console.log(chalk.gray(`   PID: ${daemonInfo.pid}`));
+        console.log(chalk.gray(`   Port: ${daemonInfo.port}`));
+        console.log(
+          chalk.gray(
+            `   Started: ${new Date(daemonInfo.startTime).toLocaleString()}`,
+          ),
+        );
+        console.log(
+          chalk.yellow(
+            '\nUse "fenwave service status" to check the daemon status.',
+          ),
+        );
+        console.log(
+          chalk.yellow('Use "fenwave service logs -f" to follow daemon logs.'),
+        );
+        process.exit(0);
+      } catch (error) {
+        spinner.fail("Failed to start daemon");
+        console.error(chalk.red(`   ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  // fenwave service stop - stop daemon
+  serviceCommand
+    .command("stop")
+    .description("stop the running daemon")
+    .action(async () => {
+      const spinner = ora("Stopping Fenwave Agent daemon...").start();
+
+      try {
+        const stopped = await stopDaemon({
+          timeout: 10000,
+        });
+
+        if (stopped) {
+          spinner.succeed("Fenwave Agent daemon stopped");
+        } else {
+          spinner.warn("Daemon was not running");
+        }
+        process.exit(0);
+      } catch (error) {
+        spinner.fail("Failed to stop daemon");
+        console.error(chalk.red(`   ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  // fenwave service restart - restart daemon
+  serviceCommand
+    .command("restart")
+    .description("restart the daemon")
+    .option("-p, --port <port>", "WebSocket port to listen on")
+    .action(async (options) => {
+      const spinner = ora("Restarting Fenwave Agent daemon...").start();
+
+      try {
+        const daemonInfo = await restartDaemon({
+          port: options.port ? parseInt(options.port, 10) : undefined,
+        });
+
+        spinner.succeed("Fenwave Agent daemon restarted");
+        console.log(chalk.gray(`   PID: ${daemonInfo.pid}`));
+        console.log(chalk.gray(`   Port: ${daemonInfo.port}`));
+        console.log(
+          chalk.gray(
+            `   Started: ${new Date(daemonInfo.startTime).toLocaleString()}`,
+          ),
+        );
+        process.exit(0);
+      } catch (error) {
+        spinner.fail("Failed to restart daemon");
+        console.error(chalk.red(`   ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  // fenwave service status - show status
+  serviceCommand
+    .command("status")
+    .description("show daemon status")
+    .action(async () => {
+      const status = getDaemonStatus();
+
+      console.log(chalk.bold("\nFenwave Agent Daemon Status\n"));
+
+      if (status.running) {
+        console.log(chalk.green("Status:    Running"));
+        console.log(chalk.white(`PID:       ${status.pid}`));
+        console.log(chalk.white(`Port:      ${status.port}`));
+        console.log(chalk.white(`User:      ${status.userEntityRef || "N/A"}`));
+        console.log(
+          chalk.white(
+            `Started:   ${new Date(status.startTime).toLocaleString()}`,
+          ),
+        );
+        console.log(
+          chalk.white(`Uptime:    ${formatDaemonUptime(status.uptime)}`),
+        );
+      } else {
+        console.log(chalk.yellow("Status:    Not Running"));
+        console.log(chalk.gray("\nTo start the agent, run:"));
+        console.log(chalk.cyan("   fenwave service start"));
+      }
+
+      console.log("");
+      process.exit(0);
+    });
+
+  // fenwave service logs - view logs
+  serviceCommand
+    .command("logs")
+    .description("view daemon logs")
+    .option("-f, --follow", "follow log output in real-time")
+    .option("-t, --tail <lines>", "number of lines to show", "100")
+    .action(async (options) => {
+      if (options.follow) {
+        // Follow logs in real-time using tail
+        const logPath = getLogPath();
+
+        if (!fs.existsSync(logPath)) {
+          console.log(
+            chalk.yellow("No log file found. Is the daemon running?"),
+          );
+          process.exit(0);
+        }
+
+        console.log(chalk.blue(`Following logs from ${logPath}`));
+        console.log(chalk.gray("Press Ctrl+C to stop\n"));
+
+        const tailProcess = spawn("tail", ["-f", "-n", options.tail, logPath], {
+          stdio: "inherit",
+        });
+
+        process.on("SIGINT", () => {
+          tailProcess.kill();
+          process.exit(0);
+        });
+      } else {
+        // Show recent logs
+        const logs = readLogs(parseInt(options.tail, 10));
+        if (logs) {
+          console.log(logs);
+        } else {
+          console.log(chalk.yellow("No logs found."));
+        }
+        process.exit(0);
+      }
+    });
+
+  // Config command - view and manage agent configuration
+  const configCommand = program
+    .command("config")
+    .description("view and manage agent configuration");
+
+  // fenwave config show - display current configuration
+  configCommand
+    .command("show")
+    .description("display current agent configuration")
+    .action(async () => {
+      const { loadConfig, getConfigPath, configExists } =
+        await import("./store/configStore.js");
+
+      console.log(chalk.bold("\nFenwave Agent Configuration\n"));
+
+      if (!configExists()) {
+        console.log(chalk.yellow("No configuration file found."));
+        console.log(
+          chalk.gray(
+            "Using default settings. Run 'fenwave init' or 'fenwave config set' to configure.\n",
+          ),
+        );
+      }
+
+      const currentConfig = loadConfig();
+      console.log(chalk.white("  Config file:"), chalk.gray(getConfigPath()));
+      console.log("");
+
+      const formatValue = (v) => {
+        if (v === undefined || v === null) return chalk.gray(String(v));
+        if (typeof v === "object") return chalk.cyan(JSON.stringify(v));
+        return chalk.cyan(String(v));
+      };
+
+      Object.keys(currentConfig).forEach((key) => {
+        console.log(chalk.white(`  ${key}:`), formatValue(currentConfig[key]));
+      });
+
+      console.log("");
+
+      process.exit(0);
+    });
+
+  // fenwave config set - update configuration
+  configCommand
+    .command("set")
+    .description("update agent configuration")
+    .option("--backend-url <url>", "Fenwave backend URL")
+    .option("--frontend-url <url>", "Fenwave frontend URL")
+    .option("--ws-port <port>", "WebSocket port")
+    .option("--container-port <port>", "Container port")
+    .option("--docker-image <image>", "Docker image for dev container")
+    .action(async (options) => {
+      const { updateConfig, loadConfig } =
+        await import("./store/configStore.js");
+
+      const updates = {};
+      if (options.backendUrl) updates.backendUrl = options.backendUrl;
+      if (options.frontendUrl) updates.frontendUrl = options.frontendUrl;
+      if (options.wsPort) updates.wsPort = parseInt(options.wsPort, 10);
+      if (options.containerPort)
+        updates.containerPort = parseInt(options.containerPort, 10);
+      if (options.dockerImage) updates.dockerImage = options.dockerImage;
+
+      if (Object.keys(updates).length === 0) {
+        console.log(chalk.yellow("No configuration options provided."));
+        console.log(chalk.gray("Use --help to see available options."));
+        process.exit(1);
+      }
+
+      updateConfig(updates);
+      console.log(chalk.green("Configuration updated successfully!\n"));
+
+      // Show updated configuration
+      const newConfig = loadConfig();
+      const formatValue2 = (v) => {
+        if (v === undefined || v === null) return chalk.gray(String(v));
+        if (typeof v === "object") return chalk.cyan(JSON.stringify(v));
+        return chalk.cyan(String(v));
+      };
+      Object.keys(newConfig).forEach((key) => {
+        console.log(chalk.white(`  ${key}:`), formatValue2(newConfig[key]));
+      });
+      console.log("");
+
+      process.exit(0);
+    });
+
+  // fenwave config reset - reset to defaults
+  configCommand
+    .command("reset")
+    .description("reset configuration to defaults")
+    .action(async () => {
+      const { saveConfig, DEFAULT_CONFIG } =
+        await import("./store/configStore.js");
+
+      saveConfig(DEFAULT_CONFIG);
+      console.log(chalk.green("Configuration reset to defaults.\n"));
+      // Print full default configuration
+      const { loadConfig } = await import("./store/configStore.js");
+      const after = loadConfig();
+      const fmt = (v) => {
+        if (v === undefined || v === null) return chalk.gray(String(v));
+        if (typeof v === "object") return chalk.cyan(JSON.stringify(v));
+        return chalk.cyan(String(v));
+      };
+      Object.keys(after).forEach((k) => {
+        console.log(chalk.white(`  ${k}:`), fmt(after[k]));
+      });
+      console.log("");
+
+      process.exit(0);
+    });
+
+  // Logout (clear session)
+  program
+    .command("logout")
+    .description("clear stored session and logout")
+    .action(async () => {
+      // Check if daemon is running
+      const status = getDaemonStatus();
+      if (status.running) {
+        console.log(chalk.yellow("Stopping running daemon first..."));
+        try {
+          await stopDaemon({ force: false, timeout: 5000 });
+        } catch (e) {
+          // Ignore
+        }
+      }
+
+      const session = loadSession();
+      if (session) {
+        clearSession();
+        console.log(chalk.green("Logged out 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");
+
+        console.log(chalk.bold("\nFenwave 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 - check daemon first, then fallback to port check
+        const daemonStatus = getDaemonStatus();
+        if (daemonStatus.running) {
+          console.log(
+            chalk.green(
+              `Agent: Running (daemon, PID ${daemonStatus.pid}, port ${daemonStatus.port})`,
+            ),
+          );
+          console.log(
+            chalk.gray(`   Uptime: ${formatDaemonUptime(daemonStatus.uptime)}`),
+          );
+        } else {
+          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 service start" 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 Fenwave")
+    .option("--skip-prerequisites", "Skip prerequisites check")
+    .option(
+      "--backend-url <url>",
+      "Fenwave backend URL",
+      "http://localhost:7007",
+    )
+    .option(
+      "--frontend-url <url>",
+      "Fenwave 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 Fenwave")
+    .option("-t, --token <token>", "Registration token from Fenwave")
+    .option(
+      "--backend-url <url>",
+      "Fenwave 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");
+
+        // 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,
+        });
+
+        spinner.succeed("Device registered successfully");
+        console.log(chalk.green("\nRegistration 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 Fenwave 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>",
+      "Fenwave 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 daemon if running
+        try {
+          const status = getDaemonStatus();
+          if (status.running) {
+            spinner.text = "Stopping daemon...";
+            await stopDaemon({ force: true, timeout: 5000 });
+          }
+        } 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("\nFenwave 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/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("Y") : chalk.red("N"),
+          ]);
+        }
+
+        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 information")
+    .action(async () => {
+      const spinner = ora("Fetching agent information...").start();
+
+      try {
+        // Get Docker version
+        const dockerVersion = await docker.version();
+
+        // Display agent information
+        spinner.stop();
+        const { version } = packageJson;
+
+        console.log(chalk.bold("\nFenwave Agent Information:"));
+        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 daemon status
+        const daemonStatus = getDaemonStatus();
+        if (daemonStatus.running) {
+          console.log(
+            chalk.blue("Status:"),
+            chalk.green(`Running (PID: ${daemonStatus.pid})`),
+          );
+          console.log(chalk.blue("Port:"), daemonStatus.port);
+          console.log(
+            chalk.blue("Uptime:"),
+            formatDaemonUptime(daemonStatus.uptime),
+          );
+        } else {
+          // Fallback to checking port
+          const isAgentRunning = await checkAgentRunning(WS_PORT);
+          if (isAgentRunning) {
+            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 {
+            console.log(chalk.blue("Status:"), chalk.red("Agent Not Running"));
+            try {
+              await agentStore.clearAgentInfo();
+            } catch (error) {
+              // Ignore cleanup errors
+            }
+          }
+        }
+        process.exit(0);
+      } catch (error) {
+        spinner.fail(`Failed to fetch agent information: ${error.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+export { setupCLICommands };