container-manager-mcp 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

container_manager_mcp/container_manager.py

@@ -9,6 +9,8 @@ from typing import List, Dict, Optional, Any
 import getopt
 import json
 import subprocess
+from datetime import datetime
+import dateutil.parser
 
 try:
     import docker
@@ -26,6 +28,7 @@ except ImportError:
 
 
 class ContainerManagerBase(ABC):
+
     def __init__(self, silent: bool = False, log_file: str = None):
         self.silent = silent
         self.setup_logging(log_file)
@@ -55,6 +58,30 @@ class ContainerManagerBase(ABC):
         if error:
             self.logger.error(f"Error: {str(error)}")
 
+    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 or string) to ISO 8601 string."""
+        if not timestamp:
+            return "unknown"
+        if isinstance(timestamp, (int, float)):
+            return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%dT%H:%M:%S")
+        if isinstance(timestamp, str):
+            try:
+                parsed = dateutil.parser.isoparse(timestamp)
+                return parsed.strftime("%Y-%m-%dT%H:%M:%S")
+            except ValueError:
+                return "unknown"
+        return "unknown"
+
     @abstractmethod
     def get_version(self) -> Dict:
         pass
@@ -136,7 +163,6 @@ class ContainerManagerBase(ABC):
     def remove_network(self, network_id: str) -> Dict:
         pass
 
-    # Compose methods
     @abstractmethod
     def compose_up(
         self, compose_file: str, detach: bool = True, build: bool = False
@@ -155,19 +181,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 +206,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,31 +224,38 @@ class DockerManager(ContainerManagerBase):
             self.logger.error(f"Failed to connect to Docker daemon: {str(e)}")
             raise RuntimeError(f"Failed to connect to Docker: {str(e)}")
 
-    def get_version(self) -> Dict:
-        params = {}
-        try:
-            result = self.client.version()
-            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:
-            result = self.client.info()
-            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:
             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,29 +268,57 @@ 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:
             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:
             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:
@@ -288,15 +354,127 @@ 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
+            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)
+            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:
             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:
@@ -326,7 +504,9 @@ class DockerManager(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)
@@ -341,7 +521,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 +534,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 +555,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,28 +580,6 @@ class DockerManager(ContainerManagerBase):
             self.log_action("remove_volume", params, error=e)
             raise RuntimeError(f"Failed to remove volume: {str(e)}")
 
-    def list_networks(self) -> List[Dict]:
-        params = {}
-        try:
-            networks = self.client.networks.list()
-            result = [net.attrs for net in networks]
-            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)
-            result = network.attrs
-            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:
@@ -503,7 +678,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 +705,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 +755,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:
@@ -577,31 +825,34 @@ class PodmanManager(ContainerManagerBase):
             self.logger.error(f"Failed to connect to Podman daemon: {str(e)}")
             raise RuntimeError(f"Failed to connect to Podman: {str(e)}")
 
-    def get_version(self) -> Dict:
-        params = {}
-        try:
-            result = self.client.version()
-            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:
-            result = self.client.info()
-            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:
             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,29 +865,55 @@ 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:
             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:
             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,15 +949,126 @@ 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
+            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)
+            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:
             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:
@@ -710,7 +1098,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 +1115,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 +1128,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 +1149,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:
@@ -767,28 +1174,6 @@ class PodmanManager(ContainerManagerBase):
             self.log_action("remove_volume", params, error=e)
             raise RuntimeError(f"Failed to remove volume: {str(e)}")
 
-    def list_networks(self) -> List[Dict]:
-        params = {}
-        try:
-            networks = self.client.networks.list()
-            result = [net.attrs for net in networks]
-            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)
-            result = network.attrs
-            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:
@@ -861,6 +1246,34 @@ 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")
+
+
+# The rest of the file (create_manager, usage, container_manager) remains unchanged
+
 
 def create_manager(
     manager_type: str, silent: bool = False, log_file: str = None

{container_manager_mcp-0.0.10.dist-info → container_manager_mcp-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: container-manager-mcp
-Version: 0.0.10
+Version: 0.0.12
 Summary: Container Manager manage Docker, Docker Swarm, and Podman containers as an MCP Server
 Author-email: Audel Rouhi <knucklessg1@gmail.com>
 License: MIT
@@ -48,7 +48,7 @@ Dynamic: license-file
 ![PyPI - Wheel](https://img.shields.io/pypi/wheel/container-manager-mcp)
 ![PyPI - Implementation](https://img.shields.io/pypi/implementation/container-manager-mcp)
 
-*Version: 0.0.10*
+*Version: 0.0.12*
 
 Container Manager MCP Server provides a robust interface to manage Docker and Podman containers, networks, volumes, and Docker Swarm services through a FastMCP server, enabling programmatic and remote container management.
 

container_manager_mcp-0.0.12.dist-info/RECORD

@@ -0,0 +1,10 @@
+container_manager_mcp/__init__.py,sha256=N3bhKd_oh5YmBBl9N1omfZgaXhJyP0vOzH4VKxs68_g,506
+container_manager_mcp/__main__.py,sha256=zic5tX336HG8LfdzQQ0sDVx-tMSOsgOZCtaxHWgJ4Go,134
+container_manager_mcp/container_manager.py,sha256=hIdXyI7L2kFrJc_7bMOaQpKAPECxCVjaQoohqjmY-Iw,67859
+container_manager_mcp/container_manager_mcp.py,sha256=cIAN8YGflQ9nZEHodkYdQKo2GECAuTH7WB-oMhnAd_0,37959
+container_manager_mcp-0.0.12.dist-info/licenses/LICENSE,sha256=Z1xmcrPHBnGCETO_LLQJUeaSNBSnuptcDVTt4kaPUOE,1060
+container_manager_mcp-0.0.12.dist-info/METADATA,sha256=ItKjQvWeRj9e8J26zMjGilRfuFPywXf6afihA_knBdA,8240
+container_manager_mcp-0.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+container_manager_mcp-0.0.12.dist-info/entry_points.txt,sha256=I23pXcCgAShlfYbENzs3kbw3l1lU9Gy7lODPfRqeeiA,156
+container_manager_mcp-0.0.12.dist-info/top_level.txt,sha256=B7QQLOd9mBdu0lsPKqyu4T8-zUtbqKzQJbMbtAzoozU,22
+container_manager_mcp-0.0.12.dist-info/RECORD,,

container_manager_mcp-0.0.10.dist-info/RECORD

@@ -1,10 +0,0 @@
-container_manager_mcp/__init__.py,sha256=N3bhKd_oh5YmBBl9N1omfZgaXhJyP0vOzH4VKxs68_g,506
-container_manager_mcp/__main__.py,sha256=zic5tX336HG8LfdzQQ0sDVx-tMSOsgOZCtaxHWgJ4Go,134
-container_manager_mcp/container_manager.py,sha256=WJDWAJezb8bucHWYOXuSfT0MZDkpReuVs7sL26PO7nM,49900
-container_manager_mcp/container_manager_mcp.py,sha256=cIAN8YGflQ9nZEHodkYdQKo2GECAuTH7WB-oMhnAd_0,37959
-container_manager_mcp-0.0.10.dist-info/licenses/LICENSE,sha256=Z1xmcrPHBnGCETO_LLQJUeaSNBSnuptcDVTt4kaPUOE,1060
-container_manager_mcp-0.0.10.dist-info/METADATA,sha256=kgTYfp-2ITrb0oGOLcRgIDchWITcMkyxpPP7fXlnmng,8240
-container_manager_mcp-0.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-container_manager_mcp-0.0.10.dist-info/entry_points.txt,sha256=I23pXcCgAShlfYbENzs3kbw3l1lU9Gy7lODPfRqeeiA,156
-container_manager_mcp-0.0.10.dist-info/top_level.txt,sha256=B7QQLOd9mBdu0lsPKqyu4T8-zUtbqKzQJbMbtAzoozU,22
-container_manager_mcp-0.0.10.dist-info/RECORD,,