appmesh 1.3.6__py3-none-any.whl → 1.3.8__py3-none-any.whl

appmesh/appmesh_client.py

@@ -1,1774 +1,8 @@
-#!/usr/bin/python3
-"""App Mesh Python SDK"""
-import abc
-import base64
-from contextlib import contextmanager
-import copy
-import json
-import os
-import socket
-import ssl
-import uuid
+# appmesh_client.py
 
-from enum import Enum, unique
-from datetime import datetime
-from http import HTTPStatus
-from typing import Optional, Tuple, Union
-from urllib import parse
+# Legacy Compatibility Layer
+# These imports provide backward compatibility for older code that relies on
+# AppMeshClient, App, and AppOutput classes. The updated implementation can be found
+# in http_client.py, where these classes are now primarily maintained.
 
-import aniso8601
-import requests
-
-# pylint: disable=broad-exception-raised,line-too-long,broad-exception-caught,too-many-lines, import-outside-toplevel, protected-access
-
-DURATION_ONE_WEEK_ISO = "P1W"
-DURATION_TWO_DAYS_ISO = "P2D"
-DURATION_TWO_DAYS_HALF_ISO = "P2DT12H"
-
-DEFAULT_SSL_CA_CERT_PATH = "/opt/appmesh/ssl/ca.pem"
-DEFAULT_SSL_CLIENT_CERT_PATH = "/opt/appmesh/ssl/client.pem"
-DEFAULT_SSL_CLIENT_KEY_PATH = "/opt/appmesh/ssl/client-key.pem"
-
-# TLS-optimized chunk size (slightly less than maximum TLS record size)
-# leaves some room for TLS overhead (like headers) within the 16 KB limit.
-TCP_BLOCK_SIZE = 16 * 1024 - 256  # target to 16KB
-TCP_HEADER_LENGTH = 4
-JSON_KEY_MESSAGE = "message"
-ENCODING_UTF8 = "utf-8"
-
-HTTP_USER_AGENT = "appmesh/python"
-HTTP_USER_AGENT_TCP = "appmesh/python/tcp"
-HTTP_HEADER_KEY_USER_AGENT = "User-Agent"
-HTTP_HEADER_KEY_X_SEND_FILE_SOCKET = "X-Send-File-Socket"
-HTTP_HEADER_KEY_X_RECV_FILE_SOCKET = "X-Recv-File-Socket"
-HTTP_HEADER_KEY_X_TARGET_HOST = "X-Target-Host"
-
-
-class App(object):
-    """
-    Represents an application in App Mesh, including configuration, resource limitations, behaviors, and permissions.
-    """
-
-    @staticmethod
-    def _get_str_item(data: dict, key: str) -> Optional[str]:
-        """Retrieve a string value from a dictionary by key, if it exists and is a valid string."""
-        return data[key] if (data and key in data and data[key] and isinstance(data[key], str)) else None
-
-    @staticmethod
-    def _get_int_item(data: dict, key: str) -> Optional[int]:
-        """Retrieve an integer value from a dictionary by key, if it exists and is a valid integer."""
-        return int(data[key]) if (data and key in data and data[key] and isinstance(data[key], int)) else None
-
-    @staticmethod
-    def _get_bool_item(data: dict, key: str) -> Optional[bool]:
-        """Retrieve a boolean value from a dictionary by key, if it exists and is boolean-like."""
-        return bool(data[key]) if (data and key in data and data[key]) else None
-
-    @staticmethod
-    def _get_native_item(data: dict, key: str) -> Optional[object]:
-        """Retrieve a deep copy of a value from a dictionary by key, if it exists."""
-        return copy.deepcopy(data[key]) if (data and key in data and data[key]) else None
-
-    @unique
-    class Permission(Enum):
-        """Defines application permission levels."""
-
-        DENY = "1"
-        READ = "2"
-        WRITE = "3"
-
-    class Behavior(object):
-        """
-        Manages application error handling behavior, including exit and control behaviors.
-        """
-
-        @unique
-        class Action(Enum):
-            """Defines actions for application exit behaviors."""
-
-            RESTART = "restart"
-            STANDBY = "standby"
-            KEEPALIVE = "keepalive"
-            REMOVE = "remove"
-
-        def __init__(self, data=None) -> None:
-            if isinstance(data, (str, bytes, bytearray)):
-                data = json.loads(data)
-
-            self.exit = App._get_str_item(data, "exit")
-            """Default exit behavior, options: 'restart', 'standby', 'keepalive', 'remove'."""
-
-            self.control = App._get_native_item(data, "control") or {}
-            """Exit code specific behavior (e.g, --control 0:restart --control 1:standby), higher priority than default exit behavior"""
-
-        def set_exit_behavior(self, action: Action) -> None:
-            """Set default behavior for application exit."""
-            self.exit = action.value
-
-        def set_control_behavior(self, control_code: int, action: Action) -> None:
-            """Define behavior for specific exit codes."""
-            self.control[str(control_code)] = action.value
-
-    class DailyLimitation(object):
-        """
-        Defines application availability within a daily time range.
-        """
-
-        def __init__(self, data=None) -> None:
-            if isinstance(data, (str, bytes, bytearray)):
-                data = json.loads(data)
-
-            self.daily_start = App._get_int_item(data, "daily_start")
-            """Start time for application availability (e.g., 09:00:00+08)."""
-
-            self.daily_end = App._get_int_item(data, "daily_end")
-            """End time for application availability (e.g., 20:00:00+08)."""
-
-        def set_daily_range(self, start: datetime, end: datetime) -> None:
-            """Set the valid daily start and end times."""
-            self.daily_start = int(start.timestamp())
-            self.daily_end = int(end.timestamp())
-
-    class ResourceLimitation(object):
-        """
-        Defines application resource limits, such as CPU and memory usage.
-        """
-
-        def __init__(self, data=None) -> None:
-            if isinstance(data, (str, bytes, bytearray)):
-                data = json.loads(data)
-
-            self.cpu_shares = App._get_int_item(data, "cpu_shares")
-            """CPU shares, relative weight of CPU usage."""
-
-            self.memory_mb = App._get_int_item(data, "memory_mb")
-            """Physical memory limit in MB."""
-
-            self.memory_virt_mb = App._get_int_item(data, "memory_virt_mb")
-            """Virtual memory limit in MB."""
-
-    def __init__(self, data=None) -> None:
-        """Initialize an App instance with optional configuration data."""
-        if isinstance(data, (str, bytes, bytearray)):
-            data = json.loads(data)
-
-        self.name = App._get_str_item(data, "name")
-        """application name (unique)"""
-        self.command = App._get_str_item(data, "command")
-        """full command line with arguments"""
-        self.shell = App._get_bool_item(data, "shell")
-        """use shell mode, cmd can be more shell commands with string format"""
-        self.session_login = App._get_bool_item(data, "session_login")
-        """app run in session login mode"""
-        self.description = App._get_str_item(data, "description")
-        """application description string"""
-        self.metadata = App._get_native_item(data, "metadata")
-        """metadata string/JSON (input for application, pass to process stdin)"""
-        self.working_dir = App._get_str_item(data, "working_dir")
-        """working directory"""
-        self.status = App._get_int_item(data, "status")
-        """initial application status (true is enable, false is disabled)"""
-        self.docker_image = App._get_str_item(data, "docker_image")
-        """docker image which used to run command line (for docker container application)"""
-        self.stdout_cache_num = App._get_int_item(data, "stdout_cache_num")
-        """stdout file cache number"""
-        self.start_time = App._get_int_item(data, "start_time")
-        """start date time for app (ISO8601 time format, e.g., '2020-10-11T09:22:05')"""
-        self.end_time = App._get_int_item(data, "end_time")
-        """end date time for app (ISO8601 time format, e.g., '2020-10-11T10:22:05')"""
-        self.interval = App._get_int_item(data, "interval")
-        """start interval seconds for short running app, support ISO 8601 durations and cron expression (e.g., 'P1Y2M3DT4H5M6S' 'P5W' '* */5 * * * *')"""
-        self.cron = App._get_bool_item(data, "cron")
-        """indicate interval parameter use cron expression or not"""
-        self.daily_limitation = App.DailyLimitation(App._get_native_item(data, "daily_limitation"))
-        self.retention = App._get_str_item(data, "retention")
-        """extra timeout seconds for stopping current process, support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P5W')."""
-        self.health_check_cmd = App._get_str_item(data, "health_check_cmd")
-        """health check script command (e.g., sh -x 'curl host:port/health', return 0 is health)"""
-        self.permission = App._get_int_item(data, "permission")
-        """application user permission, value is 2 bit integer: [group & other], each bit can be deny:1, read:2, write: 3."""
-        self.behavior = App.Behavior(App._get_native_item(data, "behavior"))
-
-        self.env = data.get("env", {}) if data else {}
-        """environment variables (e.g., -e env1=value1 -e env2=value2, APP_DOCKER_OPTS is used to input docker run parameters)"""
-        self.sec_env = data.get("sec_env", {}) if data else {}
-        """security environment variables, encrypt in server side with application owner's cipher"""
-        self.pid = App._get_int_item(data, "pid")
-        """process id used to attach to the running process"""
-        self.resource_limit = App.ResourceLimitation(App._get_native_item(data, "resource_limit"))
-
-        # Read-only attributes
-        self.owner = App._get_str_item(data, "owner")
-        """owner name"""
-        self.pstree = App._get_str_item(data, "pstree")
-        """process tree"""
-        self.container_id = App._get_str_item(data, "container_id")
-        """container id"""
-        self.memory = App._get_int_item(data, "memory")
-        """memory usage"""
-        self.cpu = App._get_int_item(data, "cpu")
-        """cpu usage"""
-        self.fd = App._get_int_item(data, "fd")
-        """file descriptor usage"""
-        self.last_start_time = App._get_int_item(data, "last_start_time")
-        """last start time"""
-        self.last_exit_time = App._get_int_item(data, "last_exit_time")
-        """last exit time"""
-        self.health = App._get_int_item(data, "health")
-        """health status"""
-        self.version = App._get_int_item(data, "version")
-        """version number"""
-        self.return_code = App._get_int_item(data, "return_code")
-        """last exit code"""
-
-    def set_valid_time(self, start: datetime, end: datetime) -> None:
-        """Define the valid time window for the application."""
-        self.start_time = int(start.timestamp()) if start else None
-        self.end_time = int(end.timestamp()) if end else None
-
-    def set_env(self, key: str, value: str, secure: bool = False) -> None:
-        """Set an environment variable, marking it secure if specified."""
-        (self.sec_env if secure else self.env)[key] = value
-
-    def set_permission(self, group_user: Permission, others_user: Permission) -> None:
-        """Define application permissions based on user roles."""
-        self.permission = int(group_user.value + others_user.value)
-
-    def __str__(self) -> str:
-        """Return a JSON string representation of the application."""
-        return json.dumps(self.json())
-
-    def json(self) -> dict:
-        """Convert the application data into a JSON-compatible dictionary, removing empty items."""
-        output = copy.deepcopy(self.__dict__)
-        output["behavior"] = self.behavior.__dict__
-        output["daily_limitation"] = self.daily_limitation.__dict__
-        output["resource_limit"] = self.resource_limit.__dict__
-
-        def clean_empty(data: dict) -> None:
-            keys_to_delete = []
-            for key, value in data.items():
-                if isinstance(value, dict) and key != "metadata":
-                    clean_empty(value)  # Recursive call (without check user metadata)
-                if data[key] in [None, "", {}]:
-                    keys_to_delete.append(key)  # Mark keys for deletion
-
-            for key in keys_to_delete:  # Delete keys after the loop to avoid modifying dict during iteration
-                del data[key]
-
-        clean_empty(output)
-        return output
-
-
-class AppOutput(object):
-    """
-    Represents the output information returned by the `app_output()` API, including the application's
-    stdout content, current read position, status code, and exit code.
-    """
-
-    def __init__(self, status_code: HTTPStatus, output: str, out_position: Optional[int], exit_code: Optional[int]) -> None:
-        self.status_code = status_code
-        """HTTP status code from the `app_output()` API request, indicating the result status."""
-
-        self.output = output
-        """Captured stdout content of the application as returned by the `app_output()` API."""
-
-        self.out_position = out_position
-        """Current read position in the application's stdout stream, or `None` if not applicable."""
-
-        self.exit_code = exit_code
-        """Exit code of the application, or `None` if the process is still running or hasn't exited."""
-
-
-class AppRun(object):
-    """
-    Represents an application run object initiated by `run_async()` for monitoring and retrieving
-    the result of a remote application run.
-    """
-
-    def __init__(self, client, app_name: str, process_id: str):
-        self.app_name = app_name
-        """Name of the application associated with this run."""
-
-        self.proc_uid = process_id
-        """Unique process ID from `run_async()`."""
-
-        self._client = client
-        """Instance of `AppMeshClient` used to manage this application run."""
-
-        self._forwarding_host = client.forwarding_host
-        """Target server for the application run, used for forwarding."""
-
-    @contextmanager
-    def forwarding_host(self):
-        """Context manager to override the `forwarding_host` for the duration of the run."""
-        original_value = self._client.forwarding_host
-        self._client.forwarding_host = self._forwarding_host
-        try:
-            yield
-        finally:
-            self._client.forwarding_host = original_value
-
-    def wait(self, stdout_print: bool = True, timeout: int = 0) -> int:
-        """Wait for the asynchronous run to complete.
-
-        Args:
-            stdout_print (bool, optional): If `True`, prints remote stdout to local. Defaults to `True`.
-            timeout (int, optional): Maximum time to wait in seconds. If `0`, waits until completion. Defaults to `0`.
-
-        Returns:
-            int: Exit code if the process finishes successfully. Returns `None` on timeout or exception.
-        """
-        with self.forwarding_host():
-            return self._client.run_async_wait(self, stdout_print, timeout)
-
-
-class AppMeshClient(metaclass=abc.ABCMeta):
-    """
-    Client SDK for interacting with the App Mesh service via REST API.
-
-    The `AppMeshClient` class provides a comprehensive interface for managing and monitoring distributed applications
-    within the App Mesh ecosystem. It enables communication with the App Mesh REST API for operations such as
-    application lifecycle management, monitoring, and configuration.
-
-    This client is designed for direct usage in applications that require access to App Mesh services over HTTP-based REST.
-
-    Usage:
-        - Install the App Mesh Python package:
-            python3 -m pip install --upgrade appmesh
-        - Import the client module:
-            from appmesh import appmesh_client
-
-    Example:
-        client = appmesh_client.AppMeshClient()
-        client.login("your-name", "your-password")
-        response = client.app_view(app_name='ping')
-
-    Attributes:
-        - TLS (Transport Layer Security): Supports secure connections between the client and App Mesh service,
-          ensuring encrypted communication.
-        - JWT (JSON Web Token) and RBAC (Role-Based Access Control): Provides secure API access with
-          token-based authentication and authorization to enforce fine-grained permissions.
-
-    Methods:
-        - login()
-        - logoff()
-        - authentication()
-        - renew()
-        - totp_disable()
-        - totp_secret()
-        - totp_setup()
-
-        - app_add()
-        - app_delete()
-        - app_disable()
-        - app_enable()
-        - app_health()
-        - app_output()
-        - app_view()
-        - app_view_all()
-
-        - run_async()
-        - run_async_wait()
-        - run_sync()
-
-        - config_set()
-        - config_view()
-        - log_level_set()
-        - host_resource()
-        - forwarding_host
-        - metrics()
-
-        - tag_add()
-        - tag_delete()
-        - tag_view()
-
-        - file_download()
-        - file_upload()
-
-        - user_add()
-        - user_delete()
-        - user_lock()
-        - user_passwd_update()
-        - user_self()
-        - user_unlock()
-        - users_view()
-        - permissions_for_user()
-        - permissions_view()
-        - role_delete()
-        - role_update()
-        - roles_view()
-        - groups_view()
-    """
-
-    @unique
-    class Method(Enum):
-        """REST methods"""
-
-        GET = "GET"
-        PUT = "PUT"
-        POST = "POST"
-        DELETE = "DELETE"
-        POST_STREAM = "POST_STREAM"
-
-    def __init__(
-        self,
-        rest_url: str = "https://127.0.0.1:6060",
-        rest_ssl_verify=DEFAULT_SSL_CA_CERT_PATH if os.path.exists(DEFAULT_SSL_CA_CERT_PATH) else False,
-        rest_ssl_client_cert=(DEFAULT_SSL_CLIENT_CERT_PATH, DEFAULT_SSL_CLIENT_KEY_PATH) if os.path.exists(DEFAULT_SSL_CLIENT_CERT_PATH) else None,
-        rest_timeout=(60, 300),
-        jwt_token=None,
-    ):
-        """Initialize an App Mesh HTTP client for interacting with the App Mesh server via secure HTTPS.
-
-        Args:
-            rest_url (str, optional): The server's base URI, including protocol, hostname, and port. Defaults to `"https://127.0.0.1:6060"`.
-
-            rest_ssl_verify (Union[bool, str], optional): Configures SSL certificate verification for HTTPS requests:
-                - `True`: Uses system CA certificates to verify the server's identity.
-                - `False`: Disables SSL verification (insecure, use cautiously for development).
-                - `str`: Path to a custom CA certificate or directory for verification. This option allows custom CA configuration,
-                which may be necessary in environments requiring specific CA chains that differ from the default system CAs.
-
-            rest_ssl_client_cert (Union[tuple, str], optional): Specifies a client certificate for mutual TLS authentication:
-                - If a `str`, provides the path to a PEM file with both client certificate and private key.
-                - If a `tuple`, contains two paths as (`cert`, `key`), where `cert` is the certificate file and `key` is the private key file.
-
-            rest_timeout (tuple, optional): HTTP connection timeouts for API requests, as `(connect_timeout, read_timeout)`.
-                The default is `(60, 300)`, where `60` seconds is the maximum time to establish a connection and `300` seconds for the maximum read duration.
-
-            jwt_token (str, optional): JWT token for API authentication, used in headers to authorize requests where required.
-
-        """
-
-        self.server_url = rest_url
-        self._jwt_token = jwt_token
-        self.ssl_verify = rest_ssl_verify
-        self.ssl_client_cert = rest_ssl_client_cert
-        self.rest_timeout = rest_timeout
-        self._forwarding_host = None
-
-    @property
-    def jwt_token(self) -> str:
-        """property for jwt_token
-
-        Returns:
-            str: _description_
-        """
-        return self._jwt_token
-
-    @jwt_token.setter
-    def jwt_token(self, token: str) -> None:
-        """setter for jwt_token
-
-        Args:
-            token (str): _description_
-        """
-        self._jwt_token = token
-
-    @property
-    def forwarding_host(self) -> str:
-        """property for forwarding_host
-
-        Returns:
-            str: forward request to target host (host:port)
-        """
-        return self._forwarding_host
-
-    @forwarding_host.setter
-    def forwarding_host(self, host: str) -> None:
-        """setter for forwarding_host
-
-        Args:
-            host (str): forward request to target host (host:port)
-        """
-        self._forwarding_host = host
-
-    ########################################
-    # Security
-    ########################################
-    def login(self, user_name: str, user_pwd: str, totp_code="", timeout_seconds=DURATION_ONE_WEEK_ISO) -> str:
-        """Login with user name and password
-
-        Args:
-            user_name (str): the name of the user.
-            user_pwd (str): the password of the user.
-            totp_code (str, optional): the TOTP code if enabled for the user.
-            timeout_seconds (int | str, optional): token expire timeout of seconds. support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P1W').
-
-        Returns:
-            str: JWT token.
-        """
-        self.jwt_token = None
-        resp = self._request_http(
-            AppMeshClient.Method.POST,
-            path="/appmesh/login",
-            header={
-                "Authorization": "Basic " + base64.b64encode((user_name + ":" + user_pwd).encode()).decode(),
-                "Expire-Seconds": self._parse_duration(timeout_seconds),
-            },
-        )
-        if resp.status_code == HTTPStatus.OK:
-            if "Access-Token" in resp.json():
-                self.jwt_token = resp.json()["Access-Token"]
-        elif resp.status_code == HTTPStatus.UNAUTHORIZED and "Totp-Challenge" in resp.json():
-            challenge = resp.json()["Totp-Challenge"]
-            resp = self._request_http(
-                AppMeshClient.Method.POST,
-                path="/appmesh/totp/validate",
-                header={
-                    "Username": base64.b64encode(user_name.encode()).decode(),
-                    "Totp-Challenge": base64.b64encode(challenge.encode()).decode(),
-                    "Totp": totp_code,
-                    "Expire-Seconds": self._parse_duration(timeout_seconds),
-                },
-            )
-            if resp.status_code == HTTPStatus.OK:
-                if "Access-Token" in resp.json():
-                    self.jwt_token = resp.json()["Access-Token"]
-            else:
-                raise Exception(resp.text)
-        else:
-            raise Exception(resp.text)
-        return self.jwt_token
-
-    def logoff(self) -> bool:
-        """Logoff current session from server
-
-        Returns:
-            bool: logoff success or failure.
-        """
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/self/logoff")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        self.jwt_token = None
-        return resp.status_code == HTTPStatus.OK
-
-    def authentication(self, token: str, permission=None) -> bool:
-        """Login with token and verify permission when specified,
-           verified token will be stored in client object when success
-
-        Args:
-            token (str): JWT token returned from login().
-            permission (str, optional): the permission ID used to verify the token user
-                permission ID can be:
-                - pre-defined by App Mesh from security.yaml (e.g 'app-view', 'app-delete')
-                - defined by input from role_update() or security.yaml
-
-        Returns:
-            bool: authentication success or failure.
-        """
-        old_token = self.jwt_token
-        self.jwt_token = token
-        headers = {}
-        if permission:
-            headers["Auth-Permission"] = permission
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/auth", header=headers)
-        if resp.status_code != HTTPStatus.OK:
-            self.jwt_token = old_token
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def renew(self, timeout_seconds=DURATION_ONE_WEEK_ISO) -> str:
-        """Renew current token
-
-        Args:
-            timeout_seconds (int | str, optional): token expire timeout of seconds. support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P1W').
-
-        Returns:
-            str: The new JWT token if renew success, otherwise return None.
-        """
-        assert self.jwt_token
-        resp = self._request_http(
-            AppMeshClient.Method.POST,
-            path="/appmesh/token/renew",
-            header={
-                "Expire-Seconds": self._parse_duration(timeout_seconds),
-            },
-        )
-        if resp.status_code == HTTPStatus.OK:
-            if "Access-Token" in resp.json():
-                self.jwt_token = resp.json()["Access-Token"]
-                return self.jwt_token
-        raise Exception(resp.text)
-
-    def totp_secret(self) -> str:
-        """Generate TOTP secret for current login user and return MFA URI with JSON body
-
-        Returns:
-            str: TOTP secret str
-        """
-        resp = self._request_http(method=AppMeshClient.Method.POST, path="/appmesh/totp/secret")
-        if resp.status_code == HTTPStatus.OK:
-            totp_uri = base64.b64decode(resp.json()["Mfa-Uri"]).decode()
-            return self._parse_totp_uri(totp_uri).get("secret")
-        raise Exception(resp.text)
-
-    def totp_setup(self, totp_code: str) -> bool:
-        """Setup 2FA for current login user
-
-        Args:
-            totp_code (str): TOTP code
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(
-            method=AppMeshClient.Method.POST,
-            path="/appmesh/totp/setup",
-            header={"Totp": totp_code},
-        )
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def totp_disable(self, user="self") -> bool:
-        """Disable 2FA for current user
-
-        Args:
-            user (str, optional): user name for disable TOTP.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(
-            method=AppMeshClient.Method.POST,
-            path=f"/appmesh/totp/{user}/disable",
-        )
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    @staticmethod
-    def _parse_totp_uri(totp_uri: str) -> dict:
-        """Extract TOTP parameters
-
-        Args:
-            totp_uri (str): TOTP uri
-
-        Returns:
-            dict: eextract parameters
-        """
-        parsed_info = {}
-        parsed_uri = parse.urlparse(totp_uri)
-
-        # Extract label from the path
-        parsed_info["label"] = parsed_uri.path[1:]  # Remove the leading slash
-
-        # Extract parameters from the query string
-        query_params = parse.parse_qs(parsed_uri.query)
-        for key, value in query_params.items():
-            parsed_info[key] = value[0]
-        return parsed_info
-
-    ########################################
-    # Application view
-    ########################################
-    def app_view(self, app_name: str) -> App:
-        """Get one application information
-
-        Args:
-            app_name (str): the application name.
-
-        Returns:
-            App: the application object both contain static configuration and runtime information.
-
-        Exception:
-            failed request or no such application
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path=f"/appmesh/app/{app_name}")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return App(resp.json())
-
-    def app_view_all(self):
-        """Get all applications
-
-        Returns:
-            list: the application object both contain static configuration and runtime information, only return applications that the user has permissions.
-
-        Exception:
-            failed request or no such application
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/applications")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        apps = []
-        for app in resp.json():
-            apps.append(App(app))
-        return apps
-
-    def app_output(self, app_name: str, stdout_position: int = 0, stdout_index: int = 0, stdout_maxsize: int = 10240, process_uuid: str = "", timeout: int = 0) -> AppOutput:
-        """Get application stdout/stderr
-
-        Args:
-            app_name (str): the application name
-            stdout_position (int, optional): start read position, 0 means start from beginning.
-            stdout_index (int, optional): index of history process stdout, 0 means get from current running process,
-                the stdout number depends on 'stdout_cache_size' of the application.
-            stdout_maxsize (int, optional): max buffer size to read.
-            process_uuid (str, optional): used to get the specified process.
-            timeout (int, optional): wait for the running process for some time(seconds) to get the output.
-
-        Returns:
-            AppOutput object.
-        """
-        resp = self._request_http(
-            AppMeshClient.Method.GET,
-            path=f"/appmesh/app/{app_name}/output",
-            query={
-                "stdout_position": str(stdout_position),
-                "stdout_index": str(stdout_index),
-                "stdout_maxsize": str(stdout_maxsize),
-                "process_uuid": process_uuid,
-                "timeout": str(timeout),
-            },
-        )
-        out_position = int(resp.headers["Output-Position"]) if "Output-Position" in resp.headers else None
-        exit_code = int(resp.headers["Exit-Code"]) if "Exit-Code" in resp.headers else None
-        return AppOutput(status_code=resp.status_code, output=resp.text, out_position=out_position, exit_code=exit_code)
-
-    def app_health(self, app_name: str) -> bool:
-        """Get application health status
-
-        Args:
-            app_name (str): the application name.
-
-        Returns:
-            bool: healthy or not
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path=f"/appmesh/app/{app_name}/health")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return int(resp.text) == 0
-
-    ########################################
-    # Application manage
-    ########################################
-    def app_add(self, app: App) -> App:
-        """Register an application
-
-        Args:
-            app (App): the application definition.
-
-        Returns:
-            App: resigtered application object.
-
-        Exception:
-            failed request
-        """
-        resp = self._request_http(AppMeshClient.Method.PUT, path=f"/appmesh/app/{app.name}", body=app.json())
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return App(resp.json())
-
-    def app_delete(self, app_name: str) -> bool:
-        """Remove an application.
-
-        Args:
-            app_name (str): the application name.
-
-        Returns:
-            bool: True for delete success, Flase for not exist anymore.
-        """
-        resp = self._request_http(AppMeshClient.Method.DELETE, path=f"/appmesh/app/{app_name}")
-        if resp.status_code == HTTPStatus.OK:
-            return True
-        elif resp.status_code == HTTPStatus.NOT_FOUND:
-            return False
-        else:
-            raise Exception(resp.text)
-
-    def app_enable(self, app_name: str) -> bool:
-        """Enable an application
-
-        Args:
-            app_name (str): the application name.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(AppMeshClient.Method.POST, path=f"/appmesh/app/{app_name}/enable")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def app_disable(self, app_name: str) -> bool:
-        """Stop and disable an application
-
-        Args:
-            app_name (str): the application name.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(AppMeshClient.Method.POST, path=f"/appmesh/app/{app_name}/disable")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    ########################################
-    # Cloud management
-    ########################################
-    def cloud_app_view_all(self) -> dict:
-        """Get all cloud applications
-
-        Returns:
-            dict: cloud applications in JSON format.
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/cloud/applications")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def cloud_app(self, app_name: str) -> dict:
-        """Get an cloud application
-
-        Args:
-            app_name (str): the application name.
-
-        Returns:
-            dict: application in JSON format.
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path=f"/appmesh/cloud/app/{app_name}")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def cloud_app_output(self, app_name: str, host_name: str, stdout_position: int = 0, stdout_index: int = 0, stdout_maxsize: int = 10240, process_uuid: str = ""):
-        """Get cloud application stdout/stderr from master agent
-
-        Args:
-            app_name (str): the application name
-            host_name (str): the target host name where the application is running
-            stdout_position (int, optional): start read position, 0 means start from beginning.
-            stdout_index (int, optional): index of history process stdout, 0 means get from current running process,
-                the stdout number depends on 'stdout_cache_size' of the application.
-            stdout_maxsize (int, optional): max buffer size to read.
-            process_uuid (str, optional): used to get the specified process.
-
-        Returns:
-            bool: success or failure.
-            str: output string.
-            int or None: current read position.
-            int or None: process exit code.
-        """
-        resp = self._request_http(
-            AppMeshClient.Method.GET,
-            path=f"/appmesh/cloud/app/{app_name}/output/{host_name}",
-            query={
-                "stdout_position": str(stdout_position),
-                "stdout_index": str(stdout_index),
-                "stdout_maxsize": str(stdout_maxsize),
-                "process_uuid": process_uuid,
-            },
-        )
-        out_position = int(resp.headers["Output-Position"]) if "Output-Position" in resp.headers else None
-        exit_code = int(resp.headers["Exit-Code"]) if "Exit-Code" in resp.headers else None
-        return (resp.status_code == HTTPStatus.OK), resp.text, out_position, exit_code
-
-    def cloud_app_delete(self, app_name: str) -> bool:
-        """Delete a cloud application
-
-        Args:
-            app_name (str): The application name for cloud
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(AppMeshClient.Method.DELETE, path=f"/appmesh/cloud/app/{app_name}")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def cloud_app_add(self, app_json: dict) -> dict:
-        """Add a cloud application
-
-        Args:
-            app_json (dict): the cloud application definition with replication, condition and resource requirement
-
-         Returns:
-            dict: cluster application json.
-        """
-        resp = self._request_http(AppMeshClient.Method.PUT, path=f"/appmesh/cloud/app/{app_json['content']['name']}", body=app_json)
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def cloud_nodes(self) -> dict:
-        """Get cluster node list
-
-        Returns:
-            dict: cluster node list json.
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/cloud/nodes")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    ########################################
-    # Configuration
-    ########################################
-    def host_resource(self) -> dict:
-        """Get App Mesh host resource report include CPU, memory and disk
-
-        Returns:
-            dict: the host resource json.
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/resources")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def config_view(self) -> dict:
-        """Get App Mesh configuration JSON
-
-        Returns:
-            dict: the configuration json.
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/config")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def config_set(self, cfg_json) -> dict:
-        """Update configuration, the format follow 'config.yaml', support partial update
-
-        Args:
-            cfg_json (dict): the new configuration json.
-
-        Returns:
-            dict: the updated configuration json.
-        """
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/config", body=cfg_json)
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def log_level_set(self, level: str = "DEBUG") -> str:
-        """Update App Mesh log level(DEBUG/INFO/NOTICE/WARN/ERROR), a wrapper of config_set()
-
-        Args:
-            level (str, optional): log level.
-
-        Returns:
-            str: the updated log level.
-        """
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/config", body={"BaseConfig": {"LogLevel": level}})
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()["BaseConfig"]["LogLevel"]
-
-    ########################################
-    # User Management
-    ########################################
-    def user_passwd_update(self, new_password: str, user_name: str = "self") -> bool:
-        """Change user password
-
-        Args:
-            user_name (str): the user name.
-            new_password (str):the new password string
-
-        Returns:
-            bool: success
-        """
-        resp = self._request_http(
-            method=AppMeshClient.Method.POST,
-            path=f"/appmesh/user/{user_name}/passwd",
-            header={"New-Password": base64.b64encode(new_password.encode())},
-        )
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return True
-
-    def user_add(self, user_name: str, user_json: dict) -> bool:
-        """Add a new user, not available for LDAP user
-
-        Args:
-            user_name (str): the user name.
-            user_json (dict): user definition, follow same user format from security.yaml.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(
-            method=AppMeshClient.Method.PUT,
-            path=f"/appmesh/user/{user_name}",
-            body=user_json,
-        )
-        return resp.status_code == HTTPStatus.OK
-
-    def user_delete(self, user_name: str) -> bool:
-        """Delete a user
-
-        Args:
-            user_name (str): the user name.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(
-            method=AppMeshClient.Method.DELETE,
-            path=f"/appmesh/user/{user_name}",
-        )
-        return resp.status_code == HTTPStatus.OK
-
-    def user_lock(self, user_name: str) -> bool:
-        """Lock a user
-
-        Args:
-            user_name (str): the user name.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(
-            method=AppMeshClient.Method.POST,
-            path=f"/appmesh/user/{user_name}/lock",
-        )
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def user_unlock(self, user_name: str) -> bool:
-        """Unlock a user
-
-        Args:
-            user_name (str): the user name.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(
-            method=AppMeshClient.Method.POST,
-            path=f"/appmesh/user/{user_name}/unlock",
-        )
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def users_view(self) -> dict:
-        """Get all users
-
-        Returns:
-            dict: all user definition
-        """
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/users")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def user_self(self) -> dict:
-        """Get current user infomation
-
-        Returns:
-            dict: user definition.
-        """
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/user/self")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def groups_view(self) -> list:
-        """Get all user groups
-
-        Returns:
-            dict: user group array.
-        """
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/user/groups")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def permissions_view(self) -> list:
-        """Get all available permissions
-
-        Returns:
-            dict: permission array
-        """
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/permissions")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def permissions_for_user(self) -> list:
-        """Get current user permissions
-
-        Returns:
-            dict: user permission array.
-        """
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/user/permissions")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def roles_view(self) -> list:
-        """Get all roles with permission definition
-
-        Returns:
-            dict: all role definition.
-        """
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/roles")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    def role_update(self, role_name: str, role_permission_json: dict) -> bool:
-        """Update (or add) a role with defined permissions, the permission ID can be App Mesh pre-defined or other permission ID.
-
-        Args:
-            role_name (str): the role name.
-            role_permission_json (dict): role permission definition array, e.g: ["app-control", "app-delete", "cloud-app-reg", "cloud-app-delete"]
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(method=AppMeshClient.Method.POST, path=f"/appmesh/role/{role_name}", body=role_permission_json)
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def role_delete(self, role_name: str) -> bool:
-        """Delete a user role
-
-        Args:
-            role_name (str): the role name.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(
-            method=AppMeshClient.Method.DELETE,
-            path=f"/appmesh/role/{role_name}",
-        )
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    ########################################
-    # Tag management
-    ########################################
-    def tag_add(self, tag_name: str, tag_value: str) -> bool:
-        """Add a new label
-
-        Args:
-            tag_name (str): the label name.
-            tag_value (str): the label value.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(
-            AppMeshClient.Method.PUT,
-            query={"value": tag_value},
-            path=f"/appmesh/label/{tag_name}",
-        )
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def tag_delete(self, tag_name: str) -> bool:
-        """Delete a label
-
-        Args:
-            tag_name (str): the label name.
-
-        Returns:
-            bool: success or failure.
-        """
-        resp = self._request_http(AppMeshClient.Method.DELETE, path=f"/appmesh/label/{tag_name}")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.status_code == HTTPStatus.OK
-
-    def tag_view(self) -> dict:
-        """Get the server labels
-
-        Returns:
-            dict: label data.
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/labels")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.json()
-
-    ########################################
-    # Promethus metrics
-    ########################################
-    def metrics(self):
-        """Prometheus metrics (this does not call Prometheus API /metrics, just copy the same metrics data)
-
-        Returns:
-            str: prometheus metrics texts
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/metrics")
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-        return resp.text
-
-    ########################################
-    # File management
-    ########################################
-    def file_download(self, remote_file: str, local_file: str, apply_file_attributes: bool = True) -> None:
-        """Copy a remote file to local. Optionally, the local file will have the same permission as the remote file.
-
-        Args:
-            remote_file (str): the remote file path.
-            local_file (str): the local file path to be downloaded.
-            apply_file_attributes (bool): whether to apply file attributes (permissions, owner, group) to the local file.
-        """
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/file/download", header={"File-Path": remote_file})
-        resp.raise_for_status()
-
-        # Write the file content locally
-        with open(local_file, "wb") as fp:
-            for chunk in resp.iter_content(chunk_size=8 * 1024):  # 8 KB
-                if chunk:
-                    fp.write(chunk)
-
-        # Apply file attributes (permissions, owner, group) if requested
-        if apply_file_attributes:
-            if "File-Mode" in resp.headers:
-                os.chmod(path=local_file, mode=int(resp.headers["File-Mode"]))
-            if "File-User" in resp.headers and "File-Group" in resp.headers:
-                file_uid = int(resp.headers["File-User"])
-                file_gid = int(resp.headers["File-Group"])
-                try:
-                    os.chown(path=local_file, uid=file_uid, gid=file_gid)
-                except PermissionError:
-                    print(f"Warning: Unable to change owner/group of {local_file}. Operation requires elevated privileges.")
-
-    def file_upload(self, local_file: str, remote_file: str, apply_file_attributes: bool = True) -> None:
-        """Upload a local file to the remote server. Optionally, the remote file will have the same permission as the local file.
-
-        Dependency:
-            sudo apt install python3-pip
-            pip3 install requests_toolbelt
-
-        Args:
-            local_file (str): the local file path.
-            remote_file (str): the target remote file to be uploaded.
-            apply_file_attributes (bool): whether to upload file attributes (permissions, owner, group) along with the file.
-        """
-        if not os.path.exists(local_file):
-            raise FileNotFoundError(f"Local file not found: {local_file}")
-
-        from requests_toolbelt import MultipartEncoder
-
-        with open(file=local_file, mode="rb") as fp:
-            encoder = MultipartEncoder(fields={"filename": os.path.basename(remote_file), "file": ("filename", fp, "application/octet-stream")})
-            header = {"File-Path": remote_file, "Content-Type": encoder.content_type}
-
-            # Include file attributes (permissions, owner, group) if requested
-            if apply_file_attributes:
-                file_stat = os.stat(local_file)
-                header["File-Mode"] = str(file_stat.st_mode & 0o777)  # Mask to keep only permission bits
-                header["File-User"] = str(file_stat.st_uid)
-                header["File-Group"] = str(file_stat.st_gid)
-
-            # Upload file with or without attributes
-            # https://stackoverflow.com/questions/22567306/python-requests-file-upload
-            resp = self._request_http(
-                AppMeshClient.Method.POST_STREAM,
-                path="/appmesh/file/upload",
-                header=header,
-                body=encoder,
-            )
-            resp.raise_for_status()
-
-    ########################################
-    # Application run
-    ########################################
-    def _parse_duration(self, timeout) -> str:
-        if isinstance(timeout, int):
-            return str(timeout)
-        elif isinstance(timeout, str):
-            return str(int(aniso8601.parse_duration(timeout).total_seconds()))
-        else:
-            raise TypeError(f"Invalid timeout type: {str(timeout)}")
-
-    def run_async(
-        self,
-        app: Union[App, str],
-        max_time_seconds: Union[int, str] = DURATION_TWO_DAYS_ISO,
-        life_cycle_seconds: Union[int, str] = DURATION_TWO_DAYS_HALF_ISO,
-    ) -> AppRun:
-        """Run an application asynchronously on a remote system without blocking the API.
-
-        Args:
-            app (Union[App, str]): An `App` instance or a shell command string.
-                - If `app` is a string, it is treated as a shell command for the remote run,
-                and an `App` instance is created as:
-                `App({"command": "<command_string>", "shell": True})`.
-                - If `app` is an `App` object, providing only the `name` attribute (without
-                a command) will run an existing application; otherwise, it is treated as a new application.
-            max_time_seconds (Union[int, str], optional): Maximum runtime for the remote process.
-                Accepts ISO 8601 duration format (e.g., 'P1Y2M3DT4H5M6S', 'P5W'). Defaults to `P2D`.
-            life_cycle_seconds (Union[int, str], optional): Maximum lifecycle time for the remote process.
-                Accepts ISO 8601 duration format. Defaults to `P2DT12H`.
-
-        Returns:
-            AppRun: An application run object that can be used to monitor and retrieve the result of the run.
-        """
-        if isinstance(app, str):
-            app = App({"command": app, "shell": True})
-
-        path = "/appmesh/app/run"
-        resp = self._request_http(
-            AppMeshClient.Method.POST,
-            body=app.json(),
-            path=path,
-            query={
-                "timeout": self._parse_duration(max_time_seconds),
-                "lifecycle": self._parse_duration(life_cycle_seconds),
-            },
-        )
-        if resp.status_code != HTTPStatus.OK:
-            raise Exception(resp.text)
-
-        # Return an AppRun object with the application name and process UUID
-        return AppRun(self, resp.json()["name"], resp.json()["process_uuid"])
-
-    def run_async_wait(self, run: AppRun, stdout_print: bool = True, timeout: int = 0) -> int:
-        """Wait for an async run to be finished
-
-        Args:
-            run (AppRun): asyncrized run result from run_async().
-            stdout_print (bool, optional): print remote stdout to local or not.
-            timeout (int, optional): wait max timeout seconds and return if not finished, 0 means wait until finished
-
-        Returns:
-            int: return exit code if process finished, return None for timeout or exception.
-        """
-        if run:
-            last_output_position = 0
-            start = datetime.now()
-            interval = 1 if self.__class__.__name__ == "AppMeshClient" else 1000
-            while len(run.proc_uid) > 0:
-                app_out = self.app_output(app_name=run.app_name, stdout_position=last_output_position, stdout_index=0, process_uuid=run.proc_uid, timeout=interval)
-                if app_out.output and stdout_print:
-                    print(app_out.output, end="")
-                if app_out.out_position is not None:
-                    last_output_position = app_out.out_position
-                if app_out.exit_code is not None:
-                    # success
-                    self.app_delete(run.app_name)
-                    return app_out.exit_code
-                if app_out.status_code != HTTPStatus.OK:
-                    # failed
-                    break
-                if timeout > 0 and (datetime.now() - start).seconds > timeout:
-                    # timeout
-                    break
-        return None
-
-    def run_sync(
-        self,
-        app: Union[App, str],
-        stdout_print: bool = True,
-        max_time_seconds: Union[int, str] = DURATION_TWO_DAYS_ISO,
-        life_cycle_seconds: Union[int, str] = DURATION_TWO_DAYS_HALF_ISO,
-    ) -> Tuple[Union[int, None], str]:
-        """Synchronously run an application remotely, blocking until completion, and return the result.
-
-        If 'app' is a string, it is treated as a shell command and converted to an App instance.
-        If 'app' is App object, the name attribute is used to run an existing application if specified.
-
-        Args:
-            app (Union[App, str]): An App instance or a shell command string.
-                If a string, an App instance is created as:
-                `appmesh_client.App({"command": "<command_string>", "shell": True})`
-            stdout_print (bool, optional): If True, prints the remote stdout locally. Defaults to True.
-            max_time_seconds (Union[int, str], optional): Maximum runtime for the remote process.
-                Supports ISO 8601 duration format (e.g., 'P1Y2M3DT4H5M6S', 'P5W'). Defaults to DEFAULT_RUN_APP_TIMEOUT_SECONDS.
-            life_cycle_seconds (Union[int, str], optional): Maximum lifecycle time for the remote process.
-                Supports ISO 8601 duration format. Defaults to DEFAULT_RUN_APP_LIFECYCLE_SECONDS.
-
-        Returns:
-            Tuple[Union[int, None], str]: Exit code of the process (None if unavailable) and the stdout text.
-        """
-        if isinstance(app, str):
-            app = App({"command": app, "shell": True})
-
-        path = "/appmesh/app/syncrun"
-        resp = self._request_http(
-            AppMeshClient.Method.POST,
-            body=app.json(),
-            path=path,
-            query={
-                "timeout": self._parse_duration(max_time_seconds),
-                "lifecycle": self._parse_duration(life_cycle_seconds),
-            },
-        )
-        exit_code = None
-        if resp.status_code == HTTPStatus.OK:
-            if stdout_print:
-                print(resp.text, end="")
-            if "Exit-Code" in resp.headers:
-                exit_code = int(resp.headers.get("Exit-Code"))
-        elif stdout_print:
-            print(resp.text)
-
-        return exit_code, resp.text
-
-    def _request_http(self, method: Method, path: str, query: dict = None, header: dict = None, body=None) -> requests.Response:
-        """REST API
-
-        Args:
-            method (Method): AppMeshClient.Method.
-            path (str): URI patch str.
-            query (dict, optional): HTTP query parameters.
-            header (dict, optional): HTTP headers.
-            body (_type_, optional): object to send in the body of the :class:`Request`.
-
-        Returns:
-            requests.Response: HTTP response
-        """
-        rest_url = parse.urljoin(self.server_url, path)
-
-        header = {} if header is None else header
-        if self.jwt_token:
-            header["Authorization"] = "Bearer " + self.jwt_token
-        if self.forwarding_host and len(self.forwarding_host) > 0:
-            if ":" in self.forwarding_host:
-                header[HTTP_HEADER_KEY_X_TARGET_HOST] = self.forwarding_host
-            else:
-                header[HTTP_HEADER_KEY_X_TARGET_HOST] = self.forwarding_host + ":" + str(parse.urlsplit(self.server_url).port)
-        header[HTTP_HEADER_KEY_USER_AGENT] = HTTP_USER_AGENT
-
-        if method is AppMeshClient.Method.GET:
-            return requests.get(url=rest_url, params=query, headers=header, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
-        elif method is AppMeshClient.Method.POST:
-            return requests.post(
-                url=rest_url, params=query, headers=header, data=json.dumps(body) if type(body) in (dict, list) else body, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout
-            )
-        elif method is AppMeshClient.Method.POST_STREAM:
-            return requests.post(url=rest_url, params=query, headers=header, data=body, cert=self.ssl_client_cert, verify=self.ssl_verify, stream=True, timeout=self.rest_timeout)
-        elif method is AppMeshClient.Method.DELETE:
-            return requests.delete(url=rest_url, headers=header, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
-        elif method is AppMeshClient.Method.PUT:
-            return requests.put(url=rest_url, params=query, headers=header, json=body, cert=self.ssl_client_cert, verify=self.ssl_verify, timeout=self.rest_timeout)
-        else:
-            raise Exception("Invalid http method", method)
-
-
-class AppMeshClientTCP(AppMeshClient):
-    """
-    Client SDK for interacting with the App Mesh service over TCP, with enhanced support for large file transfers.
-
-    The `AppMeshClientTCP` class extends the functionality of `AppMeshClient` by offering a TCP-based communication layer
-    for the App Mesh REST API. It overrides the file download and upload methods to support large file transfers with
-    improved performance, leveraging TCP for lower latency and higher throughput compared to HTTP.
-
-    This client is suitable for applications requiring efficient data transfers and high-throughput operations within the
-    App Mesh ecosystem, while maintaining compatibility with all other attributes and methods from `AppMeshClient`.
-
-    Dependency:
-        - Install the required package for message serialization:
-            pip3 install msgpack
-
-    Usage:
-        - Import the client module:
-            from appmesh import appmesh_client
-
-    Example:
-        client = appmesh_client.AppMeshClientTCP()
-        client.login("your-name", "your-password")
-        client.file_download("/tmp/os-release", "os-release")
-
-    Attributes:
-        - Inherits all attributes from `AppMeshClient`, including TLS secure connections and JWT-based authentication.
-        - Optimized for TCP-based communication to provide better performance for large file transfers.
-
-    Methods:
-        - file_download()
-        - file_upload()
-        - Inherits all other methods from `AppMeshClient`, providing a consistent interface for managing applications within App Mesh.
-    """
-
-    def __init__(
-        self,
-        rest_ssl_verify=DEFAULT_SSL_CA_CERT_PATH if os.path.exists(DEFAULT_SSL_CA_CERT_PATH) else False,
-        rest_ssl_client_cert=None,
-        jwt_token=None,
-        tcp_address=("localhost", 6059),
-    ):
-        """Construct an App Mesh client TCP object to communicate securely with an App Mesh server over TLS.
-
-        Args:
-            rest_ssl_verify (Union[bool, str], optional): Specifies SSL certificate verification behavior. Can be:
-                - `True`: Uses the system’s default CA certificates to verify the server’s identity.
-                - `False`: Disables SSL certificate verification (insecure, intended for development).
-                - `str`: Specifies a custom CA bundle or directory for server certificate verification. If a string is provided,
-                it should either be a file path to a custom CA certificate (CA bundle) or a directory path containing multiple
-                certificates (CA directory).
-
-                **Note**: Unlike HTTP requests, TCP connections cannot automatically retrieve intermediate or public CA certificates.
-                When `rest_ssl_verify` is a path, it explicitly identifies a CA issuer to ensure certificate validation.
-
-            rest_ssl_client_cert (Union[str, Tuple[str, str]], optional): Path to the SSL client certificate and key. If a `str`,
-                it should be the path to a PEM file containing both the client certificate and private key. If a `tuple`, it should
-                be a pair of paths: (`cert`, `key`), where `cert` is the client certificate file and `key` is the private key file.
-
-            jwt_token (str, optional): JWT token for authentication. Used in methods requiring login and user authorization.
-
-            tcp_address (Tuple[str, int], optional): Address and port for establishing a TCP connection to the server.
-                Defaults to `("localhost", 6059)`.
-        """
-        self.tcp_address = tcp_address
-        self.__socket_client = None
-        super().__init__(rest_ssl_verify=rest_ssl_verify, rest_ssl_client_cert=rest_ssl_client_cert, jwt_token=jwt_token)
-
-    def __del__(self) -> None:
-        """De-construction"""
-        self.__close_socket()
-
-    def __connect_socket(self) -> None:
-        """Establish tcp connection"""
-        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
-        # Set minimum TLS version
-        if hasattr(context, "minimum_version"):
-            context.minimum_version = ssl.TLSVersion.TLSv1_2
-        else:
-            context.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
-        # Configure SSL verification
-        if not self.ssl_verify:
-            context.verify_mode = ssl.CERT_NONE
-        else:
-            context.verify_mode = ssl.CERT_REQUIRED  # Require certificate verification
-            context.load_default_certs()  # Load system's default CA certificates
-            if isinstance(self.ssl_verify, str):
-                if os.path.isfile(self.ssl_verify):
-                    # Load custom CA certificate file
-                    context.load_verify_locations(cafile=self.ssl_verify)
-                elif os.path.isdir(self.ssl_verify):
-                    # Load CA certificates from directory
-                    context.load_verify_locations(capath=self.ssl_verify)
-                else:
-                    raise ValueError(f"ssl_verify path '{self.ssl_verify}' is neither a file nor a directory")
-
-        if self.ssl_client_cert is not None:
-            # Load client-side certificate and private key
-            context.load_cert_chain(certfile=self.ssl_client_cert[0], keyfile=self.ssl_client_cert[1])
-
-        # Create a TCP socket
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.setblocking(True)
-        # Wrap the socket with SSL/TLS
-        self.__socket_client = context.wrap_socket(sock, server_hostname=self.tcp_address[0])
-        # Connect to the server
-        self.__socket_client.connect(self.tcp_address)
-        # Disable Nagle's algorithm
-        self.__socket_client.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-
-    def __close_socket(self) -> None:
-        """Close socket connection"""
-        if self.__socket_client:
-            try:
-                self.__socket_client.close()
-                self.__socket_client = None
-            except Exception as ex:
-                print(ex)
-
-    def __recvall(self, length: int) -> bytes:
-        """socket recv data with fixed length
-           https://stackoverflow.com/questions/64466530/using-a-custom-socket-recvall-function-works-only-if-thread-is-put-to-sleep
-        Args:
-            length (bytes): data length to be received
-
-        Raises:
-            EOFError: socket closed unexpectedly
-
-        Returns:
-            bytes: socket data
-        """
-        fragments = []
-        while length:
-            chunk = self.__socket_client.recv(length)
-            if not chunk:
-                raise EOFError("socket closed")
-            length -= len(chunk)
-            fragments.append(chunk)
-        return b"".join(fragments)
-
-    def _request_http(self, method: AppMeshClient.Method, path: str, query: dict = None, header: dict = None, body=None) -> requests.Response:
-        """TCP API
-
-        Args:
-            method (Method): AppMeshClient.Method.
-            path (str): URI patch str.
-            query (dict, optional): HTTP query parameters.
-            header (dict, optional): HTTP headers.
-            body (_type_, optional): object to send in the body of the :class:`Request`.
-
-        Returns:
-            requests.Response: HTTP response
-        """
-        import msgpack
-
-        class RequestMsg:
-            """HTTP request message"""
-
-            uuid: str = ""
-            request_uri: str = ""
-            http_method: str = ""
-            client_addr: str = ""
-            body: bytes = b""
-            headers: dict = {}
-            querys: dict = {}
-
-            def serialize(self) -> bytes:
-                """Serialize request message to bytes"""
-                # http://www.cnitblog.com/luckydmz/archive/2019/11/20/91959.html
-                self_dict = vars(self)
-                self_dict["headers"] = self.headers
-                self_dict["querys"] = self.querys
-                return msgpack.dumps(self_dict)
-
-        class ResponseMsg:
-            """HTTP response message"""
-
-            uuid: str = ""
-            request_uri: str = ""
-            http_status: int = 0
-            body_msg_type: str = ""
-            body: str = ""
-            headers: dict = {}
-
-            def desirialize(self, buf: bytes):
-                """Deserialize response message"""
-                dic = msgpack.unpackb(buf)
-                for k, v in dic.items():
-                    setattr(self, k, v)
-                return self
-
-        if self.__socket_client is None:
-            self.__connect_socket()
-
-        appmesh_request = RequestMsg()
-        if super().jwt_token:
-            appmesh_request.headers["Authorization"] = "Bearer " + super().jwt_token
-        if super().forwarding_host and len(super().forwarding_host) > 0:
-            raise Exception("Not support forward request in TCP mode")
-        appmesh_request.headers[HTTP_HEADER_KEY_USER_AGENT] = HTTP_USER_AGENT_TCP
-        appmesh_request.uuid = str(uuid.uuid1())
-        appmesh_request.http_method = method.value
-        appmesh_request.request_uri = path
-        appmesh_request.client_addr = socket.gethostname()
-        if body:
-            if isinstance(body, dict) or isinstance(body, list):
-                appmesh_request.body = bytes(json.dumps(body, indent=2), ENCODING_UTF8)
-            elif isinstance(body, str):
-                appmesh_request.body = bytes(body, ENCODING_UTF8)
-            elif isinstance(body, bytes):
-                appmesh_request.body = body
-            else:
-                raise Exception(f"UnSupported body type: {type(body)}")
-        if header:
-            for k, v in header.items():
-                appmesh_request.headers[k] = v
-        if query:
-            for k, v in query.items():
-                appmesh_request.querys[k] = v
-        data = appmesh_request.serialize()
-        self.__socket_client.sendall(len(data).to_bytes(TCP_HEADER_LENGTH, byteorder="big", signed=False))
-        self.__socket_client.sendall(data)
-
-        # https://developers.google.com/protocol-buffers/docs/pythontutorial
-        # https://stackoverflow.com/questions/33913308/socket-module-how-to-send-integer
-        resp_data = bytes()
-        resp_data = self.__recvall(int.from_bytes(self.__recvall(TCP_HEADER_LENGTH), byteorder="big", signed=False))
-        if resp_data is None or len(resp_data) == 0:
-            self.__close_socket()
-            raise Exception("socket connection broken")
-        appmesh_resp = ResponseMsg().desirialize(resp_data)
-        response = requests.Response()
-        response.status_code = appmesh_resp.http_status
-        response.encoding = ENCODING_UTF8
-        response._content = appmesh_resp.body.encode(ENCODING_UTF8)
-        response.headers = appmesh_resp.headers
-        if appmesh_resp.body_msg_type:
-            response.headers["Content-Type"] = appmesh_resp.body_msg_type
-        return response
-
-    ########################################
-    # File management
-    ########################################
-    def file_download(self, remote_file: str, local_file: str, apply_file_attributes: bool = True) -> None:
-        """Copy a remote file to local, the local file will have the same permission as the remote file
-
-        Args:
-            remote_file (str): the remote file path.
-            local_file (str): the local file path to be downloaded.
-            apply_file_attributes (bool): whether to apply file attributes (permissions, owner, group) to the local file.
-        """
-        header = {"File-Path": remote_file}
-        header[HTTP_HEADER_KEY_X_RECV_FILE_SOCKET] = "true"
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/file/download", header=header)
-
-        resp.raise_for_status()
-        if HTTP_HEADER_KEY_X_RECV_FILE_SOCKET not in resp.headers:
-            raise ValueError(f"Server did not respond with socket transfer option: {HTTP_HEADER_KEY_X_RECV_FILE_SOCKET}")
-
-        with open(local_file, "wb") as fp:
-            chunk_data = bytes()
-            chunk_size = int.from_bytes(self.__recvall(TCP_HEADER_LENGTH), byteorder="big", signed=False)
-            while chunk_size > 0:
-                chunk_data = self.__recvall(chunk_size)
-                if chunk_data is None or len(chunk_data) == 0:
-                    self.__close_socket()
-                    raise Exception("socket connection broken")
-                fp.write(chunk_data)
-                chunk_size = int.from_bytes(self.__recvall(TCP_HEADER_LENGTH), byteorder="big", signed=False)
-
-        if apply_file_attributes:
-            if "File-Mode" in resp.headers:
-                os.chmod(path=local_file, mode=int(resp.headers["File-Mode"]))
-            if "File-User" in resp.headers and "File-Group" in resp.headers:
-                file_uid = int(resp.headers["File-User"])
-                file_gid = int(resp.headers["File-Group"])
-                try:
-                    os.chown(path=local_file, uid=file_uid, gid=file_gid)
-                except PermissionError:
-                    print(f"Warning: Unable to change owner/group of {local_file}. Operation requires elevated privileges.")
-
-    def file_upload(self, local_file: str, remote_file: str, apply_file_attributes: bool = True) -> None:
-        """Upload a local file to the remote server, the remote file will have the same permission as the local file
-
-        Dependency:
-            sudo apt install python3-pip
-            pip3 install requests_toolbelt
-
-        Args:
-            local_file (str): the local file path.
-            remote_file (str): the target remote file to be uploaded.
-            apply_file_attributes (bool): whether to upload file attributes (permissions, owner, group) along with the file.
-        """
-        if not os.path.exists(local_file):
-            raise FileNotFoundError(f"Local file not found: {local_file}")
-
-        with open(file=local_file, mode="rb") as fp:
-            header = {"File-Path": remote_file, "Content-Type": "text/plain"}
-            header[HTTP_HEADER_KEY_X_SEND_FILE_SOCKET] = "true"
-
-            if apply_file_attributes:
-                file_stat = os.stat(local_file)
-                header["File-Mode"] = str(file_stat.st_mode & 0o777)  # Mask to keep only permission bits
-                header["File-User"] = str(file_stat.st_uid)
-                header["File-Group"] = str(file_stat.st_gid)
-
-            # https://stackoverflow.com/questions/22567306/python-requests-file-upload
-            resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/file/upload", header=header)
-
-            resp.raise_for_status()
-            if HTTP_HEADER_KEY_X_SEND_FILE_SOCKET not in resp.headers:
-                raise ValueError(f"Server did not respond with socket transfer option: {HTTP_HEADER_KEY_X_SEND_FILE_SOCKET}")
-
-            chunk_size = TCP_BLOCK_SIZE
-            while True:
-                chunk_data = fp.read(chunk_size)
-                if not chunk_data:
-                    self.__socket_client.sendall((0).to_bytes(TCP_HEADER_LENGTH, byteorder="big", signed=False))
-                    break
-                self.__socket_client.sendall(len(chunk_data).to_bytes(TCP_HEADER_LENGTH, byteorder="big", signed=False))
-                self.__socket_client.sendall(chunk_data)
+from .http_client import AppMeshClient, App, AppOutput