container-manager-mcp 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

container_manager_mcp/container_manager.py

@@ -8,10 +8,12 @@ from abc import ABC, abstractmethod
 from typing import List, Dict, Optional, Any
 import argparse
 import json
+import shutil
 import subprocess
 from datetime import datetime
 import dateutil.parser
 import platform
+import traceback
 
 try:
     import docker
@@ -40,7 +42,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__)
@@ -57,7 +59,10 @@ 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)."""
@@ -105,6 +110,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
@@ -130,6 +139,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
@@ -152,6 +165,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
@@ -164,6 +181,14 @@ class ContainerManagerBase(ABC):
     def remove_network(self, network_id: str) -> Dict:
         pass
 
+    @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
@@ -225,6 +250,78 @@ 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:
+            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:
@@ -294,6 +391,59 @@ 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 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:
@@ -384,98 +534,6 @@ 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:
@@ -500,6 +558,34 @@ 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:
@@ -581,6 +667,90 @@ 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 = []
+            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 remove_network(self, network_id: str) -> Dict:
         params = {"network_id": network_id}
         try:
@@ -593,6 +763,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:
@@ -818,17 +1007,14 @@ class DockerManager(ContainerManagerBase):
 class PodmanManager(ContainerManagerBase):
     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}")
@@ -863,7 +1049,6 @@ class PodmanManager(ContainerManagerBase):
         """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:
@@ -872,41 +1057,31 @@ class PodmanManager(ContainerManagerBase):
 
     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
+                    "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:
-            # 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
+                    f"unix:///run/user/{uid}/podman/podman.sock",
+                    "unix:///run/podman/podman.sock",
                 ]
             )
-
-        # 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):
@@ -915,9 +1090,207 @@ class PodmanManager(ContainerManagerBase):
             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:
+            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 list_images(self) -> List[Dict]:
         params = {}
         try:
@@ -983,6 +1356,17 @@ 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:
@@ -1069,99 +1453,6 @@ 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:
@@ -1267,6 +1558,51 @@ 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", 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 remove_network(self, network_id: str) -> Dict:
         params = {"network_id": network_id}
         try:
@@ -1365,21 +1701,24 @@ class PodmanManager(ContainerManagerBase):
         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: Optional[str] = None, silent: bool = False, log_file: str = None
 ) -> ContainerManagerBase:
     if manager_type is None:
-        manager_type = os.environ.get("CONTAINER_MANAGER_TYPE")
+        manager_type = os.environ.get("CONTAINER_MANAGER_TYPE", None)
     if manager_type is None:
-        # Autodetect
-        if PodmanClient is not None:
+        if is_app_installed("podman"):
             try:
                 test_client = PodmanClient()
                 test_client.close()
                 manager_type = "podman"
             except Exception:
                 pass
-        if manager_type is None and docker is not None:
+        if is_app_installed("docker"):
             try:
                 test_client = docker.from_env()
                 test_client.close()
@@ -1418,6 +1757,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 ]
@@ -1431,6 +1772,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 ]
@@ -1440,10 +1782,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 ]
@@ -1470,7 +1817,7 @@ container_manager.py --manager docker --pull-image nginx --tag latest --list-con
     )
 
 
-def container_manager(argv):
+def container_manager():
     parser = argparse.ArgumentParser(
         description="Container Manager: A tool to manage containers with Docker, Podman, and Docker Swarm!"
     )
@@ -1492,7 +1839,7 @@ def container_manager(argv):
     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("--prune-images", action="store_true", help="Prune images")
     parser.add_argument(
         "--list-containers", action="store_true", help="List containers"
     )
@@ -1513,6 +1860,9 @@ def container_manager(argv):
     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"
     )
@@ -1529,6 +1879,7 @@ def container_manager(argv):
     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"
@@ -1537,6 +1888,8 @@ def container_manager(argv):
     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(
@@ -1566,9 +1919,10 @@ def container_manager(argv):
     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(argv)
+    args = parser.parse_args()
 
     if args.help:
         usage()
@@ -1583,9 +1937,11 @@ def container_manager(argv):
     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
+    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
@@ -1599,6 +1955,7 @@ def container_manager(argv):
     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
@@ -1611,12 +1968,17 @@ def container_manager(argv):
     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
@@ -1665,6 +2027,9 @@ def container_manager(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))
 
@@ -1710,6 +2075,9 @@ def container_manager(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")
@@ -1739,6 +2107,9 @@ def container_manager(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))
 
@@ -1752,6 +2123,12 @@ def container_manager(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")
@@ -1819,4 +2196,4 @@ if __name__ == "__main__":
     if len(sys.argv) < 2:
         usage()
         sys.exit(2)
-    container_manager(sys.argv[1:])
+    container_manager()