docker-stack 2.1.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

docker_stack/cli.py

@@ -12,6 +12,7 @@ from typing import Dict, List, Optional, Tuple
 import os
 import yaml
 import json
+import time
 from docker_stack.docker_objects import DockerConfig, DockerObjectManager, DockerSecret
 from docker_stack.helpers import CallbackCommand, Command, generate_secret, run_cli_command
 from docker_stack.login import (
@@ -19,13 +20,16 @@ from docker_stack.login import (
     ensure_isolated_login,
     format_expiry,
     login as docker_manager_login,
+    persist_shell_context,
     resolve_login_config,
     resolve_shell_login_config,
     setup_auth as docker_manager_setup_auth,
     switch_docker_context,
+    UnknownShellContextError,
 )
 from docker_stack.shell_auth import (
     SHELL_CONTEXT_ENV,
+    SHELL_NODE_STATE_ENV,
     ShellAuthError,
     ensure_shell_access,
     login_for_active_shell,
@@ -33,6 +37,7 @@ from docker_stack.shell_auth import (
     shell_session_active,
 )
 from docker_stack.manager_api import (
+    FEATURE_CLUSTER_CONTAINER_CLI,
     FEATURE_STACK_DEPLOY,
     FEATURE_STACK_QUERY,
     ManagerApiClient,
@@ -48,6 +53,281 @@ DOCKER_SHELL_ENDPOINT_ENV_VARS = (
     "DOCKER_API_VERSION",
     "DOCKER_MACHINE_NAME",
 )
+DEFAULT_NAMESPACE = "default"
+NODE_HEADER = "X-Docker-Manager-Node"
+
+
+def _active_docker_config_path() -> Path:
+    if not shell_session_active():
+        raise RuntimeError("node selection is available only inside docker-stack shell")
+    config_root = os.getenv("DOCKER_CONFIG", "").strip()
+    if not config_root:
+        raise RuntimeError("managed shell Docker configuration is unavailable")
+    return Path(config_root) / "config.json"
+
+
+def _read_selected_node() -> str:
+    config_path = _active_docker_config_path()
+    try:
+        payload = json.loads(config_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"failed reading managed Docker configuration: {exc}") from exc
+    headers = payload.get("HttpHeaders")
+    value = headers.get(NODE_HEADER) if isinstance(headers, dict) else None
+    return str(value).strip() if value else "cluster"
+
+
+def _write_selected_node(value: Optional[str], display_name: str) -> None:
+    config_path = _active_docker_config_path()
+    try:
+        payload = json.loads(config_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"failed reading managed Docker configuration: {exc}") from exc
+    headers = payload.get("HttpHeaders")
+    headers = dict(headers) if isinstance(headers, dict) else {}
+    if value:
+        headers[NODE_HEADER] = value
+    else:
+        headers.pop(NODE_HEADER, None)
+    if headers:
+        payload["HttpHeaders"] = headers
+    else:
+        payload.pop("HttpHeaders", None)
+    temporary = config_path.with_suffix(".tmp")
+    temporary.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    os.chmod(temporary, 0o600)
+    os.replace(temporary, config_path)
+    node_state = os.getenv(SHELL_NODE_STATE_ENV, "").strip()
+    if node_state:
+        Path(node_state).write_text(f"{display_name}\n", encoding="utf-8")
+
+
+def _manager_with_cluster_cli() -> ManagerApiClient:
+    client = discover_manager_client()
+    if client is None or not client.supports(FEATURE_CLUSTER_CONTAINER_CLI):
+        raise RuntimeError("Docker-Manager does not support cluster container CLI; upgrade the manager and all node agents")
+    return client
+
+
+def _select_node(value: str) -> str:
+    client = _manager_with_cluster_cli()
+    requested = value.strip()
+    if requested.lower() == "cluster":
+        _write_selected_node(None, "cluster")
+        return "cluster"
+    nodes = client.list_nodes().get("nodes", [])
+    exact = [node for node in nodes if str(node.get("id") or "") == requested]
+    candidates = exact or [
+        node
+        for node in nodes
+        if str(node.get("id") or "").startswith(requested)
+        or str(node.get("hostname") or "") == requested
+    ]
+    if not candidates:
+        raise RuntimeError(f"node '{requested}' is not visible or does not exist")
+    if len(candidates) != 1:
+        names = ", ".join(str(node.get("hostname") or node.get("id")) for node in candidates)
+        raise RuntimeError(f"node '{requested}' is ambiguous: {names}")
+    node = candidates[0]
+    if str(node.get("state") or "").lower() != "ready":
+        raise RuntimeError(f"node '{requested}' is not ready")
+    node_id = str(node.get("id") or "").strip()
+    hostname = str(node.get("hostname") or node_id).strip()
+    _write_selected_node(node_id, hostname)
+    return hostname
+
+
+def _human_age(timestamp: object) -> str:
+    try:
+        seconds = max(0, int(time.time()) - int(timestamp))
+    except (TypeError, ValueError):
+        return "-"
+    if seconds < 60:
+        return f"{seconds} seconds ago"
+    if seconds < 3600:
+        return f"{seconds // 60} minutes ago"
+    if seconds < 86400:
+        return f"{seconds // 3600} hours ago"
+    return f"{seconds // 86400} days ago"
+
+
+def _format_ports(ports: object) -> str:
+    if not isinstance(ports, list):
+        return ""
+    values = []
+    for port in ports:
+        if not isinstance(port, dict):
+            continue
+        private = port.get("PrivatePort")
+        protocol = port.get("Type") or "tcp"
+        public = port.get("PublicPort")
+        address = port.get("IP") or "0.0.0.0"
+        values.append(f"{address}:{public}->{private}/{protocol}" if public is not None else f"{private}/{protocol}")
+    return ", ".join(values)
+
+
+def _print_cluster_containers(payload: Dict[str, object], *, no_trunc: bool = False, show_size: bool = False) -> int:
+    rows = []
+    for entry in payload.get("containers", []):
+        if not isinstance(entry, dict) or not isinstance(entry.get("docker"), dict):
+            continue
+        item = entry["docker"]
+        container_id = str(item.get("Id") or "-")
+        names = item.get("Names") if isinstance(item.get("Names"), list) else []
+        row = {
+            "CONTAINER ID": container_id if no_trunc else container_id[:12],
+            "IMAGE": str(item.get("Image") or "-"),
+            "COMMAND": str(item.get("Command") or "-"),
+            "CREATED": _human_age(item.get("Created")),
+            "STATUS": str(item.get("Status") or item.get("State") or "-"),
+            "PORTS": _format_ports(item.get("Ports")),
+            "NAMES": ",".join(str(name).lstrip("/") for name in names) or "-",
+            "NODE": str(entry.get("node_name") or entry.get("node_id") or "-"),
+        }
+        if show_size:
+            row["SIZE"] = str(item.get("SizeRw") if item.get("SizeRw") is not None else "-")
+        rows.append(row)
+    columns = ["CONTAINER ID", "IMAGE", "COMMAND", "CREATED", "STATUS", "PORTS", "NAMES"]
+    if show_size:
+        columns.append("SIZE")
+    columns.append("NODE")
+    widths = {column: max(len(column), max((len(row[column]) for row in rows), default=0)) for column in columns}
+    print("   ".join(column.ljust(widths[column]) for column in columns))
+    for row in rows:
+        print("   ".join(row[column].ljust(widths[column]) for column in columns))
+    errors = payload.get("node_errors") if isinstance(payload.get("node_errors"), list) else []
+    for error in errors:
+        if isinstance(error, dict):
+            print(
+                f"docker ps: node {error.get('node_name') or error.get('node_id')}: {error.get('message')} "
+                f"(incident: {error.get('incident_id')})",
+                file=sys.stderr,
+            )
+    return 1 if errors else 0
+
+
+def _managed_docker(arguments: List[str]) -> int:
+    values = list(arguments)
+    if values and values[0] == "--":
+        values.pop(0)
+    command_index = 0
+    while command_index < len(values) and values[command_index].startswith("-"):
+        option = values[command_index]
+        if option in {"--config", "--context", "--host", "-H", "--log-level"}:
+            command_index += 2
+        else:
+            command_index += 1
+    command = values[command_index:]
+    global_options = values[:command_index]
+    explicit_target = any(
+        value in {"--config", "--context", "-c", "--host", "-H"}
+        or value.startswith(("--config=", "--context=", "--host=", "-H="))
+        or (value.startswith("-H") and value != "-H")
+        or (value.startswith("-c") and value != "-c")
+        for value in global_options
+    )
+    is_ps = bool(command) and (
+        command[0] == "ps"
+        or (len(command) >= 2 and command[0] == "container" and command[1] in {"ls", "list"})
+    )
+    if explicit_target or not is_ps or any(
+        value in {"-q", "--quiet", "--format"} or value.startswith("--format=")
+        for value in command
+    ):
+        return subprocess.run(["docker", *values], check=False).returncode
+    try:
+        client = discover_manager_client()
+        if client is None or not client.supports(FEATURE_CLUSTER_CONTAINER_CLI):
+            return subprocess.run(["docker", *values], check=False).returncode
+        filters = []
+        all_containers = False
+        latest = False
+        limit = None
+        no_trunc = False
+        show_size = False
+        index = 1 if command[0] == "ps" else 2
+        while index < len(command):
+            value = command[index]
+            if value in {"-a", "--all"}:
+                all_containers = True
+            elif value in {"-l", "--latest"}:
+                latest = True
+            elif value == "--no-trunc":
+                no_trunc = True
+            elif value in {"-s", "--size"}:
+                show_size = True
+            elif value in {"-f", "--filter"} and index + 1 < len(command):
+                index += 1
+                filters.append(command[index])
+            elif value.startswith("--filter="):
+                filters.append(value.split("=", 1)[1])
+            elif value in {"-n", "--last"} and index + 1 < len(command):
+                index += 1
+                limit = int(command[index])
+            elif value.startswith("--last="):
+                limit = int(value.split("=", 1)[1])
+            else:
+                return subprocess.run(["docker", *values], check=False).returncode
+            index += 1
+        payload = client.list_containers(
+            all_containers=all_containers,
+            filters=filters,
+            limit=limit,
+            latest=latest,
+            size=show_size,
+        )
+        return _print_cluster_containers(payload, no_trunc=no_trunc, show_size=show_size)
+    except (RuntimeError, ValueError) as exc:
+        print(f"docker ps: {exc}", file=sys.stderr)
+        return 2
+
+
+def physical_stack_name(namespace: str, stack: str) -> str:
+    return stack if namespace == DEFAULT_NAMESPACE else f"{namespace}--{stack}"
+
+
+def _namespace_default() -> str:
+    return os.getenv("DOCKER_STACK_NAMESPACE", DEFAULT_NAMESPACE).strip() or DEFAULT_NAMESPACE
+
+
+def _add_namespace_argument(parser: argparse.ArgumentParser, help_text: str = "Stack namespace") -> None:
+    parser.add_argument(
+        "-n",
+        "--namespace",
+        default=_namespace_default(),
+        help=f"{help_text} (default: %(default)s)",
+    )
+
+
+def _add_listing_namespace_arguments(parser: argparse.ArgumentParser) -> None:
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "-n",
+        "--namespace",
+        default=_namespace_default(),
+        help="Stack namespace (default: %(default)s)",
+    )
+    group.add_argument(
+        "-A",
+        "--all-namespaces",
+        "-all-namespaces",
+        action="store_true",
+        help="List stacks across all namespaces",
+    )
+
+
+def _prompt_for_manager_target(context_name: str) -> str:
+    if not sys.stdin.isatty():
+        raise RuntimeError(
+            f"Unknown shell context '{context_name}'. Run "
+            f"'docker-stack shell --context {context_name} <manager-url>' to create it."
+        )
+    print(f"Docker context '{context_name}' does not exist yet.")
+    print("Enter the Docker-Manager URL to create it (for example https://manager.example.com:2376).")
+    target = input(f"Manager URL for {context_name}: ").strip()
+    if not target:
+        raise RuntimeError(f"Manager URL is required to create shell context '{context_name}'")
+    return target
 
 
 @dataclass
@@ -382,7 +662,13 @@ class DockerStack:
             env_sources.append(content.decode("utf-8", errors="ignore"))
         return x_files, env_sources
 
-    def rendered_compose_file(self, compose_file, stack=None, include_build=True) -> RenderedCompose:
+    def rendered_compose_file(
+        self,
+        compose_file,
+        stack=None,
+        include_build=True,
+        namespace: str = DEFAULT_NAMESPACE,
+    ) -> RenderedCompose:
         compose_path = Path(compose_file).resolve()
         template_bytes = compose_path.read_bytes()
         template_content = template_bytes.decode("utf-8")
@@ -411,11 +697,19 @@ class DockerStack:
         if stack and not manager_deploy:
             if "configs" in compose_data:
                 compose_data["configs"] = self._process_x_content(
-                    compose_data["configs"], self.docker.config, base_dir=str(base_dir), stack=stack
+                    compose_data["configs"],
+                    self.docker.config,
+                    base_dir=str(base_dir),
+                    stack=stack,
+                    namespace=namespace,
                 )
             if "secrets" in compose_data:
                 compose_data["secrets"] = self._process_x_content(
-                    compose_data["secrets"], self.docker.secret, base_dir=str(base_dir), stack=stack
+                    compose_data["secrets"],
+                    self.docker.secret,
+                    base_dir=str(base_dir),
+                    stack=stack,
+                    namespace=namespace,
                 )
 
         # Define the replacements for '$' to '$$' for env variables in compose files
@@ -437,26 +731,38 @@ class DockerStack:
     def decode_yaml(self, data: str) -> dict:
         return yaml.safe_load(data)
 
-    def render_compose_file(self, compose_file, stack=None, include_build=True):
+    def render_compose_file(self, compose_file, stack=None, include_build=True, namespace: str = DEFAULT_NAMESPACE):
         """
         Render the Docker Compose file with environment variables and create Docker configs/secrets.
         """
-        return self.rendered_compose_file(compose_file, stack, include_build=include_build)
+        return self.rendered_compose_file(
+            compose_file,
+            stack,
+            include_build=include_build,
+            namespace=namespace,
+        )
 
-    def _process_x_content(self, objects, manager: DockerObjectManager, base_dir="", stack=None):
+    def _process_x_content(
+        self,
+        objects,
+        manager: DockerObjectManager,
+        base_dir="",
+        stack=None,
+        namespace: str = DEFAULT_NAMESPACE,
+    ):
         """
         Process configs or secrets with x-content keys.
         Returns a tuple: (processed_objects, commands)
         """
         processed_objects = {}
         manager_client = self._manager_client_for_feature(FEATURE_STACK_DEPLOY)
-        namespace = os.getenv("DOCKER_STACK_NAMESPACE", "default")
+        object_stack = physical_stack_name(namespace, stack) if stack else None
 
         def docker_object_name_for(name, explicit_name=None):
             if explicit_name:
                 return explicit_name
-            if stack:
-                return f"{stack}_{name}"
+            if object_stack:
+                return f"{object_stack}_{name}"
             return name
 
         def normalize_labels(labels):
@@ -500,7 +806,7 @@ class DockerStack:
                 processed_objects[name] = {"name": response["actual_name"], "external": True}
                 return
 
-            object_name, command = manager.create(docker_object_name, data, labels=labels, stack=stack)
+            object_name, command = manager.create(docker_object_name, data, labels=labels, stack=object_stack)
             if not command.isNop():
                 self.commands.append(command)
                 if is_generated_secret:
@@ -604,16 +910,55 @@ class DockerStack:
     def _version_sort_key(raw: str):
         return int(raw) if raw.isdigit() else raw
 
-    def _print_stack_listing(self, stack_versions: Dict[str, List[str]]) -> None:
-        max_stack_name_length = max(len(stack) for stack in stack_versions) if stack_versions else 10
-        header_stack = "Stack Name".ljust(max_stack_name_length)
+    @staticmethod
+    def _compact_versions(versions: List[str]) -> str:
+        numeric = sorted({int(version.lstrip("vV")) for version in versions if version.lstrip("vV").isdigit()})
+        other = sorted({version for version in versions if not version.lstrip("vV").isdigit()})
+        compact = []
+        start = end = None
+
+        def append_range(first: int, last: int) -> None:
+            if last - first >= 2:
+                compact.append(f"v{first}...v{last}")
+            elif last == first:
+                compact.append(f"v{first}")
+            else:
+                compact.extend((f"v{first}", f"v{last}"))
 
-        print(f"{header_stack} | Versions")
-        print("-" * (max_stack_name_length + 12))
+        for version in numeric:
+            if start is None:
+                start = end = version
+            elif version == end + 1:
+                end = version
+            else:
+                append_range(start, end)
+                start = end = version
+        if start is not None:
+            append_range(start, end)
+        compact.extend(other)
+        return ", ".join(compact)
+
+    def _print_stack_listing(self, stack_versions: Dict[Tuple[str, str], List[str]], namespace: Optional[str]) -> None:
+        max_stack_name_length = max((len(stack) for _, stack in stack_versions), default=10)
+        header_stack = "Stack Name".ljust(max_stack_name_length)
 
-        for stack, versions in sorted(stack_versions.items()):
-            versions_str = ", ".join(sorted(versions, key=self._version_sort_key))
-            print(f"{stack.ljust(max_stack_name_length)} | {versions_str}")
+        if namespace is not None:
+            print(f"Namespace: {namespace}")
+            print(f"{header_stack} | Versions")
+            print("-" * (max_stack_name_length + 12))
+        else:
+            max_namespace_length = max((len(item_namespace) for item_namespace, _ in stack_versions), default=9)
+            header_namespace = "Namespace".ljust(max_namespace_length)
+            print("Namespace: all")
+            print(f"{header_namespace} | {header_stack} | Versions")
+            print("-" * (max_namespace_length + max_stack_name_length + 15))
+
+        for (item_namespace, stack), versions in sorted(stack_versions.items()):
+            versions_str = self._compact_versions(versions)
+            if namespace is None:
+                print(f"{item_namespace.ljust(max_namespace_length)} | {stack.ljust(max_stack_name_length)} | {versions_str}")
+            else:
+                print(f"{stack.ljust(max_stack_name_length)} | {versions_str}")
 
     def _print_versions(self, versions_list: List[Tuple[str, str]]) -> None:
         rows = [("Version", "Tag")] + versions_list
@@ -626,13 +971,13 @@ class DockerStack:
         for version, tag in sorted(versions_list, key=lambda x: self._version_sort_key(x[0])):
             print(f"{version.ljust(max_version_length)} | {tag.ljust(max_tag_length)}")
 
-    def ls(self):
+    def ls(self, namespace: Optional[str] = DEFAULT_NAMESPACE):
         client = self._manager_client_for_feature(FEATURE_STACK_QUERY)
         if client:
             try:
-                payload = client.list_stacks()
+                payload = client.list_stacks(namespace=namespace)
                 stack_versions = {
-                    str(item.get("stack")): [
+                    (str(item.get("namespace") or namespace or DEFAULT_NAMESPACE), str(item.get("stack"))): [
                         str(version)
                         for version in (
                             item.get("versions") if isinstance(item.get("versions"), list) else item.get("available_versions", [])
@@ -642,7 +987,9 @@ class DockerStack:
                     for item in payload.get("stacks", [])
                     if str(item.get("stack", "")).strip()
                 }
-                self._print_stack_listing(stack_versions)
+                self._print_stack_listing(stack_versions, namespace)
+                if namespace is not None:
+                    return {stack: versions for (_, stack), versions in stack_versions.items()}
                 return stack_versions
             except RuntimeError as exc:
                 self._raise_if_manager_is_explicit(exc)
@@ -650,7 +997,7 @@ class DockerStack:
         cmd = ["docker", "config", "ls", "--format", "{{.ID}}\t{{.Name}}\t{{.Labels}}"]
         raw_output = run_cli_command(cmd, log=False)
         output = raw_output.split("\n") if raw_output else []
-        stack_versions: Dict[str, List[str]] = {}
+        stack_versions: Dict[Tuple[str, str], List[str]] = {}
 
         for line in output:
             parts = line.split("\t")
@@ -658,11 +1005,14 @@ class DockerStack:
                 labels = {k: v for k, v in (label.split("=") for label in parts[2].split(",") if "=" in label)}
                 stack_name = labels.get("mesudip.stack.name")
                 version = labels.get("mesudip.object.version", "unknown")
+                object_namespace = labels.get("com.mesudip.namespace", DEFAULT_NAMESPACE)
 
-                if stack_name:
-                    stack_versions.setdefault(stack_name, []).append(version)
+                if stack_name and (namespace is None or object_namespace == namespace):
+                    stack_versions.setdefault((object_namespace, stack_name), []).append(version)
 
-        self._print_stack_listing(stack_versions)
+        self._print_stack_listing(stack_versions, namespace)
+        if namespace is not None:
+            return {stack: versions for (_, stack), versions in stack_versions.items()}
         return stack_versions
 
     def cat(self, name: str, version: str, namespace: str = "default"):
@@ -681,10 +1031,11 @@ class DockerStack:
             except RuntimeError as exc:
                 self._raise_if_manager_is_explicit(exc)
 
+        history_name = physical_stack_name(namespace, name)
         if normalized_version == "1":
-            config_name = f"{name}"
+            config_name = history_name
         else:
-            config_name = f"{name}_v{normalized_version}"
+            config_name = f"{history_name}_v{normalized_version}"
 
         cmd = ["docker", "config", "inspect", config_name]
         output = run_cli_command(cmd, log=False)
@@ -730,8 +1081,9 @@ class DockerStack:
                 stack = labels.get("mesudip.stack.name")
                 version = labels.get("mesudip.object.version", "unknown")
                 tag = labels.get("mesudip.stack.tag", "")
+                object_namespace = labels.get("com.mesudip.namespace", DEFAULT_NAMESPACE)
 
-                if stack == stack_name:
+                if stack == stack_name and object_namespace == namespace:
                     versions_list.append((version, tag))
 
         if print_output:
@@ -894,11 +1246,17 @@ class DockerStack:
         if force_update:
             raise RuntimeError("--force-update is supported only by the Docker-Manager stack deploy API")
 
-        _, cmd = self.docker.config.increment(stack_name, stored_content, labels=labels, stack=stack_name)
+        physical_stack = physical_stack_name(namespace, stack_name)
+        _, cmd = self.docker.config.increment(
+            physical_stack,
+            stored_content,
+            labels=labels,
+            stack=physical_stack,
+        )
         if not cmd.isNop():
             self.commands.append(cmd)
 
-        cmd = ["docker", "stack", "deploy", "-c", "-", stack_name]
+        cmd = ["docker", "stack", "deploy", "-c", "-", physical_stack]
         if with_registry_auth:
             cmd.insert(3, "--with-registry-auth")
         if prune:
@@ -1059,7 +1417,12 @@ class DockerStack:
         force_update: bool = False,
     ):
         self.generated_secrets = {}  # Reset for each deployment
-        rendered = self.render_compose_file(compose_file, stack=stack_name, include_build=False)
+        rendered = self.render_compose_file(
+            compose_file,
+            stack=stack_name,
+            include_build=False,
+            namespace=namespace,
+        )
         self._deploy(
             stack_name,
             rendered.clean,
@@ -1098,7 +1461,12 @@ class DockerStack:
                 )
             )
             return
-        self.commands.append(Command(["docker", "stack", "rm", stack_name], give_console=True))
+        self.commands.append(
+            Command(
+                ["docker", "stack", "rm", physical_stack_name(namespace, stack_name)],
+                give_console=True,
+            )
+        )
 
     def push(self, compose_file):
         compose_data = self.read_compose_file(compose_file)
@@ -1380,6 +1748,9 @@ def main(args: List[str] = None):
     shell_auth_parser = subparsers.add_parser("shell-auth", help=argparse.SUPPRESS)
     shell_auth_parser.add_argument("operation", choices=("ensure", "status"), help=argparse.SUPPRESS)
 
+    docker_parser = subparsers.add_parser("docker", help=argparse.SUPPRESS)
+    docker_parser.add_argument("docker_args", nargs=argparse.REMAINDER, help=argparse.SUPPRESS)
+
     # Build subcommand
     build_parser = subparsers.add_parser("build", help="Build images using docker-compose")
     build_parser.add_argument("compose_file", help="Path to the compose file")
@@ -1405,36 +1776,40 @@ def main(args: List[str] = None):
         action="store_true",
         help="Force service task updates (Docker-Manager deploys only)",
     )
-    deploy_parser.add_argument("--namespace", default=os.getenv("DOCKER_STACK_NAMESPACE", "default"), help="Deployment namespace")
+    _add_namespace_argument(deploy_parser, "Deployment namespace")
     deploy_parser.add_argument("-t", "--tag", help="Tag the current deployment for later checkout", required=False)
     deploy_parser.add_argument("--show-generated", action="store_true", default=True, help="Show newly generated secrets after deployment")
 
     # Remove subcommand
     rm_parser = subparsers.add_parser("rm", help="Remove a deployed stack")
     rm_parser.add_argument("stack_name", help="Name of the stack")
-    rm_parser.add_argument("--namespace", default=os.getenv("DOCKER_STACK_NAMESPACE", "default"), help="Stack namespace")
+    _add_namespace_argument(rm_parser)
 
     # Prune command
     subparsers.add_parser("prune", help="Remove old versions of configs and secrets")
 
     # Ls command
-    subparsers.add_parser("ls", help="List docker-stacks")
+    ls_parser = subparsers.add_parser("ls", help="List docker-stacks")
+    _add_listing_namespace_arguments(ls_parser)
 
     node_parser = subparsers.add_parser("node", help="Inspect Docker Swarm nodes")
     node_subparsers = node_parser.add_subparsers(dest="node_command", required=True)
     node_subparsers.add_parser("ls", help="List Docker Swarm nodes and their labels")
+    node_subparsers.add_parser("current", help="Show the node selected in this managed shell")
+    node_use_parser = node_subparsers.add_parser("use", help="Select a node for node-local Docker commands")
+    node_use_parser.add_argument("node", help="Node id, id prefix, hostname, or 'cluster'")
 
     cat_parser = subparsers.add_parser(
         "cat", help="Print the docker compose of specific version. Defaults to latest version if not specified."
     )
     cat_parser.add_argument("stack_name", help="Name of the stack")
     cat_parser.add_argument("version", nargs="?", help="Stack version to cat. Defaults to latest if omitted.")
-    cat_parser.add_argument("--namespace", default=os.getenv("DOCKER_STACK_NAMESPACE", "default"), help="Stack namespace")
+    _add_namespace_argument(cat_parser)
 
     checkout_parser = subparsers.add_parser("checkout", help="Deploy specific version of the stack")
     checkout_parser.add_argument("stack_name", help="Name of the stack")
     checkout_parser.add_argument("version", help="Stack version to cat")
-    checkout_parser.add_argument("--namespace", default=os.getenv("DOCKER_STACK_NAMESPACE", "default"), help="Stack namespace")
+    _add_namespace_argument(checkout_parser)
 
     # version_parser = subparsers.add_parser("version",help="Deploy specific version of the stack")
     # version_parser.add_argument("stack_name", help="Name of the stack")
@@ -1442,7 +1817,7 @@ def main(args: List[str] = None):
 
     version_parser = subparsers.add_parser("version", aliases=["versions"], help="Deploy specific version of the stack")
     version_parser.add_argument("stack_name", help="Name of the stack")
-    version_parser.add_argument("--namespace", default=os.getenv("DOCKER_STACK_NAMESPACE", "default"), help="Stack namespace")
+    _add_namespace_argument(version_parser)
 
     parser.add_argument(
         "-u", "--user", help="Registry credentials in format hostname:username:password", action="append", required=False, default=[]
@@ -1471,6 +1846,9 @@ def main(args: List[str] = None):
             return 2
         return 0
 
+    if args.command == "docker":
+        return _managed_docker(args.docker_args)
+
     if args.command == "login":
         try:
             config = resolve_login_config(
@@ -1480,6 +1858,8 @@ def main(args: List[str] = None):
                 timeout_secs=args.timeout_secs,
             )
             current_shell_config = active_shell_config_dir(config.context_name)
+            if current_shell_config is None:
+                current_shell_config = getattr(config, "docker_config_dir", None)
             if shell_session_active():
                 result = login_for_active_shell(config)
                 config_dir = current_shell_config
@@ -1513,12 +1893,26 @@ def main(args: List[str] = None):
         shell_name = args.target if args.context_name is None else None
         manager_target = args.target if args.context_name is not None else None
         try:
-            config = resolve_shell_login_config(
-                shell_name=shell_name,
-                manager_target=manager_target,
-                context_name=args.context_name,
-                timeout_secs=args.timeout_secs,
-            )
+            try:
+                config = resolve_shell_login_config(
+                    shell_name=shell_name,
+                    manager_target=manager_target,
+                    context_name=args.context_name,
+                    timeout_secs=args.timeout_secs,
+                )
+            except UnknownShellContextError as exc:
+                manager_target = _prompt_for_manager_target(exc.context_name)
+                print(f"Creating Docker-Manager shell context '{exc.context_name}'...")
+                config = resolve_shell_login_config(
+                    shell_name=None,
+                    manager_target=manager_target,
+                    context_name=exc.context_name,
+                    timeout_secs=args.timeout_secs,
+                )
+                persist_shell_context(config)
+            else:
+                if manager_target is not None:
+                    persist_shell_context(config)
             if shell_session_active() and os.getenv(SHELL_CONTEXT_ENV) == config.context_name:
                 print(f"docker-stack shell context={config.context_name} is already active")
                 return
@@ -1586,6 +1980,9 @@ def main(args: List[str] = None):
         docker = Docker(registries=args.user)
         docker.load_env()
 
+        if hasattr(args, "namespace") and args.command != "ls":
+            print(f"Namespace: {args.namespace}", file=sys.stderr)
+
         if args.command == "build":
             docker.stack.build_and_push(args.compose_file, push=args.push)
         elif args.command == "push":
@@ -1604,10 +2001,23 @@ def main(args: List[str] = None):
                 force_update=args.force_update,
             )
         elif args.command == "ls":
-            docker.stack.ls()
+            docker.stack.ls(namespace=None if args.all_namespaces else (args.namespace or DEFAULT_NAMESPACE))
         elif args.command == "node":
             if args.node_command == "ls":
                 docker.node.ls()
+            elif args.node_command == "current":
+                try:
+                    print(_read_selected_node())
+                except RuntimeError as exc:
+                    print(f"docker-stack node current: {exc}", file=sys.stderr)
+                    return 2
+            elif args.node_command == "use":
+                try:
+                    selected = _select_node(args.node)
+                except RuntimeError as exc:
+                    print(f"docker-stack node use: {exc}", file=sys.stderr)
+                    return 2
+                print(f"Docker node selection: {selected}")
 
         elif args.command == "rm":
             docker.stack.rm(args.stack_name, namespace=args.namespace)

docker_stack/login.py

@@ -25,6 +25,7 @@ class DockerManagerLoginConfig:
     context_name: str
     timeout_secs: int
     skip_tls_verify: bool = False
+    docker_config_dir: Optional[Path] = None
 
     @property
     def docker_context_host(self) -> str:
@@ -60,6 +61,12 @@ class DockerManagerSetupAuthResult:
     validation_skipped: bool = False
 
 
+class UnknownShellContextError(RuntimeError):
+    def __init__(self, context_name: str):
+        self.context_name = context_name
+        super().__init__(f"Unknown shell context '{context_name}'")
+
+
 def normalize_loopback_host(url: str) -> str:
     if "127.0.0.1" in url:
         return url.replace("127.0.0.1", "localhost")
@@ -261,15 +268,23 @@ def resolve_login_config(
     current_context_name = None
     current_context_target = None
     inferred_context_name = None
+    resolved_docker_config_dir = None
     if not manager_url and not manager_target and not env_manager_value:
         current_context_name, current_context_target = current_docker_context_target()
 
     raw_manager_value = manager_url or manager_target or env_manager_value or current_context_target or "http://localhost:8080"
     if manager_target and "://" not in manager_target and ":" not in manager_target:
-        context_target = docker_context_target(manager_target)
+        isolated_config_dir = isolated_docker_config_dir(manager_target)
+        isolated_context_target = docker_context_target(
+            manager_target,
+            isolated_config_dir,
+        )
+        context_target = isolated_context_target or docker_context_target(manager_target)
         if context_target:
             raw_manager_value = context_target
             inferred_context_name = manager_target
+            if isolated_context_target:
+                resolved_docker_config_dir = isolated_config_dir
     if manager_target:
         resolved_manager_url, skip_tls_verify = detect_manager_url(raw_manager_value, verify_ssl=verify_ssl)
     elif manager_url:
@@ -296,6 +311,7 @@ def resolve_login_config(
         or "dm-proxy",
         timeout_secs=int(timeout_secs or os.getenv("DOCKER_MANAGER_LOGIN_TIMEOUT_SECS", "300")),
         skip_tls_verify=skip_tls_verify,
+        docker_config_dir=resolved_docker_config_dir,
     )
 
 
@@ -343,10 +359,7 @@ def resolve_shell_login_config(
         )
         target = persisted_target or docker_context_target(resolved_context_name)
         if not target:
-            raise RuntimeError(
-                f"Unknown shell context '{resolved_context_name}'. First run "
-                f"'docker-stack shell --context {resolved_context_name} <manager-host>'."
-            )
+            raise UnknownShellContextError(resolved_context_name)
         resolved_manager_url, skip_tls_verify = detect_manager_url(target)
         return DockerManagerLoginConfig(
             manager_url=resolved_manager_url,
@@ -618,6 +631,13 @@ def configure_docker_context_in_store(config: DockerManagerLoginConfig, docker_c
         raise RuntimeError((result.stderr or result.stdout or "failed to configure docker context").strip())
 
 
+def persist_shell_context(config: DockerManagerLoginConfig) -> Path:
+    config_dir = isolated_docker_config_dir(config.context_name)
+    ensure_isolated_docker_config(config_dir)
+    configure_docker_context_in_store(config, config_dir)
+    return config_dir
+
+
 def ensure_isolated_login(
     config: DockerManagerLoginConfig,
     *,

docker_stack/manager_api.py

@@ -18,6 +18,7 @@ from docker_stack.shell_auth import ensure_shell_access
 FEATURE_MESUDIP_DOCKER_ENTERPRISE = "mesudip-docker-enterprise-v1"
 FEATURE_STACK_QUERY = "docker_stack_query_v1"
 FEATURE_STACK_DEPLOY = "docker_stack_deploy_v1"
+FEATURE_CLUSTER_CONTAINER_CLI = "cluster_container_cli_v1"
 DEFAULT_NAMESPACE = "default"
 
 
@@ -429,10 +430,13 @@ class ManagerApiClient:
                 return False
         return True
 
-    def list_stacks(self) -> Dict[str, Any]:
+    def list_stacks(self, *, namespace: Optional[str] = DEFAULT_NAMESPACE) -> Dict[str, Any]:
+        query = urllib.parse.urlencode(
+            {"namespace": namespace} if namespace is not None else {"all_namespaces": "true"}
+        )
         if self._detect_manager_backend():
-            return self._request_json("/api/docker-stack/stacks")
-        return self._request_json(self._endpoint_path("/inventory/stacks"))
+            return self._request_json(f"/api/docker-stack/stacks?{query}")
+        return self._request_json(f"{self._endpoint_path('/inventory/stacks')}?{query}")
 
     def list_stack_versions(self, stack_name: str, *, namespace: str = DEFAULT_NAMESPACE) -> Dict[str, Any]:
         stack = urllib.parse.quote(stack_name, safe="")
@@ -487,6 +491,7 @@ class ManagerApiClient:
 
             nodes.append(
                 {
+                    "id": str(item.get("ID") or ""),
                     "hostname": str(description.get("Hostname") or spec.get("Name") or item.get("ID") or "-"),
                     "role": role,
                     "manager_status": manager_status,
@@ -499,6 +504,39 @@ class ManagerApiClient:
 
         return {"nodes": nodes}
 
+    def list_containers(
+        self,
+        *,
+        all_containers: bool = False,
+        filters: Optional[list[str]] = None,
+        limit: Optional[int] = None,
+        latest: bool = False,
+        size: bool = False,
+    ) -> Dict[str, Any]:
+        docker_filters: Dict[str, list[str]] = {}
+        for raw_filter in filters or []:
+            key, separator, value = raw_filter.partition("=")
+            key = key.strip()
+            if not key or not separator:
+                raise RuntimeError(f"Invalid Docker filter: {raw_filter}")
+            docker_filters.setdefault(key, []).append(value)
+        params: Dict[str, Any] = {
+            "all": "1" if all_containers else "0",
+            "size": "1" if size else "0",
+        }
+        if docker_filters:
+            params["filters"] = json.dumps(docker_filters, separators=(",", ":"))
+        if limit is not None:
+            params["limit"] = str(limit)
+        if latest:
+            params["latest"] = "1"
+        payload = self._request_json(
+            f"/api/docker-stack/containers?{urllib.parse.urlencode(params)}"
+        )
+        if not isinstance(payload, dict) or not isinstance(payload.get("containers"), list):
+            raise RuntimeError("Docker-Manager containers response is invalid")
+        return payload
+
     def resolve_config(
         self,
         *,

docker_stack/shell_auth.py

@@ -32,6 +32,7 @@ SHELL_SOCKET_ENV = "DOCKER_STACK_SHELL_SOCKET"
 SHELL_SECRET_ENV = "DOCKER_STACK_SHELL_SECRET"
 SHELL_CONTEXT_ENV = "DOCKER_STACK_SHELL_CONTEXT"
 SHELL_STATUS_ENV = "DOCKER_STACK_SHELL_STATUS"
+SHELL_NODE_STATE_ENV = "DOCKER_STACK_SHELL_NODE_STATE"
 SHELL_ORIGINAL_ZDOTDIR_ENV = "DOCKER_STACK_SHELL_ORIGINAL_ZDOTDIR"
 SHELL_AUTH_TIMEOUT_ENV = "DOCKER_STACK_SHELL_AUTH_TIMEOUT_SECS"
 
@@ -530,9 +531,11 @@ def _write_shell_wrappers(
     *,
     context_name: str,
     status_path: Path,
+    node_state_path: Optional[Path] = None,
 ) -> Dict[str, str]:
     context = _prompt_context(context_name)
     status_path_value = str(status_path)
+    node_state_path_value = str(node_state_path or status_path.with_name("node-selection"))
     no_color = bool(os.getenv("NO_COLOR"))
     bash_rc = session_dir / "bashrc"
     zsh_dir = session_dir / "zsh"
@@ -542,11 +545,18 @@ def _write_shell_wrappers(
         os.getenv(SHELL_ORIGINAL_ZDOTDIR_ENV) or os.getenv("ZDOTDIR", str(Path.home()))
     )
     original_zshrc = original_zshrc_root / ".zshrc"
+    original_zsh_history = original_zshrc_root / ".zsh_history"
     bash_rc.write_text(
         f'''[ -f {json.dumps(str(original_bashrc))} ] && source {json.dumps(str(original_bashrc))}
 __docker_stack_base_ps1="$PS1"
 __docker_stack_prompt_update() {{
-  local state expires now color reset
+  local state expires now color reset node
+  if [ -n "${{DOCKER_HOST:-}}" ]; then
+    color='\\[\\e[31m\\]'; reset='\\[\\e[0m\\]'
+    [ {str(no_color).lower()} = true ] && color= && reset=
+    PS1="${{color}}(docker:!DOCKER_HOST)${{reset}} ${{__docker_stack_base_ps1}}"
+    return
+  fi
   read -r state expires < {json.dumps(status_path_value)} 2>/dev/null || state=error
   now=$(date +%s)
   if [ "$state" = active ] && [ "${{expires:-0}}" -gt $((now + {REFRESH_WINDOW_SECS})) ]; then color='\\[\\e[32m\\]';
@@ -554,21 +564,35 @@ __docker_stack_prompt_update() {{
   else color='\\[\\e[31m\\]'; fi
   reset='\\[\\e[0m\\]'
   [ {str(no_color).lower()} = true ] && color= && reset=
-  PS1="${{color}}(docker:{context})${{reset}} ${{__docker_stack_base_ps1}}"
+  node=$(cat {json.dumps(node_state_path_value)} 2>/dev/null || printf cluster)
+  PS1="${{color}}(docker:{context}@${{node}})${{reset}} ${{__docker_stack_base_ps1}}"
 }}
 case ";${{PROMPT_COMMAND:-}};" in *';__docker_stack_prompt_update;'*) ;; *) PROMPT_COMMAND="__docker_stack_prompt_update${{PROMPT_COMMAND:+;$PROMPT_COMMAND}}";; esac
-docker() {{ docker-stack shell-auth ensure || return $?; command docker "$@"; }}
+docker() {{ docker-stack shell-auth ensure || return $?; docker-stack docker -- "$@"; }}
 ''',
         encoding="utf-8",
     )
     os.chmod(bash_rc, 0o600)
     zsh_rc = zsh_dir / ".zshrc"
     zsh_rc.write_text(
-        f'''[ -f {json.dumps(str(original_zshrc))} ] && source {json.dumps(str(original_zshrc))}
+        f'''typeset -g __docker_stack_session_zdotdir="$ZDOTDIR"
+typeset -g ZDOTDIR={json.dumps(str(original_zshrc_root))}
+typeset -g HISTFILE={json.dumps(str(original_zsh_history))}
+typeset -g SHELL_SESSION_HISTORY=0
+[ -f {json.dumps(str(original_zshrc))} ] && source {json.dumps(str(original_zshrc))}
+[[ -r "$HISTFILE" ]] && fc -R "$HISTFILE"
+typeset -g ZDOTDIR="$__docker_stack_session_zdotdir"
+unset __docker_stack_session_zdotdir
 autoload -Uz add-zsh-hook
 typeset -g __docker_stack_base_prompt="$PROMPT"
 __docker_stack_prompt_update() {{
-  local state expires now color reset
+  local state expires now color reset node
+  if [[ -n "${{DOCKER_HOST:-}}" ]]; then
+    color='%F{{red}}'; reset='%f'
+    [[ -n "${{NO_COLOR:-}}" ]] && color= && reset=
+    PROMPT="${{color}}(docker:!DOCKER_HOST)${{reset}} ${{__docker_stack_base_prompt}}"
+    return
+  fi
   read -r state expires < {json.dumps(status_path_value)} 2>/dev/null || state=error
   now=$(date +%s)
   if [[ "$state" = active && "${{expires:-0}}" -gt $((now + {REFRESH_WINDOW_SECS})) ]]; then color='%F{{green}}';
@@ -576,10 +600,11 @@ __docker_stack_prompt_update() {{
   else color='%F{{red}}'; fi
   reset='%f'
   [[ -n "${{NO_COLOR:-}}" ]] && color= && reset=
-  PROMPT="${{color}}(docker:{context})${{reset}} ${{__docker_stack_base_prompt}}"
+  node=$(cat {json.dumps(node_state_path_value)} 2>/dev/null || printf cluster)
+  PROMPT="${{color}}(docker:{context}@${{node}})${{reset}} ${{__docker_stack_base_prompt}}"
 }}
 add-zsh-hook precmd __docker_stack_prompt_update
-docker() {{ docker-stack shell-auth ensure || return $?; command docker "$@"; }}
+docker() {{ docker-stack shell-auth ensure || return $?; docker-stack docker -- "$@"; }}
 ''',
         encoding="utf-8",
     )
@@ -638,6 +663,9 @@ def run_managed_shell(config: DockerManagerLoginConfig, result: DockerManagerLog
         update_access_header(config_path, result.access_token)
         socket_path = session_dir / "auth.sock"
         status_path = session_dir / "status"
+        node_state_path = session_dir / "node-selection"
+        node_state_path.write_text("cluster\n", encoding="utf-8")
+        os.chmod(node_state_path, 0o600)
         shell_secret = os.urandom(32).hex()
         broker_env = dict(os.environ)
         for key in (SHELL_SOCKET_ENV, SHELL_SECRET_ENV, SHELL_CONTEXT_ENV, SHELL_STATUS_ENV):
@@ -689,12 +717,14 @@ def run_managed_shell(config: DockerManagerLoginConfig, result: DockerManagerLog
             shell,
             context_name=config.context_name,
             status_path=status_path,
+            node_state_path=node_state_path,
         )
         env = dict(os.environ)
         env[SHELL_SOCKET_ENV] = str(socket_path)
         env[SHELL_SECRET_ENV] = shell_secret
         env[SHELL_CONTEXT_ENV] = config.context_name
         env[SHELL_STATUS_ENV] = str(status_path)
+        env[SHELL_NODE_STATE_ENV] = str(node_state_path)
         env[SHELL_AUTH_TIMEOUT_ENV] = str(max(1, config.timeout_secs) + 5)
         env.update(wrapper_env)
         for key in ("DOCKER_HOST", "DOCKER_TLS_VERIFY", "DOCKER_CERT_PATH", "DOCKER_API_VERSION", "DOCKER_MACHINE_NAME"):

{docker_stack-2.1.1.dist-info → docker_stack-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docker-stack
-Version: 2.1.1
+Version: 2.2.0
 Summary: CLI for deploying and managing Docker stacks.
 Home-page: https://github.com/mesudip/docker-stack
 Author: Sudip Bhattarai
@@ -47,6 +47,8 @@ Typical daemon-only workflow:
 ```bash
 docker-stack deploy my-stack docker-compose.yml
 docker-stack ls
+docker-stack ls -n team-a
+docker-stack ls -A
 docker-stack versions my-stack
 docker-stack cat my-stack
 docker-stack checkout my-stack v2
@@ -82,7 +84,10 @@ Use this option when CI can connect directly to the target Docker daemon.
 
 #### 2. Docker-Manager
 
-Use the bundled action when deploying through Docker-Manager:
+Use the bundled action when deploying through
+[Docker-Manager](https://github.com/mesudip/docker-enterprise). The manager
+repository contains the server source, installation instructions, and deployment
+documentation.
 
 For a full compose deployment directly from CI, use the action to configure
 Docker-Manager authentication and then run the normal `docker-stack deploy`
@@ -152,11 +157,48 @@ Open an isolated Bash or Zsh session for a manager context:
 docker-stack shell office
 ```
 
-The prompt displays `(docker:office)`, keeps the selected manager context active,
+If `office` does not exist yet, the CLI asks for its Docker-Manager URL, creates
+the context, authenticates, and opens the shell. You can also provide everything
+non-interactively with `docker-stack shell --context office <manager-url>`.
+
+Stack commands use the `default` namespace unless `-n/--namespace` is supplied.
+Listings print the selected namespace; `docker-stack ls -A` (or
+`--all-namespaces`) lists every visible namespace.
+
+The prompt displays `(docker:office@cluster)`, keeps the selected manager context active,
 and refreshes authentication when needed. The session supports `docker` and
 `docker compose`; legacy `docker-compose` is not supported. If authentication
 expires, run `docker-stack login` again.
 
+Container listing is cluster-aware and includes the owning Swarm node. Select a
+node when working with daemon-local resources such as volumes and images:
+
+```bash
+docker ps
+docker-stack node current
+docker-stack node use worker-02
+docker volume ls
+docker image ls
+docker-stack node use cluster
+```
+
+Node selection is stored only in the managed shell's isolated Docker
+configuration and appears in the prompt as `(docker:office@worker-02)`.
+Selected-node requests remain subject to the manager's Docker permissions;
+image management is root-only because the manager does not define delegated
+image permissions.
+
+Cluster-aware output is enabled after the manager has observed compatible
+agents on every discovered node. The manager remembers that capability until it
+restarts, so a temporary agent outage does not make the CLI revert to a legacy
+feature decision. A partial cluster listing prints the available containers,
+reports each failed node on stderr with its incident id, and exits non-zero.
+
+`docker ps --quiet` and `docker ps --format ...` use Docker's native formatter
+and therefore do not add the `NODE` column. Explicit Docker overrides such as
+`--context`, `--host`/`-H`, and `--config` bypass managed cluster formatting and
+are sent unchanged to the Docker CLI.
+
 ## Core Capabilities
 
 -   **Advanced Deployments on Plain Docker Daemons:**

{docker_stack-2.1.1.dist-info → docker_stack-2.2.0.dist-info}/RECORD

@@ -1,20 +1,20 @@
 docker_stack/__init__.py,sha256=qgHdW8ZDBlyk6FzIf8Mld_cJD1SjOfqo2dELg4pK668,880
-docker_stack/cli.py,sha256=FknrFO67Xfp502XY_e_B3NzhSU3UFJFUo-6R-7ZBQPs,72160
+docker_stack/cli.py,sha256=yvBl8rI6GjpmgFyNBhP1shEDQUTTLjRJI2uzo8Q6xdg,88496
 docker_stack/command_runner.py,sha256=mNaUAVKtrJbji_5ARVPLKhc92avqllNKrVQj1A6S0dA,1252
 docker_stack/compose.py,sha256=_fAVesjyW5ecid46sYYhcu02yF1vqknDSCFYflJPDOE,534
 docker_stack/docker_objects.py,sha256=U6szytv5gKrmBYKqThSeMMXdiJ2u4STIQLkeqQ-Fn4Q,12103
 docker_stack/envsubst.py,sha256=gdEUpsjWJeNbbahySk56vUdQh1nns85o3LbU6SUBo3I,8337
 docker_stack/envsubst_merge.py,sha256=TwOu8BducG0rWnSreJGwesNi-VghCetljcf-aWceE8M,4971
 docker_stack/helpers.py,sha256=nJHaIS1vtFyPYclXVl3-Qd-1h55jnSy1LwdATDrF4hk,5953
-docker_stack/login.py,sha256=oueosAd_a_OP79L-f_Jmo6IW6BkG3q60p3vC-JcubBw,33194
-docker_stack/manager_api.py,sha256=VIwxpLjC6y9IliIguDYFxeKoJSuJ48KuNL_Z1fIZad4,26727
+docker_stack/login.py,sha256=SNHL2S3InQ7Qc3ITV1VySazix1f7H0OD7IvTPBTgF4Y,33977
+docker_stack/manager_api.py,sha256=xb8RwY4LEn1usg9qhG9AfiCvBJ2tpQawVMLRwF3vYHY,28361
 docker_stack/markers.py,sha256=gqStnr0tNWZ1kzqvREc2jVQVQrevheShgJtL5QzSx4g,2388
 docker_stack/merge_conf.py,sha256=Pmsabcgf3SDyaWvf2OLsBPodzEqsvOIjj9xzn_qWXH0,1917
 docker_stack/registry.py,sha256=sWC1J9JDIrcYyhei1POYCZHJ0xUCKC2pveisSHMgYsQ,9036
-docker_stack/shell_auth.py,sha256=waJgM4TdewzZw4XGQcWQzESRvC3xkT6p3NJFdpSuWao,31545
+docker_stack/shell_auth.py,sha256=em0_lo1qnLIB4KHYqn4vQvqwKe7HkV9NM_I0VQTDDQ4,33082
 docker_stack/url_parser.py,sha256=Sk8GQE0nEiwCkijp1OltP2AfgtKEmM2hybcH_rBhfiI,6824
-docker_stack-2.1.1.dist-info/METADATA,sha256=mqvsGzjJ2uwXf9KbrLVJ3r4iD-mn2I9o3zJeT_pKBMk,11901
-docker_stack-2.1.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-docker_stack-2.1.1.dist-info/entry_points.txt,sha256=mpe2RwIguARsosXIUBQEN2pKU53URqZCh2S4ATwDFL4,55
-docker_stack-2.1.1.dist-info/top_level.txt,sha256=zT6TPL54cLrt9LO_MNkhEpGGOmsoe2HV6Na5Ohy3_2c,13
-docker_stack-2.1.1.dist-info/RECORD,,
+docker_stack-2.2.0.dist-info/METADATA,sha256=xxDwMGLFu2AitS8ZFn0nOAVdTG-Z5yLxlfdW70qMkbg,13821
+docker_stack-2.2.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+docker_stack-2.2.0.dist-info/entry_points.txt,sha256=mpe2RwIguARsosXIUBQEN2pKU53URqZCh2S4ATwDFL4,55
+docker_stack-2.2.0.dist-info/top_level.txt,sha256=zT6TPL54cLrt9LO_MNkhEpGGOmsoe2HV6Na5Ohy3_2c,13
+docker_stack-2.2.0.dist-info/RECORD,,