container-manager-mcp 0.0.11__py3-none-any.whl → 1.0.0__py3-none-any.whl

container_manager_mcp/container_manager.py

@@ -6,10 +6,12 @@ import logging
 import os
 from abc import ABC, abstractmethod
 from typing import List, Dict, Optional, Any
-import getopt
+import argparse
 import json
 import subprocess
-from datetime import datetime  # Added for consistent timestamp formatting
+from datetime import datetime
+import dateutil.parser
+import platform
 
 try:
     import docker
@@ -27,6 +29,7 @@ except ImportError:
 
 
 class ContainerManagerBase(ABC):
+
     def __init__(self, silent: bool = False, log_file: str = None):
         self.silent = silent
         self.setup_logging(log_file)
@@ -66,6 +69,20 @@ class ContainerManagerBase(ABC):
             size_bytes /= 1024.0
         return f"{size_bytes:.2f}PB"
 
+    def _parse_timestamp(self, timestamp: Any) -> str:
+        """Parse timestamp (integer or string) to ISO 8601 string."""
+        if not timestamp:
+            return "unknown"
+        if isinstance(timestamp, (int, float)):
+            return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%dT%H:%M:%S")
+        if isinstance(timestamp, str):
+            try:
+                parsed = dateutil.parser.isoparse(timestamp)
+                return parsed.strftime("%Y-%m-%dT%H:%M:%S")
+            except ValueError:
+                return "unknown"
+        return "unknown"
+
     @abstractmethod
     def get_version(self) -> Dict:
         pass
@@ -208,42 +225,6 @@ class DockerManager(ContainerManagerBase):
             self.logger.error(f"Failed to connect to Docker daemon: {str(e)}")
             raise RuntimeError(f"Failed to connect to Docker: {str(e)}")
 
-    def get_version(self) -> Dict:
-        params = {}
-        try:
-            version = self.client.version()
-            result = {
-                "version": version.get("Version", "unknown"),
-                "api_version": version.get("ApiVersion", "unknown"),
-                "os": version.get("Os", "unknown"),
-                "arch": version.get("Arch", "unknown"),
-                "build_time": version.get("BuildTime", "unknown"),
-            }
-            self.log_action("get_version", params, result)
-            return result
-        except Exception as e:
-            self.log_action("get_version", params, error=e)
-            raise RuntimeError(f"Failed to get version: {str(e)}")
-
-    def get_info(self) -> Dict:
-        params = {}
-        try:
-            info = self.client.info()
-            result = {
-                "containers_total": info.get("Containers", 0),
-                "containers_running": info.get("ContainersRunning", 0),
-                "images": info.get("Images", 0),
-                "driver": info.get("Driver", "unknown"),
-                "platform": f"{info.get('OperatingSystem', 'unknown')} {info.get('Architecture', 'unknown')}",
-                "memory_total": self._format_size(info.get("MemTotal", 0)),
-                "swap_total": self._format_size(info.get("SwapTotal", 0)),
-            }
-            self.log_action("get_info", params, result)
-            return result
-        except Exception as e:
-            self.log_action("get_info", params, error=e)
-            raise RuntimeError(f"Failed to get info: {str(e)}")
-
     def list_images(self) -> List[Dict]:
         params = {}
         try:
@@ -257,12 +238,8 @@ class DockerManager(ContainerManagerBase):
                     repo_tag.rsplit(":", 1) if ":" in repo_tag else ("<none>", "<none>")
                 )
 
-                created = attrs.get("Created", 0)
-                created_str = (
-                    datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                    if created
-                    else "unknown"
-                )
+                created = attrs.get("Created", None)
+                created_str = self._parse_timestamp(created)
 
                 size_bytes = attrs.get("Size", 0)
                 size_str = self._format_size(size_bytes) if size_bytes else "0B"
@@ -298,12 +275,8 @@ class DockerManager(ContainerManagerBase):
             repository, tag = (
                 repo_tag.rsplit(":", 1) if ":" in repo_tag else (image, tag)
             )
-            created = attrs.get("Created", 0)
-            created_str = (
-                datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                if created
-                else "unknown"
-            )
+            created = attrs.get("Created", None)
+            created_str = self._parse_timestamp(created)
             size_bytes = attrs.get("Size", 0)
             size_str = self._format_size(size_bytes) if size_bytes else "0B"
             result = {
@@ -321,17 +294,6 @@ class DockerManager(ContainerManagerBase):
             self.log_action("pull_image", params, error=e)
             raise RuntimeError(f"Failed to pull image: {str(e)}")
 
-    def remove_image(self, image: str, force: bool = False) -> Dict:
-        params = {"image": image, "force": force}
-        try:
-            self.client.images.remove(image, force=force)
-            result = {"removed": image}
-            self.log_action("remove_image", params, result)
-            return result
-        except Exception as e:
-            self.log_action("remove_image", params, error=e)
-            raise RuntimeError(f"Failed to remove image: {str(e)}")
-
     def list_containers(self, all: bool = False) -> List[Dict]:
         params = {"all": all}
         try:
@@ -347,12 +309,8 @@ class DockerManager(ContainerManagerBase):
                             port_mappings.append(
                                 f"{hp.get('HostIp', '0.0.0.0')}:{hp.get('HostPort')}->{container_port}"
                             )
-                created = attrs.get("Created", 0)
-                created_str = (
-                    datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                    if created
-                    else "unknown"
-                )
+                created = attrs.get("Created", None)
+                created_str = self._parse_timestamp(created)
                 simplified = {
                     "id": attrs.get("Id", "unknown")[7:19],
                     "image": attrs.get("Config", {}).get("Image", "unknown"),
@@ -410,12 +368,8 @@ class DockerManager(ContainerManagerBase):
                         port_mappings.append(
                             f"{hp.get('HostIp', '0.0.0.0')}:{hp.get('HostPort')}->{container_port}"
                         )
-            created = attrs.get("Created", 0)
-            created_str = (
-                datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                if created
-                else "unknown"
-            )
+            created = attrs.get("Created", None)
+            created_str = self._parse_timestamp(created)
             result = {
                 "id": attrs.get("Id", "unknown")[7:19],
                 "image": attrs.get("Config", {}).get("Image", image),
@@ -430,6 +384,98 @@ class DockerManager(ContainerManagerBase):
             self.log_action("run_container", params, error=e)
             raise RuntimeError(f"Failed to run container: {str(e)}")
 
+    def list_networks(self) -> List[Dict]:
+        params = {}
+        try:
+            networks = self.client.networks.list()
+            result = []
+            for net in networks:
+                attrs = net.attrs
+                containers = len(attrs.get("Containers", {}))
+                created = attrs.get("Created", None)
+                created_str = self._parse_timestamp(created)
+                simplified = {
+                    "id": attrs.get("Id", "unknown")[7:19],
+                    "name": attrs.get("Name", "unknown"),
+                    "driver": attrs.get("Driver", "unknown"),
+                    "scope": attrs.get("Scope", "unknown"),
+                    "containers": containers,
+                    "created": created_str,
+                }
+                result.append(simplified)
+            self.log_action("list_networks", params, result)
+            return result
+        except Exception as e:
+            self.log_action("list_networks", params, error=e)
+            raise RuntimeError(f"Failed to list networks: {str(e)}")
+
+    def create_network(self, name: str, driver: str = "bridge") -> Dict:
+        params = {"name": name, "driver": driver}
+        try:
+            network = self.client.networks.create(name, driver=driver)
+            attrs = network.attrs
+            created = attrs.get("Created", None)
+            created_str = self._parse_timestamp(created)
+            result = {
+                "id": attrs.get("Id", "unknown")[7:19],
+                "name": attrs.get("Name", name),
+                "driver": attrs.get("Driver", driver),
+                "scope": attrs.get("Scope", "unknown"),
+                "created": created_str,
+            }
+            self.log_action("create_network", params, result)
+            return result
+        except Exception as e:
+            self.log_action("create_network", params, error=e)
+            raise RuntimeError(f"Failed to create network: {str(e)}")
+
+    def get_version(self) -> Dict:
+        params = {}
+        try:
+            version = self.client.version()
+            result = {
+                "version": version.get("Version", "unknown"),
+                "api_version": version.get("ApiVersion", "unknown"),
+                "os": version.get("Os", "unknown"),
+                "arch": version.get("Arch", "unknown"),
+                "build_time": version.get("BuildTime", "unknown"),
+            }
+            self.log_action("get_version", params, result)
+            return result
+        except Exception as e:
+            self.log_action("get_version", params, error=e)
+            raise RuntimeError(f"Failed to get version: {str(e)}")
+
+    def get_info(self) -> Dict:
+        params = {}
+        try:
+            info = self.client.info()
+            result = {
+                "containers_total": info.get("Containers", 0),
+                "containers_running": info.get("ContainersRunning", 0),
+                "images": info.get("Images", 0),
+                "driver": info.get("Driver", "unknown"),
+                "platform": f"{info.get('OperatingSystem', 'unknown')} {info.get('Architecture', 'unknown')}",
+                "memory_total": self._format_size(info.get("MemTotal", 0)),
+                "swap_total": self._format_size(info.get("SwapTotal", 0)),
+            }
+            self.log_action("get_info", params, result)
+            return result
+        except Exception as e:
+            self.log_action("get_info", params, error=e)
+            raise RuntimeError(f"Failed to get info: {str(e)}")
+
+    def remove_image(self, image: str, force: bool = False) -> Dict:
+        params = {"image": image, "force": force}
+        try:
+            self.client.images.remove(image, force=force)
+            result = {"removed": image}
+            self.log_action("remove_image", params, result)
+            return result
+        except Exception as e:
+            self.log_action("remove_image", params, error=e)
+            raise RuntimeError(f"Failed to remove image: {str(e)}")
+
     def stop_container(self, container_id: str, timeout: int = 10) -> Dict:
         params = {"container_id": container_id, "timeout": timeout}
         try:
@@ -535,65 +581,6 @@ class DockerManager(ContainerManagerBase):
             self.log_action("remove_volume", params, error=e)
             raise RuntimeError(f"Failed to remove volume: {str(e)}")
 
-    def list_networks(self) -> List[Dict]:
-        params = {}
-        try:
-            networks = self.client.networks.list()
-            result = []
-            for net in networks:
-                attrs = net.attrs
-                containers = len(attrs.get("Containers", {}))
-                created = attrs.get("Created", "unknown")
-                if isinstance(created, str):
-                    created_str = created
-                else:
-                    created_str = (
-                        datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                        if created
-                        else "unknown"
-                    )
-                simplified = {
-                    "id": attrs.get("Id", "unknown")[7:19],
-                    "name": attrs.get("Name", "unknown"),
-                    "driver": attrs.get("Driver", "unknown"),
-                    "scope": attrs.get("Scope", "unknown"),
-                    "containers": containers,
-                    "created": created_str,
-                }
-                result.append(simplified)
-            self.log_action("list_networks", params, result)
-            return result
-        except Exception as e:
-            self.log_action("list_networks", params, error=e)
-            raise RuntimeError(f"Failed to list networks: {str(e)}")
-
-    def create_network(self, name: str, driver: str = "bridge") -> Dict:
-        params = {"name": name, "driver": driver}
-        try:
-            network = self.client.networks.create(name, driver=driver)
-            attrs = network.attrs
-            created = attrs.get("Created", "unknown")
-            if isinstance(created, str):
-                created_str = created
-            else:
-                created_str = (
-                    datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                    if created
-                    else "unknown"
-                )
-            result = {
-                "id": attrs.get("Id", "unknown")[7:19],
-                "name": attrs.get("Name", name),
-                "driver": attrs.get("Driver", driver),
-                "scope": attrs.get("Scope", "unknown"),
-                "created": created_str,
-            }
-            self.log_action("create_network", params, result)
-            return result
-        except Exception as e:
-            self.log_action("create_network", params, error=e)
-            raise RuntimeError(f"Failed to create network: {str(e)}")
-
     def remove_network(self, network_id: str) -> Dict:
         params = {"network_id": network_id}
         try:
@@ -829,52 +816,107 @@ class DockerManager(ContainerManagerBase):
 
 
 class PodmanManager(ContainerManagerBase):
-    def __init__(self, silent: bool = False, log_file: str = None):
+    def __init__(self, silent: bool = False, log_file: Optional[str] = None):
         super().__init__(silent, log_file)
+
         if PodmanClient is None:
             raise ImportError("Please install podman-py: pip install podman")
+
+        base_url = self._autodetect_podman_url()
+        if base_url is None:
+            self.logger.error(
+                "No valid Podman socket found after trying all known locations"
+            )
+            raise RuntimeError("Failed to connect to Podman: No valid socket found")
+
         try:
-            self.client = PodmanClient()
+            self.client = PodmanClient(base_url=base_url)
+            self.logger.info(f"Connected to Podman with base_url: {base_url}")
         except PodmanError as e:
-            self.logger.error(f"Failed to connect to Podman daemon: {str(e)}")
-            raise RuntimeError(f"Failed to connect to Podman: {str(e)}")
+            self.logger.error(
+                f"Failed to connect to Podman daemon with {base_url}: {str(e)}"
+            )
+            raise RuntimeError(f"Failed to connect to Podman with {base_url}: {str(e)}")
 
-    def get_version(self) -> Dict:
-        params = {}
+    def _is_wsl(self) -> bool:
+        """Check if running inside WSL2."""
         try:
-            version = self.client.version()
-            result = {
-                "version": version.get("Version", "unknown"),
-                "api_version": version.get("APIVersion", "unknown"),
-                "os": version.get("Os", "unknown"),
-                "arch": version.get("Arch", "unknown"),
-                "build_time": version.get("BuildTime", "unknown"),
-            }
-            self.log_action("get_version", params, result)
-            return result
-        except Exception as e:
-            self.log_action("get_version", params, error=e)
-            raise RuntimeError(f"Failed to get version: {str(e)}")
+            with open("/proc/version", "r") as f:
+                return "WSL" in f.read()
+        except FileNotFoundError:
+            return "WSL_DISTRO_NAME" in os.environ
 
-    def get_info(self) -> Dict:
-        params = {}
+    def _is_podman_machine_running(self) -> bool:
+        """Check if Podman machine is running (for Windows/WSL2)."""
         try:
-            info = self.client.info()
-            host = info.get("host", {})
-            result = {
-                "containers_total": info.get("store", {}).get("containers", 0),
-                "containers_running": host.get("runningContainers", 0),
-                "images": info.get("store", {}).get("images", 0),
-                "driver": host.get("graphDriverName", "unknown"),
-                "platform": f"{host.get('os', 'unknown')} {host.get('arch', 'unknown')}",
-                "memory_total": self._format_size(host.get("memTotal", 0)),
-                "swap_total": self._format_size(host.get("swapTotal", 0)),
-            }
-            self.log_action("get_info", params, result)
-            return result
-        except Exception as e:
-            self.log_action("get_info", params, error=e)
-            raise RuntimeError(f"Failed to get info: {str(e)}")
+            result = subprocess.run(
+                ["podman", "machine", "list", "--format", "{{.Running}}"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            return "true" in result.stdout.lower()
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False
+
+    def _try_connect(self, base_url: str) -> Optional[PodmanClient]:
+        """Attempt to connect to Podman with the given base_url."""
+        try:
+            client = PodmanClient(base_url=base_url)
+            # Test connection
+            client.version()
+            return client
+        except PodmanError as e:
+            self.logger.debug(f"Connection failed for {base_url}: {str(e)}")
+            return None
+
+    def _autodetect_podman_url(self) -> Optional[str]:
+        """Autodetect the appropriate Podman socket URL based on platform."""
+        # Check for environment variable override
+        base_url = os.environ.get("PODMAN_BASE_URL")
+        if base_url:
+            self.logger.info(f"Using PODMAN_BASE_URL from environment: {base_url}")
+            return base_url
+
+        system = platform.system()
+        is_wsl = self._is_wsl()
+
+        # Define socket candidates based on platform
+        socket_candidates = []
+        if system == "Windows" and not is_wsl:
+            # Windows with Podman machine
+            if self._is_podman_machine_running():
+                socket_candidates.append("npipe:////./pipe/docker_engine")
+            # Fallback to WSL2 distro sockets if running in a mixed setup
+            socket_candidates.extend(
+                [
+                    "unix:///mnt/wsl/podman-sockets/podman-machine-default/podman-user.sock",  # Rootless
+                    "unix:///mnt/wsl/podman-sockets/podman-machine-default/podman-root.sock",  # Rootful
+                ]
+            )
+        elif system == "Linux" or is_wsl:
+            # Linux or WSL2 distro: prioritize rootless, then rootful
+            uid = os.getuid()
+            socket_candidates.extend(
+                [
+                    f"unix:///run/user/{uid}/podman/podman.sock",  # Rootless
+                    "unix:///run/podman/podman.sock",  # Rootful
+                ]
+            )
+
+        # Try each socket candidate
+        for url in socket_candidates:
+            # For Unix sockets, check if the file exists (on Linux/WSL2)
+            if url.startswith("unix://") and (system == "Linux" or is_wsl):
+                socket_path = url.replace("unix://", "")
+                if not os.path.exists(socket_path):
+                    self.logger.debug(f"Socket {socket_path} does not exist")
+                    continue
+            client = self._try_connect(url)
+            if client:
+                return url
+
+        return None
 
     def list_images(self) -> List[Dict]:
         params = {}
@@ -888,12 +930,8 @@ class PodmanManager(ContainerManagerBase):
                 repository, tag = (
                     repo_tag.rsplit(":", 1) if ":" in repo_tag else ("<none>", "<none>")
                 )
-                created = attrs.get("Created", 0)
-                created_str = (
-                    datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                    if created
-                    else "unknown"
-                )
+                created = attrs.get("Created", None)
+                created_str = self._parse_timestamp(created)
                 size_bytes = attrs.get("Size", 0)
                 size_str = self._format_size(size_bytes) if size_bytes else "0B"
                 simplified = {
@@ -926,12 +964,8 @@ class PodmanManager(ContainerManagerBase):
             repository, tag = (
                 repo_tag.rsplit(":", 1) if ":" in repo_tag else (image, tag)
             )
-            created = attrs.get("Created", 0)
-            created_str = (
-                datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                if created
-                else "unknown"
-            )
+            created = attrs.get("Created", None)
+            created_str = self._parse_timestamp(created)
             size_bytes = attrs.get("Size", 0)
             size_str = self._format_size(size_bytes) if size_bytes else "0B"
             result = {
@@ -949,17 +983,6 @@ class PodmanManager(ContainerManagerBase):
             self.log_action("pull_image", params, error=e)
             raise RuntimeError(f"Failed to pull image: {str(e)}")
 
-    def remove_image(self, image: str, force: bool = False) -> Dict:
-        params = {"image": image, "force": force}
-        try:
-            self.client.images.remove(image, force=force)
-            result = {"removed": image}
-            self.log_action("remove_image", params, result)
-            return result
-        except Exception as e:
-            self.log_action("remove_image", params, error=e)
-            raise RuntimeError(f"Failed to remove image: {str(e)}")
-
     def list_containers(self, all: bool = False) -> List[Dict]:
         params = {"all": all}
         try:
@@ -973,12 +996,8 @@ class PodmanManager(ContainerManagerBase):
                     for p in ports
                     if p.get("host_port")
                 ]
-                created = attrs.get("Created", 0)
-                created_str = (
-                    datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                    if created
-                    else "unknown"
-                )
+                created = attrs.get("Created", None)
+                created_str = self._parse_timestamp(created)
                 simplified = {
                     "id": attrs.get("Id", "unknown")[7:19],
                     "image": attrs.get("Image", "unknown"),
@@ -1034,12 +1053,8 @@ class PodmanManager(ContainerManagerBase):
                 for p in ports
                 if p.get("host_port")
             ]
-            created = attrs.get("Created", 0)
-            created_str = (
-                datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                if created
-                else "unknown"
-            )
+            created = attrs.get("Created", None)
+            created_str = self._parse_timestamp(created)
             result = {
                 "id": attrs.get("Id", "unknown")[7:19],
                 "image": attrs.get("Image", image),
@@ -1054,6 +1069,99 @@ class PodmanManager(ContainerManagerBase):
             self.log_action("run_container", params, error=e)
             raise RuntimeError(f"Failed to run container: {str(e)}")
 
+    def list_networks(self) -> List[Dict]:
+        params = {}
+        try:
+            networks = self.client.networks.list()
+            result = []
+            for net in networks:
+                attrs = net.attrs
+                containers = len(attrs.get("Containers", {}))
+                created = attrs.get("Created", None)
+                created_str = self._parse_timestamp(created)
+                simplified = {
+                    "id": attrs.get("Id", "unknown")[7:19],
+                    "name": attrs.get("Name", "unknown"),
+                    "driver": attrs.get("Driver", "unknown"),
+                    "scope": attrs.get("Scope", "unknown"),
+                    "containers": containers,
+                    "created": created_str,
+                }
+                result.append(simplified)
+            self.log_action("list_networks", params, result)
+            return result
+        except Exception as e:
+            self.log_action("list_networks", params, error=e)
+            raise RuntimeError(f"Failed to list networks: {str(e)}")
+
+    def create_network(self, name: str, driver: str = "bridge") -> Dict:
+        params = {"name": name, "driver": driver}
+        try:
+            network = self.client.networks.create(name, driver=driver)
+            attrs = network.attrs
+            created = attrs.get("Created", None)
+            created_str = self._parse_timestamp(created)
+            result = {
+                "id": attrs.get("Id", "unknown")[7:19],
+                "name": attrs.get("Name", name),
+                "driver": attrs.get("Driver", driver),
+                "scope": attrs.get("Scope", "unknown"),
+                "created": created_str,
+            }
+            self.log_action("create_network", params, result)
+            return result
+        except Exception as e:
+            self.log_action("create_network", params, error=e)
+            raise RuntimeError(f"Failed to create network: {str(e)}")
+
+    def get_version(self) -> Dict:
+        params = {}
+        try:
+            version = self.client.version()
+            result = {
+                "version": version.get("Version", "unknown"),
+                "api_version": version.get("APIVersion", "unknown"),
+                "os": version.get("Os", "unknown"),
+                "arch": version.get("Arch", "unknown"),
+                "build_time": version.get("BuildTime", "unknown"),
+            }
+            self.log_action("get_version", params, result)
+            return result
+        except Exception as e:
+            self.log_action("get_version", params, error=e)
+            raise RuntimeError(f"Failed to get version: {str(e)}")
+
+    def get_info(self) -> Dict:
+        params = {}
+        try:
+            info = self.client.info()
+            host = info.get("host", {})
+            result = {
+                "containers_total": info.get("store", {}).get("containers", 0),
+                "containers_running": host.get("runningContainers", 0),
+                "images": info.get("store", {}).get("images", 0),
+                "driver": host.get("graphDriverName", "unknown"),
+                "platform": f"{host.get('os', 'unknown')} {host.get('arch', 'unknown')}",
+                "memory_total": self._format_size(host.get("memTotal", 0)),
+                "swap_total": self._format_size(host.get("swapTotal", 0)),
+            }
+            self.log_action("get_info", params, result)
+            return result
+        except Exception as e:
+            self.log_action("get_info", params, error=e)
+            raise RuntimeError(f"Failed to get info: {str(e)}")
+
+    def remove_image(self, image: str, force: bool = False) -> Dict:
+        params = {"image": image, "force": force}
+        try:
+            self.client.images.remove(image, force=force)
+            result = {"removed": image}
+            self.log_action("remove_image", params, result)
+            return result
+        except Exception as e:
+            self.log_action("remove_image", params, error=e)
+            raise RuntimeError(f"Failed to remove image: {str(e)}")
+
     def stop_container(self, container_id: str, timeout: int = 10) -> Dict:
         params = {"container_id": container_id, "timeout": timeout}
         try:
@@ -1159,65 +1267,6 @@ class PodmanManager(ContainerManagerBase):
             self.log_action("remove_volume", params, error=e)
             raise RuntimeError(f"Failed to remove volume: {str(e)}")
 
-    def list_networks(self) -> List[Dict]:
-        params = {}
-        try:
-            networks = self.client.networks.list()
-            result = []
-            for net in networks:
-                attrs = net.attrs
-                containers = len(attrs.get("Containers", {}))
-                created = attrs.get("Created", "unknown")
-                if isinstance(created, str):
-                    created_str = created
-                else:
-                    created_str = (
-                        datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                        if created
-                        else "unknown"
-                    )
-                simplified = {
-                    "id": attrs.get("Id", "unknown")[7:19],
-                    "name": attrs.get("Name", "unknown"),
-                    "driver": attrs.get("Driver", "unknown"),
-                    "scope": attrs.get("Scope", "unknown"),
-                    "containers": containers,
-                    "created": created_str,
-                }
-                result.append(simplified)
-            self.log_action("list_networks", params, result)
-            return result
-        except Exception as e:
-            self.log_action("list_networks", params, error=e)
-            raise RuntimeError(f"Failed to list networks: {str(e)}")
-
-    def create_network(self, name: str, driver: str = "bridge") -> Dict:
-        params = {"name": name, "driver": driver}
-        try:
-            network = self.client.networks.create(name, driver=driver)
-            attrs = network.attrs
-            created = attrs.get("Created", "unknown")
-            if isinstance(created, str):
-                created_str = created
-            else:
-                created_str = (
-                    datetime.fromtimestamp(created).strftime("%Y-%m-%dT%H:%M:%S")
-                    if created
-                    else "unknown"
-                )
-            result = {
-                "id": attrs.get("Id", "unknown")[7:19],
-                "name": attrs.get("Name", name),
-                "driver": attrs.get("Driver", driver),
-                "scope": attrs.get("Scope", "unknown"),
-                "created": created_str,
-            }
-            self.log_action("create_network", params, result)
-            return result
-        except Exception as e:
-            self.log_action("create_network", params, error=e)
-            raise RuntimeError(f"Failed to create network: {str(e)}")
-
     def remove_network(self, network_id: str) -> Dict:
         params = {"network_id": network_id}
         try:
@@ -1316,13 +1365,32 @@ class PodmanManager(ContainerManagerBase):
         raise NotImplementedError("Swarm not supported in Podman")
 
 
-# The rest of the file (create_manager, usage, container_manager) remains unchanged
-
-
 def create_manager(
-    manager_type: str, silent: bool = False, log_file: str = None
+    manager_type: Optional[str] = None, silent: bool = False, log_file: str = None
 ) -> ContainerManagerBase:
-    if manager_type.lower() == "docker" or manager_type.lower() == "swarm":
+    if manager_type is None:
+        manager_type = os.environ.get("CONTAINER_MANAGER_TYPE")
+    if manager_type is None:
+        # Autodetect
+        if PodmanClient is not None:
+            try:
+                test_client = PodmanClient()
+                test_client.close()
+                manager_type = "podman"
+            except Exception:
+                pass
+        if manager_type is None and docker is not None:
+            try:
+                test_client = docker.from_env()
+                test_client.close()
+                manager_type = "docker"
+            except Exception:
+                pass
+    if manager_type is None:
+        raise ValueError(
+            "No supported container manager detected. Set CONTAINER_MANAGER_TYPE or install Docker/Podman."
+        )
+    if manager_type.lower() in ["docker", "swarm"]:
         return DockerManager(silent=silent, log_file=log_file)
     elif manager_type.lower() == "podman":
         return PodmanManager(silent=silent, log_file=log_file)
@@ -1338,7 +1406,7 @@ Container Manager: A tool to manage containers with Docker, Podman, and Docker S
 Usage:
 -h | --help            [ See usage for script ]
 -s | --silent          [ Suppress output ]
--m | --manager <type>  [ docker, podman, swarm; default: docker ]
+-m | --manager <type>  [ docker, podman, swarm; default: auto-detect ]
 --log-file <path>      [ Log to specified file (default: container_manager.log in script dir) ]
 
 Actions:
@@ -1403,262 +1471,178 @@ container_manager.py --manager docker --pull-image nginx --tag latest --list-con
 
 
 def container_manager(argv):
-    get_version = False
-    get_info = False
-    list_images = False
-    pull_image = False
-    pull_image_str = None
-    tag = "latest"
-    platform = None
-    remove_image = False
-    remove_image_str = None
-    force = False
-    list_containers = False
-    all_containers = False
-    run_container = False
-    run_image = None
-    name = None
-    command = None
-    detach = False
-    ports_str = None
-    volumes_str = None
-    environment_str = None
-    stop_container = False
-    stop_container_id = None
-    timeout = 10
-    remove_container = False
-    remove_container_id = None
-    get_container_logs = False
-    container_logs_id = None
-    tail = "all"
-    exec_in_container = False
-    exec_container_id = None
-    exec_command = None
-    exec_detach = False
-    list_volumes = False
-    create_volume = False
-    create_volume_name = None
-    remove_volume = False
-    remove_volume_name = None
-    list_networks = False
-    create_network = False
-    create_network_name = None
-    driver = "bridge"
-    remove_network = False
-    remove_network_id = None
-    compose_up = False
-    compose_up_file = None
-    compose_build = False
-    compose_detach = True
-    compose_down = False
-    compose_down_file = None
-    compose_ps = False
-    compose_ps_file = None
-    compose_logs = False
-    compose_logs_file = None
-    compose_service = None
-    init_swarm = False
-    advertise_addr = None
-    leave_swarm = False
-    list_nodes = False
-    list_services = False
-    create_service = False
-    create_service_name = None
-    service_image = None
-    replicas = 1
-    mounts_str = None
-    remove_service = False
-    remove_service_id = None
-    manager_type = "docker"
-    silent = False
-    log_file = None
-
-    try:
-        opts, _ = getopt.getopt(
-            argv,
-            "hsm:",
-            [
-                "help",
-                "silent",
-                "manager=",
-                "log-file=",
-                "get-version",
-                "get-info",
-                "list-images",
-                "pull-image=",
-                "tag=",
-                "platform=",
-                "remove-image=",
-                "force",
-                "list-containers",
-                "all",
-                "run-container=",
-                "name=",
-                "command=",
-                "detach",
-                "ports=",
-                "volumes=",
-                "environment=",
-                "stop-container=",
-                "timeout=",
-                "remove-container=",
-                "get-container-logs=",
-                "tail=",
-                "exec-in-container=",
-                "exec-command=",
-                "exec-detach",
-                "list-volumes",
-                "create-volume=",
-                "remove-volume=",
-                "list-networks",
-                "create-network=",
-                "driver=",
-                "remove-network=",
-                "compose-up=",
-                "build",
-                "compose-down=",
-                "compose-ps=",
-                "compose-logs=",
-                "service=",
-                "init-swarm",
-                "advertise-addr=",
-                "leave-swarm",
-                "list-nodes",
-                "list-services",
-                "create-service=",
-                "image=",
-                "replicas=",
-                "mounts=",
-                "remove-service=",
-            ],
-        )
-    except getopt.GetoptError:
-        usage()
-        sys.exit(2)
+    parser = argparse.ArgumentParser(
+        description="Container Manager: A tool to manage containers with Docker, Podman, and Docker Swarm!"
+    )
+    parser.add_argument("-s", "--silent", action="store_true", help="Suppress output")
+    parser.add_argument(
+        "-m",
+        "--manager",
+        type=str,
+        default=None,
+        help="Container manager type: docker, podman, swarm (default: auto-detect)",
+    )
+    parser.add_argument("--log-file", type=str, default=None, help="Path to log file")
+    parser.add_argument("--get-version", action="store_true", help="Get version info")
+    parser.add_argument("--get-info", action="store_true", help="Get system info")
+    parser.add_argument("--list-images", action="store_true", help="List images")
+    parser.add_argument("--pull-image", type=str, default=None, help="Image to pull")
+    parser.add_argument("--tag", type=str, default="latest", help="Image tag")
+    parser.add_argument("--platform", type=str, default=None, help="Platform")
+    parser.add_argument(
+        "--remove-image", type=str, default=None, help="Image to remove"
+    )
+    parser.add_argument("--force", action="store_true", help="Force removal")
+    parser.add_argument(
+        "--list-containers", action="store_true", help="List containers"
+    )
+    parser.add_argument("--all", action="store_true", help="Show all containers")
+    parser.add_argument("--run-container", type=str, default=None, help="Image to run")
+    parser.add_argument("--name", type=str, default=None, help="Container name")
+    parser.add_argument("--command", type=str, default=None, help="Command to run")
+    parser.add_argument("--detach", action="store_true", help="Detach mode")
+    parser.add_argument("--ports", type=str, default=None, help="Port mappings")
+    parser.add_argument("--volumes", type=str, default=None, help="Volume mappings")
+    parser.add_argument(
+        "--environment", type=str, default=None, help="Environment vars"
+    )
+    parser.add_argument(
+        "--stop-container", type=str, default=None, help="Container to stop"
+    )
+    parser.add_argument("--timeout", type=int, default=10, help="Timeout in seconds")
+    parser.add_argument(
+        "--remove-container", type=str, default=None, help="Container to remove"
+    )
+    parser.add_argument(
+        "--get-container-logs", type=str, default=None, help="Container logs"
+    )
+    parser.add_argument("--tail", type=str, default="all", help="Tail lines")
+    parser.add_argument(
+        "--exec-in-container", type=str, default=None, help="Container to exec"
+    )
+    parser.add_argument("--exec-command", type=str, default=None, help="Exec command")
+    parser.add_argument("--exec-detach", action="store_true", help="Detach exec")
+    parser.add_argument("--list-volumes", action="store_true", help="List volumes")
+    parser.add_argument(
+        "--create-volume", type=str, default=None, help="Volume to create"
+    )
+    parser.add_argument(
+        "--remove-volume", type=str, default=None, help="Volume to remove"
+    )
+    parser.add_argument("--list-networks", action="store_true", help="List networks")
+    parser.add_argument(
+        "--create-network", type=str, default=None, help="Network to create"
+    )
+    parser.add_argument("--driver", type=str, default="bridge", help="Network driver")
+    parser.add_argument(
+        "--remove-network", type=str, default=None, help="Network to remove"
+    )
+    parser.add_argument("--compose-up", type=str, default=None, help="Compose file up")
+    parser.add_argument("--build", action="store_true", help="Build images")
+    parser.add_argument(
+        "--compose-detach", action="store_true", default=True, help="Detach compose"
+    )
+    parser.add_argument(
+        "--compose-down", type=str, default=None, help="Compose file down"
+    )
+    parser.add_argument("--compose-ps", type=str, default=None, help="Compose ps")
+    parser.add_argument("--compose-logs", type=str, default=None, help="Compose logs")
+    parser.add_argument("--service", type=str, default=None, help="Specific service")
+    parser.add_argument("--init-swarm", action="store_true", help="Init swarm")
+    parser.add_argument(
+        "--advertise-addr", type=str, default=None, help="Advertise address"
+    )
+    parser.add_argument("--leave-swarm", action="store_true", help="Leave swarm")
+    parser.add_argument("--list-nodes", action="store_true", help="List swarm nodes")
+    parser.add_argument(
+        "--list-services", action="store_true", help="List swarm services"
+    )
+    parser.add_argument(
+        "--create-service", type=str, default=None, help="Service to create"
+    )
+    parser.add_argument("--image", type=str, default=None, help="Service image")
+    parser.add_argument("--replicas", type=int, default=1, help="Replicas")
+    parser.add_argument("--mounts", type=str, default=None, help="Mounts")
+    parser.add_argument(
+        "--remove-service", type=str, default=None, help="Service to remove"
+    )
+    parser.add_argument("-h", "--help", action="store_true", help="Show help")
+
+    args = parser.parse_args(argv)
 
-    for opt, arg in opts:
-        if opt in ("-h", "--help"):
-            usage()
-            sys.exit()
-        elif opt in ("-s", "--silent"):
-            silent = True
-        elif opt in ("-m", "--manager"):
-            manager_type = arg
-        elif opt == "--log-file":
-            log_file = arg
-        elif opt == "--get-version":
-            get_version = True
-        elif opt == "--get-info":
-            get_info = True
-        elif opt == "--list-images":
-            list_images = True
-        elif opt == "--pull-image":
-            pull_image = True
-            pull_image_str = arg
-        elif opt == "--tag":
-            tag = arg
-        elif opt == "--platform":
-            platform = arg
-        elif opt == "--remove-image":
-            remove_image = True
-            remove_image_str = arg
-        elif opt == "--force":
-            force = True
-        elif opt == "--list-containers":
-            list_containers = True
-        elif opt == "--all":
-            all_containers = True
-        elif opt == "--run-container":
-            run_container = True
-            run_image = arg
-        elif opt == "--name":
-            name = arg
-        elif opt == "--command":
-            command = arg
-        elif opt == "--detach":
-            detach = True
-        elif opt == "--ports":
-            ports_str = arg
-        elif opt == "--volumes":
-            volumes_str = arg
-        elif opt == "--environment":
-            environment_str = arg
-        elif opt == "--stop-container":
-            stop_container = True
-            stop_container_id = arg
-        elif opt == "--timeout":
-            timeout = int(arg)
-        elif opt == "--remove-container":
-            remove_container = True
-            remove_container_id = arg
-        elif opt == "--get-container-logs":
-            get_container_logs = True
-            container_logs_id = arg
-        elif opt == "--tail":
-            tail = arg
-        elif opt == "--exec-in-container":
-            exec_in_container = True
-            exec_container_id = arg
-        elif opt == "--exec-command":
-            exec_command = arg
-        elif opt == "--exec-detach":
-            exec_detach = True
-        elif opt == "--list-volumes":
-            list_volumes = True
-        elif opt == "--create-volume":
-            create_volume = True
-            create_volume_name = arg
-        elif opt == "--remove-volume":
-            remove_volume = True
-            remove_volume_name = arg
-        elif opt == "--list-networks":
-            list_networks = True
-        elif opt == "--create-network":
-            create_network = True
-            create_network_name = arg
-        elif opt == "--driver":
-            driver = arg
-        elif opt == "--remove-network":
-            remove_network = True
-            remove_network_id = arg
-        elif opt == "--compose-up":
-            compose_up = True
-            compose_up_file = arg
-        elif opt == "--build":
-            compose_build = True
-        elif opt == "--compose-down":
-            compose_down = True
-            compose_down_file = arg
-        elif opt == "--compose-ps":
-            compose_ps = True
-            compose_ps_file = arg
-        elif opt == "--compose-logs":
-            compose_logs = True
-            compose_logs_file = arg
-        elif opt == "--service":
-            compose_service = arg
-        elif opt == "--init-swarm":
-            init_swarm = True
-        elif opt == "--advertise-addr":
-            advertise_addr = arg
-        elif opt == "--leave-swarm":
-            leave_swarm = True
-        elif opt == "--list-nodes":
-            list_nodes = True
-        elif opt == "--list-services":
-            list_services = True
-        elif opt == "--create-service":
-            create_service = True
-            create_service_name = arg
-        elif opt == "--image":
-            service_image = arg
-        elif opt == "--replicas":
-            replicas = int(arg)
-        elif opt == "--mounts":
-            mounts_str = arg
-        elif opt == "--remove-service":
-            remove_service = True
-            remove_service_id = arg
+    if args.help:
+        usage()
+        sys.exit(0)
+
+    get_version = args.get_version
+    get_info = args.get_info
+    list_images = args.list_images
+    pull_image = args.pull_image is not None
+    pull_image_str = args.pull_image
+    tag = args.tag
+    platform = args.platform
+    remove_image = args.remove_image is not None
+    remove_image_str = args.remove_image
+    force = args.force
+    list_containers = args.list_containers
+    all_containers = args.all
+    run_container = args.run_container is not None
+    run_image = args.run_container
+    name = args.name
+    command = args.command
+    detach = args.detach
+    ports_str = args.ports
+    volumes_str = args.volumes
+    environment_str = args.environment
+    stop_container = args.stop_container is not None
+    stop_container_id = args.stop_container
+    timeout = args.timeout
+    remove_container = args.remove_container is not None
+    remove_container_id = args.remove_container
+    get_container_logs = args.get_container_logs is not None
+    container_logs_id = args.get_container_logs
+    tail = args.tail
+    exec_in_container = args.exec_in_container is not None
+    exec_container_id = args.exec_in_container
+    exec_command = args.exec_command
+    exec_detach = args.exec_detach
+    list_volumes = args.list_volumes
+    create_volume = args.create_volume is not None
+    create_volume_name = args.create_volume
+    remove_volume = args.remove_volume is not None
+    remove_volume_name = args.remove_volume
+    list_networks = args.list_networks
+    create_network = args.create_network is not None
+    create_network_name = args.create_network
+    driver = args.driver
+    remove_network = args.remove_network is not None
+    remove_network_id = args.remove_network
+    compose_up = args.compose_up is not None
+    compose_up_file = args.compose_up
+    compose_build = args.build
+    compose_detach = args.compose_detach
+    compose_down = args.compose_down is not None
+    compose_down_file = args.compose_down
+    compose_ps = args.compose_ps is not None
+    compose_ps_file = args.compose_ps
+    compose_logs = args.compose_logs is not None
+    compose_logs_file = args.compose_logs
+    compose_service = args.service
+    init_swarm = args.init_swarm
+    advertise_addr = args.advertise_addr
+    leave_swarm = args.leave_swarm
+    list_nodes = args.list_nodes
+    list_services = args.list_services
+    create_service = args.create_service is not None
+    create_service_name = args.create_service
+    service_image = args.image
+    replicas = args.replicas
+    mounts_str = args.mounts
+    remove_service = args.remove_service is not None
+    remove_service_id = args.remove_service
+    manager_type = args.manager
+    silent = args.silent
+    log_file = args.log_file
 
     manager = create_manager(manager_type, silent, log_file)