container-manager-mcp 0.0.4__py3-none-any.whl → 1.2.0__py3-none-any.whl

container_manager_mcp/container_manager.py

@@ -6,9 +6,13 @@ import logging
 import os
 from abc import ABC, abstractmethod
 from typing import List, Dict, Optional, Any
-import getopt
+import argparse
 import json
+import shutil
 import subprocess
+from datetime import datetime
+import platform
+import traceback
 
 try:
     import docker
@@ -26,6 +30,7 @@ except ImportError:
 
 
 class ContainerManagerBase(ABC):
+
     def __init__(self, silent: bool = False, log_file: str = None):
         self.silent = silent
         self.setup_logging(log_file)
@@ -36,7 +41,7 @@ class ContainerManagerBase(ABC):
             log_file = os.path.join(script_dir, "container_manager.log")
         logging.basicConfig(
             filename=log_file,
-            level=logging.INFO,
+            level=logging.DEBUG,  # Changed to DEBUG for more detailed logging
             format="%(asctime)s - %(levelname)s - %(message)s",
         )
         self.logger = logging.getLogger(__name__)
@@ -53,7 +58,55 @@ class ContainerManagerBase(ABC):
         if result:
             self.logger.info(f"Result: {result}")
         if error:
-            self.logger.error(f"Error: {str(error)}")
+            self.logger.error(
+                f"Error in {action}: {type(error).__name__}: {str(error)}"
+            )
+            self.logger.error(f"Traceback: {traceback.format_exc()}")
+
+    def _format_size(self, size_bytes: int) -> str:
+        """Helper to format bytes to human-readable (e.g., 1.23GB)."""
+        for unit in ["B", "KB", "MB", "GB", "TB"]:
+            if size_bytes < 1024.0:
+                return (
+                    f"{size_bytes:.2f}{unit}" if unit != "B" else f"{size_bytes}{unit}"
+                )
+            size_bytes /= 1024.0
+        return f"{size_bytes:.2f}PB"
+
+    def _parse_timestamp(self, timestamp: Any) -> str:
+        """Parse timestamp (integer, float, or string) to ISO 8601 string."""
+        if not timestamp:
+            return "unknown"
+
+        # Handle numeric timestamps (Unix timestamps in seconds)
+        if isinstance(timestamp, (int, float)):
+            try:
+                return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%dT%H:%M:%S")
+            except (ValueError, OSError):
+                return "unknown"
+
+        # Handle string timestamps
+        if isinstance(timestamp, str):
+            # Common ISO 8601-like formats to try
+            formats = [
+                "%Y-%m-%dT%H:%M:%S",  # 2023-10-05T14:30:00
+                "%Y-%m-%d %H:%M:%S",  # 2023-10-05 14:30:00
+                "%Y-%m-%dT%H:%M:%S%z",  # 2023-10-05T14:30:00+0000
+                "%Y-%m-%d %H:%M:%S%z",  # 2023-10-05 14:30:00+0000
+                "%Y-%m-%dT%H:%M:%S.%f",  # 2023-10-05T14:30:00.123456
+                "%Y-%m-%d %H:%M:%S.%f",  # 2023-10-05 14:30:00.123456
+                "%Y-%m-%dT%H:%M:%S.%f%z",  # 2023-10-05T14:30:00.123456+0000
+                "%Y-%m-%d",  # 2023-10-05
+            ]
+            for fmt in formats:
+                try:
+                    parsed = datetime.strptime(timestamp, fmt)
+                    return parsed.strftime("%Y-%m-%dT%H:%M:%S")
+                except ValueError:
+                    continue
+            return "unknown"
+
+        return "unknown"
 
     @abstractmethod
     def get_version(self) -> Dict:
@@ -77,6 +130,10 @@ class ContainerManagerBase(ABC):
     def remove_image(self, image: str, force: bool = False) -> Dict:
         pass
 
+    @abstractmethod
+    def prune_images(self, force: bool = False, all: bool = False) -> Dict:
+        pass
+
     @abstractmethod
     def list_containers(self, all: bool = False) -> List[Dict]:
         pass
@@ -102,6 +159,10 @@ class ContainerManagerBase(ABC):
     def remove_container(self, container_id: str, force: bool = False) -> Dict:
         pass
 
+    @abstractmethod
+    def prune_containers(self) -> Dict:
+        pass
+
     @abstractmethod
     def get_container_logs(self, container_id: str, tail: str = "all") -> str:
         pass
@@ -124,6 +185,10 @@ class ContainerManagerBase(ABC):
     def remove_volume(self, name: str, force: bool = False) -> Dict:
         pass
 
+    @abstractmethod
+    def prune_volumes(self, force: bool = False, all: bool = False) -> Dict:
+        pass
+
     @abstractmethod
     def list_networks(self) -> List[Dict]:
         pass
@@ -136,7 +201,14 @@ class ContainerManagerBase(ABC):
     def remove_network(self, network_id: str) -> Dict:
         pass
 
-    # Compose methods
+    @abstractmethod
+    def prune_networks(self) -> Dict:
+        pass
+
+    @abstractmethod
+    def prune_system(self, force: bool = False, all: bool = False) -> Dict:
+        pass
+
     @abstractmethod
     def compose_up(
         self, compose_file: str, detach: bool = True, build: bool = False
@@ -155,19 +227,23 @@ class ContainerManagerBase(ABC):
     def compose_logs(self, compose_file: str, service: Optional[str] = None) -> str:
         pass
 
-    # Swarm methods (to be implemented only in DockerManager)
+    @abstractmethod
     def init_swarm(self, advertise_addr: Optional[str] = None) -> Dict:
-        raise NotImplementedError("Swarm not supported")
+        pass
 
+    @abstractmethod
     def leave_swarm(self, force: bool = False) -> Dict:
-        raise NotImplementedError("Swarm not supported")
+        pass
 
+    @abstractmethod
     def list_nodes(self) -> List[Dict]:
-        raise NotImplementedError("Swarm not supported")
+        pass
 
+    @abstractmethod
     def list_services(self) -> List[Dict]:
-        raise NotImplementedError("Swarm not supported")
+        pass
 
+    @abstractmethod
     def create_service(
         self,
         name: str,
@@ -176,10 +252,11 @@ class ContainerManagerBase(ABC):
         ports: Optional[Dict[str, str]] = None,
         mounts: Optional[List[str]] = None,
     ) -> Dict:
-        raise NotImplementedError("Swarm not supported")
+        pass
 
+    @abstractmethod
     def remove_service(self, service_id: str) -> Dict:
-        raise NotImplementedError("Swarm not supported")
+        pass
 
 
 class DockerManager(ContainerManagerBase):
@@ -193,10 +270,53 @@ 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 prune_system(self, force: bool = False, all: bool = False) -> Dict:
+        params = {"force": force, "all": all}
+        try:
+            filters = {"until": None} if all else {}
+            result = self.client.system.prune(filters=filters, volumes=all)
+            if result is None:
+                result = {
+                    "SpaceReclaimed": 0,
+                    "ImagesDeleted": [],
+                    "ContainersDeleted": [],
+                    "VolumesDeleted": [],
+                    "NetworksDeleted": [],
+                }
+            self.logger.debug(f"Raw prune_system result: {result}")
+            pruned = {
+                "space_reclaimed": self._format_size(result.get("SpaceReclaimed", 0)),
+                "images_removed": (
+                    [img["Id"][7:19] for img in result.get("ImagesDeleted", [])]
+                ),
+                "containers_removed": (
+                    [c["Id"][7:19] for c in result.get("ContainersDeleted", [])]
+                ),
+                "volumes_removed": (
+                    [v["Name"] for v in result.get("VolumesDeleted", [])]
+                ),
+                "networks_removed": (
+                    [n["Id"][7:19] for n in result.get("NetworksDeleted", [])]
+                ),
+            }
+            self.log_action("prune_system", params, pruned)
+            return pruned
+        except Exception as e:
+            self.log_action("prune_system", params, error=e)
+            raise RuntimeError(f"Failed to prune system: {str(e)}")
+
+    # Other DockerManager methods remain unchanged (omitted for brevity)
     def get_version(self) -> Dict:
         params = {}
         try:
-            result = self.client.version()
+            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:
@@ -206,7 +326,16 @@ class DockerManager(ContainerManagerBase):
     def get_info(self) -> Dict:
         params = {}
         try:
-            result = self.client.info()
+            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:
@@ -217,7 +346,34 @@ class DockerManager(ContainerManagerBase):
         params = {}
         try:
             images = self.client.images.list()
-            result = [img.attrs for img in images]
+            result = []
+            for img in images:
+                attrs = img.attrs
+                repo_tags = attrs.get("RepoTags", [])
+                repo_tag = repo_tags[0] if repo_tags else "<none>:<none>"
+                repository, tag = (
+                    repo_tag.rsplit(":", 1) if ":" in repo_tag else ("<none>", "<none>")
+                )
+
+                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 = {
+                    "repository": repository,
+                    "tag": tag,
+                    "id": (
+                        attrs.get("Id", "unknown")[7:19]
+                        if attrs.get("Id")
+                        else "unknown"
+                    ),
+                    "created": created_str,
+                    "size": size_str,
+                }
+                result.append(simplified)
+
             self.log_action("list_images", params, result)
             return result
         except Exception as e:
@@ -230,7 +386,25 @@ class DockerManager(ContainerManagerBase):
         params = {"image": image, "tag": tag, "platform": platform}
         try:
             img = self.client.images.pull(f"{image}:{tag}", platform=platform)
-            result = img.attrs
+            attrs = img.attrs
+            repo_tags = attrs.get("RepoTags", [])
+            repo_tag = repo_tags[0] if repo_tags else f"{image}:{tag}"
+            repository, tag = (
+                repo_tag.rsplit(":", 1) if ":" in repo_tag else (image, tag)
+            )
+            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 = {
+                "repository": repository,
+                "tag": tag,
+                "id": (
+                    attrs.get("Id", "unknown")[7:19] if attrs.get("Id") else "unknown"
+                ),
+                "created": created_str,
+                "size": size_str,
+            }
             self.log_action("pull_image", params, result)
             return result
         except Exception as e:
@@ -248,11 +422,74 @@ class DockerManager(ContainerManagerBase):
             self.log_action("remove_image", params, error=e)
             raise RuntimeError(f"Failed to remove image: {str(e)}")
 
+    def prune_images(self, force: bool = False, all: bool = False) -> Dict:
+        params = {"force": force, "all": all}
+        try:
+            if all:
+                # Manually remove all unused images
+                images = self.client.images.list(all=True)
+                removed = []
+                for img in images:
+                    try:
+                        for tag in img.attrs.get("RepoTags", []):
+                            self.client.images.remove(tag, force=force)
+                            removed.append(img.attrs["Id"][7:19])
+                    except Exception as e:
+                        self.logger.info(
+                            f"Info: Failed to remove image {img.attrs.get('Id', 'unknown')}: {e}"
+                        )
+                        continue
+                result = {
+                    "images_removed": removed,
+                    "space_reclaimed": "N/A (all images)",
+                }
+            else:
+                filters = {"dangling": True} if not all else {}
+                result = self.client.images.prune(filters=filters)
+                if result is None:
+                    result = {"SpaceReclaimed": 0, "ImagesDeleted": []}
+                self.logger.debug(f"Raw prune_images result: {result}")
+                pruned = {
+                    "space_reclaimed": self._format_size(
+                        result.get("SpaceReclaimed", 0)
+                    ),
+                    "images_removed": (
+                        [img["Id"][7:19] for img in result.get("ImagesDeleted", [])]
+                    ),
+                }
+                result = pruned
+            self.log_action("prune_images", params, result)
+            return result
+        except Exception as e:
+            self.log_action("prune_images", params, error=e)
+            raise RuntimeError(f"Failed to prune images: {str(e)}")
+
     def list_containers(self, all: bool = False) -> List[Dict]:
         params = {"all": all}
         try:
             containers = self.client.containers.list(all=all)
-            result = [c.attrs for c in containers]
+            result = []
+            for c in containers:
+                attrs = c.attrs
+                ports = attrs.get("NetworkSettings", {}).get("Ports", {})
+                port_mappings = []
+                for container_port, host_ports in ports.items():
+                    if host_ports:
+                        for hp in host_ports:
+                            port_mappings.append(
+                                f"{hp.get('HostIp', '0.0.0.0')}:{hp.get('HostPort')}->{container_port}"
+                            )
+                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"),
+                    "name": attrs.get("Name", "unknown").lstrip("/"),
+                    "status": attrs.get("State", {}).get("Status", "unknown"),
+                    "ports": ", ".join(port_mappings) if port_mappings else "none",
+                    "created": created_str,
+                }
+                result.append(simplified)
             self.log_action("list_containers", params, result)
             return result
         except Exception as e:
@@ -280,7 +517,7 @@ class DockerManager(ContainerManagerBase):
         }
         try:
             container = self.client.containers.run(
-                image,
+                image=image,
                 command=command,
                 name=name,
                 detach=detach,
@@ -288,9 +525,32 @@ class DockerManager(ContainerManagerBase):
                 volumes=volumes,
                 environment=environment,
             )
-            result = (
-                container.attrs if detach else {"output": container.decode("utf-8")}
-            )
+            if not detach:
+                result = {"output": container.decode("utf-8") if container else ""}
+                self.log_action("run_container", params, result)
+                return result
+            attrs = container.attrs
+            port_mappings = []
+            if ports:  # Check if ports is not None
+                network_settings = attrs.get("NetworkSettings", {})
+                container_ports = network_settings.get("Ports", {})
+                if container_ports:  # Check if Ports dictionary is not empty
+                    for container_port, host_ports in container_ports.items():
+                        if host_ports:  # Check if host_ports is not None or empty
+                            for hp in host_ports:
+                                port_mappings.append(
+                                    f"{hp.get('HostIp', '0.0.0.0')}:{hp.get('HostPort')}->{container_port}"
+                                )
+            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),
+                "name": attrs.get("Name", name or "unknown").lstrip("/"),
+                "status": attrs.get("State", {}).get("Status", "unknown"),
+                "ports": ", ".join(port_mappings) if port_mappings else "none",
+                "created": created_str,
+            }
             self.log_action("run_container", params, result)
             return result
         except Exception as e:
@@ -321,12 +581,42 @@ class DockerManager(ContainerManagerBase):
             self.log_action("remove_container", params, error=e)
             raise RuntimeError(f"Failed to remove container: {str(e)}")
 
+    def prune_containers(self) -> Dict:
+        params = {}
+        try:
+            result = self.client.containers.prune()
+            self.logger.debug(f"Raw prune_containers result: {result}")
+            if result is None:
+                result = {"SpaceReclaimed": 0, "ContainersDeleted": []}
+            pruned = {
+                "space_reclaimed": self._format_size(result.get("SpaceReclaimed", 0)),
+                "containers_removed": (
+                    [c["Id"][7:19] for c in result.get("ContainersDeleted", [])]
+                ),
+            }
+            self.log_action("prune_containers", params, pruned)
+            return pruned
+        except TypeError as e:
+            self.logger.error(f"TypeError in prune_containers: {str(e)}")
+            self.logger.error(f"Traceback: {traceback.format_exc()}")
+            self.log_action("prune_containers", params, error=e)
+            raise RuntimeError(f"Failed to prune containers: {str(e)}")
+        except Exception as e:
+            self.logger.error(
+                f"Unexpected exception in prune_containers: {type(e).__name__}: {str(e)}"
+            )
+            self.logger.error(f"Traceback: {traceback.format_exc()}")
+            self.log_action("prune_containers", params, error=e)
+            raise RuntimeError(f"Failed to prune containers: {str(e)}")
+
     def get_container_logs(self, container_id: str, tail: str = "all") -> str:
         params = {"container_id": container_id, "tail": tail}
         try:
             container = self.client.containers.get(container_id)
             logs = container.logs(tail=tail).decode("utf-8")
-            self.log_action("get_container_logs", params, logs)
+            self.log_action(
+                "get_container_logs", params, logs[:1000]
+            )  # Truncate for logging
             return logs
         except Exception as e:
             self.log_action("get_container_logs", params, error=e)
@@ -341,7 +631,8 @@ class DockerManager(ContainerManagerBase):
             exit_code, output = container.exec_run(command, detach=detach)
             result = {
                 "exit_code": exit_code,
-                "output": output.decode("utf-8") if output else None,
+                "output": output.decode("utf-8") if output and not detach else None,
+                "command": command,
             }
             self.log_action("exec_in_container", params, result)
             return result
@@ -353,7 +644,17 @@ class DockerManager(ContainerManagerBase):
         params = {}
         try:
             volumes = self.client.volumes.list()
-            result = {"volumes": [v.attrs for v in volumes]}
+            result = {
+                "volumes": [
+                    {
+                        "name": v.attrs.get("Name", "unknown"),
+                        "driver": v.attrs.get("Driver", "unknown"),
+                        "mountpoint": v.attrs.get("Mountpoint", "unknown"),
+                        "created": v.attrs.get("CreatedAt", "unknown"),
+                    }
+                    for v in volumes
+                ]
+            }
             self.log_action("list_volumes", params, result)
             return result
         except Exception as e:
@@ -364,7 +665,13 @@ class DockerManager(ContainerManagerBase):
         params = {"name": name}
         try:
             volume = self.client.volumes.create(name=name)
-            result = volume.attrs
+            attrs = volume.attrs
+            result = {
+                "name": attrs.get("Name", name),
+                "driver": attrs.get("Driver", "unknown"),
+                "mountpoint": attrs.get("Mountpoint", "unknown"),
+                "created": attrs.get("CreatedAt", "unknown"),
+            }
             self.log_action("create_volume", params, result)
             return result
         except Exception as e:
@@ -383,11 +690,64 @@ class DockerManager(ContainerManagerBase):
             self.log_action("remove_volume", params, error=e)
             raise RuntimeError(f"Failed to remove volume: {str(e)}")
 
+    def prune_volumes(self, force: bool = False, all: bool = False) -> Dict:
+        params = {"force": force, "all": all}
+        try:
+            if all:
+                volumes = self.client.volumes.list(all=True)
+                removed = []
+                for v in volumes:
+                    try:
+                        v.remove(force=force)
+                        removed.append(v.attrs["Name"])
+                    except Exception as e:
+                        self.logger.info(
+                            f"Info: Failed to remove volume {v.attrs.get('Name', 'unknown')}: {e}"
+                        )
+                        continue
+                result = {
+                    "volumes_removed": removed,
+                    "space_reclaimed": "N/A (all volumes)",
+                }
+            else:
+                result = self.client.volumes.prune()
+                if result is None:
+                    result = {"SpaceReclaimed": 0, "VolumesDeleted": []}
+                self.logger.debug(f"Raw prune_volumes result: {result}")
+                pruned = {
+                    "space_reclaimed": self._format_size(
+                        result.get("SpaceReclaimed", 0)
+                    ),
+                    "volumes_removed": (
+                        [v["Name"] for v in result.get("VolumesDeleted", [])]
+                    ),
+                }
+                result = pruned
+            self.log_action("prune_volumes", params, result)
+            return result
+        except Exception as e:
+            self.log_action("prune_volumes", params, error=e)
+            raise RuntimeError(f"Failed to prune volumes: {str(e)}")
+
     def list_networks(self) -> List[Dict]:
         params = {}
         try:
             networks = self.client.networks.list()
-            result = [net.attrs for net in networks]
+            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:
@@ -398,7 +758,16 @@ class DockerManager(ContainerManagerBase):
         params = {"name": name, "driver": driver}
         try:
             network = self.client.networks.create(name, driver=driver)
-            result = network.attrs
+            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:
@@ -417,6 +786,25 @@ class DockerManager(ContainerManagerBase):
             self.log_action("remove_network", params, error=e)
             raise RuntimeError(f"Failed to remove network: {str(e)}")
 
+    def prune_networks(self) -> Dict:
+        params = {}
+        try:
+            result = self.client.networks.prune()
+            if result is None:
+                result = {"SpaceReclaimed": 0, "NetworksDeleted": []}
+            self.logger.debug(f"Raw prune_networks result: {result}")
+            pruned = {
+                "space_reclaimed": self._format_size(result.get("SpaceReclaimed", 0)),
+                "networks_removed": (
+                    [n["Id"][7:19] for n in result.get("NetworksDeleted", [])]
+                ),
+            }
+            self.log_action("prune_networks", params, pruned)
+            return pruned
+        except Exception as e:
+            self.log_action("prune_networks", params, error=e)
+            raise RuntimeError(f"Failed to prune networks: {str(e)}")
+
     def compose_up(
         self, compose_file: str, detach: bool = True, build: bool = False
     ) -> str:
@@ -503,7 +891,23 @@ class DockerManager(ContainerManagerBase):
         params = {}
         try:
             nodes = self.client.nodes.list()
-            result = [node.attrs for node in nodes]
+            result = []
+            for node in nodes:
+                attrs = node.attrs
+                spec = attrs.get("Spec", {})
+                status = attrs.get("Status", {})
+                created = attrs.get("CreatedAt", "unknown")
+                updated = attrs.get("UpdatedAt", "unknown")
+                simplified = {
+                    "id": attrs.get("ID", "unknown")[7:19],
+                    "hostname": spec.get("Name", "unknown"),
+                    "role": spec.get("Role", "unknown"),
+                    "status": status.get("State", "unknown"),
+                    "availability": spec.get("Availability", "unknown"),
+                    "created": created,
+                    "updated": updated,
+                }
+                result.append(simplified)
             self.log_action("list_nodes", params, result)
             return result
         except Exception as e:
@@ -514,7 +918,33 @@ class DockerManager(ContainerManagerBase):
         params = {}
         try:
             services = self.client.services.list()
-            result = [service.attrs for service in services]
+            result = []
+            for service in services:
+                attrs = service.attrs
+                spec = attrs.get("Spec", {})
+                endpoint = attrs.get("Endpoint", {})
+                ports = endpoint.get("Ports", [])
+                port_mappings = [
+                    f"{p.get('PublishedPort')}->{p.get('TargetPort')}/{p.get('Protocol')}"
+                    for p in ports
+                    if p.get("PublishedPort")
+                ]
+                created = attrs.get("CreatedAt", "unknown")
+                updated = attrs.get("UpdatedAt", "unknown")
+                simplified = {
+                    "id": attrs.get("ID", "unknown")[7:19],
+                    "name": spec.get("Name", "unknown"),
+                    "image": spec.get("TaskTemplate", {})
+                    .get("ContainerSpec", {})
+                    .get("Image", "unknown"),
+                    "replicas": spec.get("Mode", {})
+                    .get("Replicated", {})
+                    .get("Replicas", 0),
+                    "ports": ", ".join(port_mappings) if port_mappings else "none",
+                    "created": created,
+                    "updated": updated,
+                }
+                result.append(simplified)
             self.log_action("list_services", params, result)
             return result
         except Exception as e:
@@ -538,15 +968,46 @@ class DockerManager(ContainerManagerBase):
         }
         try:
             mode = {"mode": "replicated", "replicas": replicas}
-            target_ports = [docker.types.EndpointSpec(ports=ports)] if ports else None
+            endpoint_spec = None
+            if ports:
+                port_list = [
+                    {
+                        "Protocol": "tcp",
+                        "PublishedPort": int(host_port),
+                        "TargetPort": int(container_port.split("/")[0]),
+                    }
+                    for container_port, host_port in ports.items()
+                ]
+                endpoint_spec = docker.types.EndpointSpec(ports=port_list)
             service = self.client.services.create(
                 image,
                 name=name,
                 mode=mode,
                 mounts=mounts,
-                endpoint_spec=target_ports[0] if target_ports else None,
+                endpoint_spec=endpoint_spec,
             )
-            result = service.attrs
+            attrs = service.attrs
+            spec = attrs.get("Spec", {})
+            endpoint = attrs.get("Endpoint", {})
+            ports = endpoint.get("Ports", [])
+            port_mappings = [
+                f"{p.get('PublishedPort')}->{p.get('TargetPort')}/{p.get('Protocol')}"
+                for p in ports
+                if p.get("PublishedPort")
+            ]
+            created = attrs.get("CreatedAt", "unknown")
+            result = {
+                "id": attrs.get("ID", "unknown")[7:19],
+                "name": spec.get("Name", name),
+                "image": spec.get("TaskTemplate", {})
+                .get("ContainerSpec", {})
+                .get("Image", image),
+                "replicas": spec.get("Mode", {})
+                .get("Replicated", {})
+                .get("Replicas", replicas),
+                "ports": ", ".join(port_mappings) if port_mappings else "none",
+                "created": created,
+            }
             self.log_action("create_service", params, result)
             return result
         except Exception as e:
@@ -567,20 +1028,268 @@ 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(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 with {base_url}: {str(e)}"
+            )
+            raise RuntimeError(f"Failed to connect to Podman with {base_url}: {str(e)}")
+
+    def _is_wsl(self) -> bool:
+        """Check if running inside WSL2."""
+        try:
+            with open("/proc/version", "r") as f:
+                return "WSL" in f.read()
+        except FileNotFoundError:
+            return "WSL_DISTRO_NAME" in os.environ
+
+    def _is_podman_machine_running(self) -> bool:
+        """Check if Podman machine is running (for Windows/WSL2)."""
+        try:
+            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:
-            self.client = PodmanClient()
+            client = PodmanClient(base_url=base_url)
+            client.version()
+            return client
         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.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."""
+        base_url = os.environ.get("CONTAINER_MANAGER_PODMAN_BASE_URL")
+        if base_url:
+            self.logger.info(
+                f"Using CONTAINER_MANAGER_PODMAN_BASE_URL from environment: {base_url}"
+            )
+            return base_url
+        system = platform.system()
+        is_wsl = self._is_wsl()
+        socket_candidates = []
+        if system == "Windows" and not is_wsl:
+            if not self._is_podman_machine_running():
+                raise RuntimeError("Podman Machine is not running on Windows system")
+            socket_candidates.extend(
+                [
+                    "tcp://127.0.0.1:8080",
+                    "unix:///run/podman/podman.sock",
+                    "npipe:////./pipe/docker_engine",
+                    "unix:///mnt/wsl/podman-sockets/podman-machine-default/podman-user.sock",
+                    "unix:///mnt/wsl/podman-sockets/podman-machine-default/podman-root.sock",
+                ]
+            )
+        elif system == "Linux" or is_wsl:
+            uid = os.getuid()
+            socket_candidates.extend(
+                [
+                    f"unix:///run/user/{uid}/podman/podman.sock",
+                    "unix:///run/podman/podman.sock",
+                    "unix:///mnt/wsl/podman-sockets/podman-machine-default/podman-user.sock",
+                    "unix:///mnt/wsl/podman-sockets/podman-machine-default/podman-root.sock",
+                ]
+            )
+        for url in socket_candidates:
+            client = self._try_connect(url)
+            if client:
+                return url
+        return None
+
+    def prune_images(self, force: bool = False, all: bool = False) -> Dict:
+        params = {"force": force, "all": all}
+        try:
+            if all:
+                # Manually remove all unused images
+                images = self.client.images.list(all=True)
+                removed = []
+                for img in images:
+                    try:
+                        for tag in img.attrs.get("Names", []):
+                            self.client.images.remove(tag, force=force)
+                            removed.append(img.attrs["Id"][7:19])
+                    except Exception as e:
+                        self.logger.info(
+                            f"Info: Failed to remove image {img.attrs.get('Id', 'unknown')}: {e}"
+                        )
+                        continue
+                result = {
+                    "images_removed": removed,
+                    "space_reclaimed": "N/A (all images)",
+                }
+            else:
+                filters = {"dangling": True} if not all else {}
+                result = self.client.images.prune(filters=filters)
+                if result is None:
+                    result = {"SpaceReclaimed": 0, "ImagesRemoved": []}
+                self.logger.debug(f"Raw prune_images result: {result}")
+                pruned = {
+                    "space_reclaimed": self._format_size(
+                        result.get("SpaceReclaimed", 0)
+                    ),
+                    "images_removed": (
+                        [img["Id"][7:19] for img in result.get("ImagesRemoved", [])]
+                        or [img["Id"][7:19] for img in result.get("ImagesDeleted", [])]
+                    ),
+                }
+                result = pruned
+            self.log_action("prune_images", params, result)
+            return result
+        except Exception as e:
+            self.log_action("prune_images", params, error=e)
+            raise RuntimeError(f"Failed to prune images: {str(e)}")
+
+    def prune_containers(self) -> Dict:
+        params = {}
+        try:
+            result = self.client.containers.prune()
+            self.logger.debug(f"Raw prune_containers result: {result}")
+            if result is None:
+                result = {"SpaceReclaimed": 0, "ContainersDeleted": []}
+            pruned = {
+                "space_reclaimed": self._format_size(result.get("SpaceReclaimed", 0)),
+                "containers_removed": (
+                    [c["Id"][7:19] for c in result.get("ContainersDeleted", [])]
+                    or [c["Id"][7:19] for c in result.get("ContainersRemoved", [])]
+                ),
+            }
+            self.log_action("prune_containers", params, pruned)
+            return pruned
+        except PodmanError as e:
+            self.logger.error(f"PodmanError in prune_containers: {str(e)}")
+            self.logger.error(f"Traceback: {traceback.format_exc()}")
+            self.log_action("prune_containers", params, error=e)
+            raise RuntimeError(f"Failed to prune containers: {str(e)}")
+        except Exception as e:
+            self.logger.error(
+                f"Unexpected exception in prune_containers: {type(e).__name__}: {str(e)}"
+            )
+            self.logger.error(f"Traceback: {traceback.format_exc()}")
+            self.log_action("prune_containers", params, error=e)
+            raise RuntimeError(f"Failed to prune containers: {str(e)}")
+
+    def prune_volumes(self, force: bool = False, all: bool = False) -> Dict:
+        params = {"force": force, "all": all}
+        try:
+            if all:
+                volumes = self.client.volumes.list(all=True)
+                removed = []
+                for v in volumes:
+                    try:
+                        v.remove(force=force)
+                        removed.append(v.attrs["Name"])
+                    except Exception as e:
+                        self.logger.info(
+                            f"Info: Failed to remove volume {v.attrs.get('Name', 'unknown')}: {e}"
+                        )
+                        continue
+                result = {
+                    "volumes_removed": removed,
+                    "space_reclaimed": "N/A (all volumes)",
+                }
+            else:
+                result = self.client.volumes.prune()
+                if result is None:
+                    result = {"SpaceReclaimed": 0, "VolumesRemoved": []}
+                self.logger.debug(f"Raw prune_volumes result: {result}")
+                pruned = {
+                    "space_reclaimed": self._format_size(
+                        result.get("SpaceReclaimed", 0)
+                    ),
+                    "volumes_removed": (
+                        [v["Name"] for v in result.get("VolumesRemoved", [])]
+                        or [v["Name"] for v in result.get("VolumesDeleted", [])]
+                    ),
+                }
+                result = pruned
+            self.log_action("prune_volumes", params, result)
+            return result
+        except Exception as e:
+            self.log_action("prune_volumes", params, error=e)
+            raise RuntimeError(f"Failed to prune volumes: {str(e)}")
+
+    def prune_networks(self) -> Dict:
+        params = {}
+        try:
+            result = self.client.networks.prune()
+            if result is None:
+                result = {"SpaceReclaimed": 0, "NetworksRemoved": []}
+            self.logger.debug(f"Raw prune_networks result: {result}")
+            pruned = {
+                "space_reclaimed": self._format_size(result.get("SpaceReclaimed", 0)),
+                "networks_removed": (
+                    [n["Id"][7:19] for n in result.get("NetworksRemoved", [])]
+                    or [n["Id"][7:19] for n in result.get("NetworksDeleted", [])]
+                ),
+            }
+            self.log_action("prune_networks", params, pruned)
+            return pruned
+        except Exception as e:
+            self.log_action("prune_networks", params, error=e)
+            raise RuntimeError(f"Failed to prune networks: {str(e)}")
+
+    def prune_system(self, force: bool = False, all: bool = False) -> Dict:
+        params = {"force": force, "all": all}
+        try:
+            cmd = (
+                ["podman", "system", "prune", "--force"]
+                if force
+                else ["podman", "system", "prune"]
+            )
+            if all:
+                cmd.append("--all")
+                if all:  # Include volumes if all=True
+                    cmd.append("--volumes")
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                raise RuntimeError(result.stderr)
+            self.logger.debug(f"Raw prune_system result: {result.stdout}")
+            pruned = {
+                "output": result.stdout.strip(),
+                "space_reclaimed": "Check output",
+                "images_removed": [],  # Podman CLI doesn't provide detailed breakdown
+                "containers_removed": [],
+                "volumes_removed": [],
+                "networks_removed": [],
+            }
+            self.log_action("prune_system", params, pruned)
+            return pruned
+        except Exception as e:
+            self.log_action("prune_system", params, error=e)
+            raise RuntimeError(f"Failed to prune system: {str(e)}")
 
     def get_version(self) -> Dict:
         params = {}
         try:
-            result = self.client.version()
+            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:
@@ -590,7 +1299,17 @@ class PodmanManager(ContainerManagerBase):
     def get_info(self) -> Dict:
         params = {}
         try:
-            result = self.client.info()
+            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:
@@ -601,7 +1320,30 @@ class PodmanManager(ContainerManagerBase):
         params = {}
         try:
             images = self.client.images.list()
-            result = [img.attrs for img in images]
+            result = []
+            for img in images:
+                attrs = img.attrs
+                repo_tags = attrs.get("Names", [])
+                repo_tag = repo_tags[0] if repo_tags else "<none>:<none>"
+                repository, tag = (
+                    repo_tag.rsplit(":", 1) if ":" in repo_tag else ("<none>", "<none>")
+                )
+                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 = {
+                    "repository": repository,
+                    "tag": tag,
+                    "id": (
+                        attrs.get("Id", "unknown")[7:19]
+                        if attrs.get("Id")
+                        else "unknown"
+                    ),
+                    "created": created_str,
+                    "size": size_str,
+                }
+                result.append(simplified)
             self.log_action("list_images", params, result)
             return result
         except Exception as e:
@@ -614,7 +1356,25 @@ class PodmanManager(ContainerManagerBase):
         params = {"image": image, "tag": tag, "platform": platform}
         try:
             img = self.client.images.pull(f"{image}:{tag}", platform=platform)
-            result = img[0].attrs if isinstance(img, list) else img.attrs
+            attrs = img[0].attrs if isinstance(img, list) else img.attrs
+            repo_tags = attrs.get("Names", [])
+            repo_tag = repo_tags[0] if repo_tags else f"{image}:{tag}"
+            repository, tag = (
+                repo_tag.rsplit(":", 1) if ":" in repo_tag else (image, tag)
+            )
+            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 = {
+                "repository": repository,
+                "tag": tag,
+                "id": (
+                    attrs.get("Id", "unknown")[7:19] if attrs.get("Id") else "unknown"
+                ),
+                "created": created_str,
+                "size": size_str,
+            }
             self.log_action("pull_image", params, result)
             return result
         except Exception as e:
@@ -636,7 +1396,26 @@ class PodmanManager(ContainerManagerBase):
         params = {"all": all}
         try:
             containers = self.client.containers.list(all=all)
-            result = [c.attrs for c in containers]
+            result = []
+            for c in containers:
+                attrs = c.attrs
+                ports = attrs.get("Ports", [])
+                port_mappings = [
+                    f"{p.get('host_ip', '0.0.0.0')}:{p.get('host_port')}->{p.get('container_port')}/{p.get('protocol', 'tcp')}"
+                    for p in ports
+                    if p.get("host_port")
+                ]
+                created = attrs.get("Created", None)
+                created_str = self._parse_timestamp(created)
+                simplified = {
+                    "id": attrs.get("Id", "unknown")[7:19],
+                    "image": attrs.get("Image", "unknown"),
+                    "name": attrs.get("Names", ["unknown"])[0].lstrip("/"),
+                    "status": attrs.get("State", "unknown"),
+                    "ports": ", ".join(port_mappings) if port_mappings else "none",
+                    "created": created_str,
+                }
+                result.append(simplified)
             self.log_action("list_containers", params, result)
             return result
         except Exception as e:
@@ -672,9 +1451,30 @@ class PodmanManager(ContainerManagerBase):
                 volumes=volumes,
                 environment=environment,
             )
-            result = (
-                container.attrs if detach else {"output": container.decode("utf-8")}
-            )
+            if not detach:
+                result = {"output": container.decode("utf-8") if container else ""}
+                self.log_action("run_container", params, result)
+                return result
+            attrs = container.attrs
+            port_mappings = []
+            if ports:  # Check if ports is not None
+                container_ports = attrs.get("Ports", [])
+                if container_ports:  # Check if Ports list is not empty
+                    port_mappings = [
+                        f"{p.get('host_ip', '0.0.0.0')}:{p.get('host_port')}->{p.get('container_port')}/{p.get('protocol', 'tcp')}"
+                        for p in container_ports
+                        if p.get("host_port")
+                    ]
+            created = attrs.get("Created", None)
+            created_str = self._parse_timestamp(created)
+            result = {
+                "id": attrs.get("Id", "unknown")[7:19],
+                "image": attrs.get("Image", image),
+                "name": attrs.get("Names", [name or "unknown"])[0].lstrip("/"),
+                "status": attrs.get("State", "unknown"),
+                "ports": ", ".join(port_mappings) if port_mappings else "none",
+                "created": created_str,
+            }
             self.log_action("run_container", params, result)
             return result
         except Exception as e:
@@ -710,7 +1510,9 @@ class PodmanManager(ContainerManagerBase):
         try:
             container = self.client.containers.get(container_id)
             logs = container.logs(tail=tail).decode("utf-8")
-            self.log_action("get_container_logs", params, logs)
+            self.log_action(
+                "get_container_logs", params, logs[:1000]
+            )  # Truncate for logging
             return logs
         except Exception as e:
             self.log_action("get_container_logs", params, error=e)
@@ -725,7 +1527,8 @@ class PodmanManager(ContainerManagerBase):
             exit_code, output = container.exec_run(command, detach=detach)
             result = {
                 "exit_code": exit_code,
-                "output": output.decode("utf-8") if output else None,
+                "output": output.decode("utf-8") if output and not detach else None,
+                "command": command,
             }
             self.log_action("exec_in_container", params, result)
             return result
@@ -737,7 +1540,17 @@ class PodmanManager(ContainerManagerBase):
         params = {}
         try:
             volumes = self.client.volumes.list()
-            result = {"volumes": [v.attrs for v in volumes]}
+            result = {
+                "volumes": [
+                    {
+                        "name": v.attrs.get("Name", "unknown"),
+                        "driver": v.attrs.get("Driver", "unknown"),
+                        "mountpoint": v.attrs.get("Mountpoint", "unknown"),
+                        "created": v.attrs.get("CreatedAt", "unknown"),
+                    }
+                    for v in volumes
+                ]
+            }
             self.log_action("list_volumes", params, result)
             return result
         except Exception as e:
@@ -748,7 +1561,13 @@ class PodmanManager(ContainerManagerBase):
         params = {"name": name}
         try:
             volume = self.client.volumes.create(name=name)
-            result = volume.attrs
+            attrs = volume.attrs
+            result = {
+                "name": attrs.get("Name", name),
+                "driver": attrs.get("Driver", "unknown"),
+                "mountpoint": attrs.get("Mountpoint", "unknown"),
+                "created": attrs.get("CreatedAt", "unknown"),
+            }
             self.log_action("create_volume", params, result)
             return result
         except Exception as e:
@@ -771,7 +1590,21 @@ class PodmanManager(ContainerManagerBase):
         params = {}
         try:
             networks = self.client.networks.list()
-            result = [net.attrs for net in networks]
+            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:
@@ -782,7 +1615,16 @@ class PodmanManager(ContainerManagerBase):
         params = {"name": name, "driver": driver}
         try:
             network = self.client.networks.create(name, driver=driver)
-            result = network.attrs
+            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:
@@ -861,11 +1703,51 @@ class PodmanManager(ContainerManagerBase):
             self.log_action("compose_logs", params, error=e)
             raise RuntimeError(f"Failed to compose logs: {str(e)}")
 
+    def init_swarm(self, advertise_addr: Optional[str] = None) -> Dict:
+        raise NotImplementedError("Swarm not supported in Podman")
+
+    def leave_swarm(self, force: bool = False) -> Dict:
+        raise NotImplementedError("Swarm not supported in Podman")
+
+    def list_nodes(self) -> List[Dict]:
+        raise NotImplementedError("Swarm not supported in Podman")
+
+    def list_services(self) -> List[Dict]:
+        raise NotImplementedError("Swarm not supported in Podman")
+
+    def create_service(
+        self,
+        name: str,
+        image: str,
+        replicas: int = 1,
+        ports: Optional[Dict[str, str]] = None,
+        mounts: Optional[List[str]] = None,
+    ) -> Dict:
+        raise NotImplementedError("Swarm not supported in Podman")
+
+    def remove_service(self, service_id: str) -> Dict:
+        raise NotImplementedError("Swarm not supported in Podman")
+
+
+def is_app_installed(app_name: str = "docker") -> bool:
+    return shutil.which(app_name.lower()) is not None
+
 
 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", None)
+    if manager_type is None:
+        if is_app_installed("podman"):
+            manager_type = "podman"
+        if is_app_installed("docker"):
+            manager_type = "docker"
+    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)
@@ -881,7 +1763,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:
@@ -893,6 +1775,8 @@ Actions:
   --platform <plat>    [ Platform, e.g., linux/amd64 ]
 --remove-image <image> [ Remove image ]
   --force              [ Force removal (global for remove actions) ]
+--prune-images         [ Prune unused images ]
+  --all                [ Prune all unused images ]
 --list-containers      [ List containers ]
   --all                [ Show all containers ]
 --run-container <image> [ Run container ]
@@ -906,6 +1790,7 @@ Actions:
   --timeout <sec>      [ Timeout, default 10 ]
 --remove-container <id>[ Remove container ]
   --force              [ Force ]
+--prune-containers     [ Prune stopped containers ]
 --get-container-logs <id> [ Get logs ]
   --tail <tail>        [ Tail lines, default all ]
 --exec-in-container <id> [ Exec command ]
@@ -915,10 +1800,15 @@ Actions:
 --create-volume <name> [ Create volume ]
 --remove-volume <name> [ Remove volume ]
   --force              [ Force ]
+--prune-volumes        [ Prune unused volumes ]
+  --all                [ Remove all volumes (dangerous) ]
 --list-networks        [ List networks ]
 --create-network <name>[ Create network ]
   --driver <driver>    [ Driver, default bridge ]
 --remove-network <id>  [ Remove network ]
+--prune-networks       [ Prune unused networks ]
+--prune-system         [ Prune system resources ]
+  --all                [ Prune all unused (including volumes, build cache) ]
 --compose-up <file>    [ Compose up ]
   --build              [ Build images ]
   --detach             [ Detach mode, default true ]
@@ -945,263 +1835,194 @@ container_manager.py --manager docker --pull-image nginx --tag latest --list-con
     )
 
 
-def main(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)
+def container_manager():
+    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("--prune-images", action="store_true", help="Prune images")
+    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(
+        "--prune-containers", action="store_true", help="Prune containers"
+    )
+    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("--prune-volumes", action="store_true", help="Prune volumes")
+    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("--prune-networks", action="store_true", help="Prune networks")
+    parser.add_argument("--prune-system", action="store_true", help="Prune system")
+    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("--force", action="store_true", help="Force removal")
+    parser.add_argument("-h", "--help", action="store_true", help="Show help")
+
+    args = parser.parse_args()
 
-    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
+    prune_images = args.prune_images
+    prune_images_all = args.all if prune_images else False
+    force = args.force
+    list_containers = args.list_containers
+    all_containers = args.all if list_containers else False
+    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
+    prune_containers = args.prune_containers
+    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
+    prune_volumes = args.prune_volumes
+    prune_volumes_all = args.all if prune_volumes else False
+    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
+    prune_networks = args.prune_networks
+    prune_system = args.prune_system
+    prune_system_all = args.all if prune_system else False
+    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)
 
@@ -1224,6 +2045,9 @@ def main(argv):
             raise ValueError("Image required for remove-image")
         print(json.dumps(manager.remove_image(remove_image_str, force), indent=2))
 
+    if prune_images:
+        print(json.dumps(manager.prune_images(force, prune_images_all), indent=2))
+
     if list_containers:
         print(json.dumps(manager.list_containers(all_containers), indent=2))
 
@@ -1269,6 +2093,9 @@ def main(argv):
             json.dumps(manager.remove_container(remove_container_id, force), indent=2)
         )
 
+    if prune_containers:
+        print(json.dumps(manager.prune_containers(), indent=2))
+
     if get_container_logs:
         if not container_logs_id:
             raise ValueError("Container ID required for get-container-logs")
@@ -1298,6 +2125,9 @@ def main(argv):
             raise ValueError("Name required for remove-volume")
         print(json.dumps(manager.remove_volume(remove_volume_name, force), indent=2))
 
+    if prune_volumes:
+        print(json.dumps(manager.prune_volumes(force, prune_volumes_all), indent=2))
+
     if list_networks:
         print(json.dumps(manager.list_networks(), indent=2))
 
@@ -1311,6 +2141,12 @@ def main(argv):
             raise ValueError("ID required for remove-network")
         print(json.dumps(manager.remove_network(remove_network_id), indent=2))
 
+    if prune_networks:
+        print(json.dumps(manager.prune_networks(), indent=2))
+
+    if prune_system:
+        print(json.dumps(manager.prune_system(force, prune_system_all), indent=2))
+
     if compose_up:
         if not compose_up_file:
             raise ValueError("File required for compose-up")
@@ -1378,4 +2214,4 @@ if __name__ == "__main__":
     if len(sys.argv) < 2:
         usage()
         sys.exit(2)
-    main(sys.argv[1:])
+    container_manager()