tunnel-manager 0.0.2__py3-none-any.whl

tunnel_manager/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from tunnel_manager.tunnel_manager import (
+    Tunnel,
+)
+from tunnel_manager.tunnel_manager_mcp import tunnel_manager_mcp
+
+"""
+tunnel-manager
+
+Create SSH tunnels to your remote hosts!
+"""
+
+
+__all__ = ["tunnel_manager_mcp", "Tunnel"]

tunnel_manager/__main__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python
+# coding: utf-8
+from tunnel_manager.tunnel_manager_mcp import tunnel_manager_mcp
+
+if __name__ == "__main__":
+    tunnel_manager_mcp()

tunnel_manager/tunnel_manager.py

@@ -0,0 +1,190 @@
+import logging
+import os
+import paramiko
+
+
+class Tunnel:
+    def __init__(
+        self,
+        remote_host: str,
+        port: int = 22,
+        identity_file: str = None,
+        certificate_file: str = None,
+        proxy_command: str = None,
+        log_file: str = None,
+    ):
+        """
+        Initialize the Tunnel class.
+
+        :param remote_host: The hostname or IP of the remote host.
+        :param identity_file: Optional path to the private key file (overrides config).
+        :param certificate_file: Optional path to the certificate file (overrides config, used for Teleport).
+        :param proxy_command: Optional proxy command string (overrides config, used for Teleport proxying).
+        :param log_file: Optional path to a log file for recording operations.
+        """
+        self.remote_host = remote_host
+        self.port = port
+        self.ssh_client = None
+        self.sftp = None
+        self.logger = None
+
+        # Load from ~/.ssh/config if not overridden
+        ssh_config_path = os.path.expanduser("~/.ssh/config")
+        self.ssh_config = paramiko.SSHConfig()
+        if os.path.exists(ssh_config_path):
+            with open(ssh_config_path) as f:
+                self.ssh_config.parse(f)
+        host_config = self.ssh_config.lookup(remote_host) or {}
+
+        self.identity_file = identity_file or (
+            host_config.get("identityfile", [None])[0]
+            if "identityfile" in host_config
+            else None
+        )
+        self.certificate_file = certificate_file or host_config.get("certificatefile")
+        self.proxy_command = proxy_command or host_config.get("proxycommand")
+
+        if not self.identity_file:
+            raise ValueError(
+                "Identity file must be provided either via parameter or in ~/.ssh/config."
+            )
+
+        if log_file:
+            logging.basicConfig(
+                filename=log_file,
+                level=logging.INFO,
+                format="%(asctime)s - %(levelname)s - %(message)s",
+            )
+            self.logger = logging.getLogger(__name__)
+            self.logger.info(f"Tunnel initialized for host: {remote_host}")
+
+    def connect(self):
+        """
+        Establish the SSH connection if not already connected.
+        """
+        if (
+            self.ssh_client
+            and self.ssh_client.get_transport()
+            and self.ssh_client.get_transport().is_active()
+        ):
+            return  # Already connected
+
+        self.ssh_client = paramiko.SSHClient()
+        self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+        proxy = None
+        if self.proxy_command:
+            proxy = paramiko.ProxyCommand(self.proxy_command)
+            if self.logger:
+                self.logger.info(f"Using proxy command: {self.proxy_command}")
+
+        private_key = paramiko.RSAKey.from_private_key_file(self.identity_file)
+        if self.certificate_file:
+            private_key.load_certificate(self.certificate_file)
+            if self.logger:
+                self.logger.info(f"Loaded certificate: {self.certificate_file}")
+
+        try:
+            self.ssh_client.connect(
+                self.remote_host,
+                port=self.port,
+                pkey=private_key,
+                sock=proxy,
+                auth_timeout=30,
+                look_for_keys=False,
+                allow_agent=False,
+            )
+            if self.logger:
+                self.logger.info(f"Connected to {self.remote_host}")
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Connection failed: {str(e)}")
+            raise
+
+    def run_command(self, command):
+        """
+        Run a shell command on the remote host.
+
+        :param command: The command to execute.
+        :return: Tuple of (stdout, stderr) as strings.
+        """
+        self.connect()
+        try:
+            stdin, stdout, stderr = self.ssh_client.exec_command(command)
+            out = stdout.read().decode("utf-8").strip()
+            err = stderr.read().decode("utf-8").strip()
+            if self.logger:
+                self.logger.info(
+                    f"Command executed: {command}\nOutput: {out}\nError: {err}"
+                )
+            return out, err
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Command execution failed: {str(e)}")
+            raise
+
+    def send_file(self, local_path, remote_path):
+        """
+        Send (upload) a file to the remote host.
+
+        :param local_path: Path to the local file.
+        :param remote_path: Path on the remote host.
+        """
+        self.connect()
+        try:
+            if not self.sftp:
+                self.sftp = self.ssh_client.open_sftp()
+            self.sftp.put(local_path, remote_path)
+            if self.logger:
+                self.logger.info(f"File sent: {local_path} -> {remote_path}")
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"File send failed: {str(e)}")
+            raise
+        finally:
+            if self.sftp:
+                self.sftp.close()
+                self.sftp = None
+
+    def receive_file(self, remote_path, local_path):
+        """
+        Receive (download) a file from the remote host.
+
+        :param remote_path: Path on the remote host.
+        :param local_path: Path to save the local file.
+        """
+        self.connect()
+        try:
+            if not self.sftp:
+                self.sftp = self.ssh_client.open_sftp()
+            self.sftp.get(remote_path, local_path)
+            if self.logger:
+                self.logger.info(f"File received: {remote_path} -> {local_path}")
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"File receive failed: {str(e)}")
+            raise
+        finally:
+            if self.sftp:
+                self.sftp.close()
+                self.sftp = None
+
+    def close(self):
+        """
+        Close the SSH connection.
+        """
+        if self.ssh_client:
+            self.ssh_client.close()
+            if self.logger:
+                self.logger.info(f"Connection closed for {self.remote_host}")
+            self.ssh_client = None
+
+
+# Example usage (commented out):
+# tunnel = Tunnel("your-remote-host.example.com", log_file="tunnel.log")
+# tunnel.connect()
+# out, err = tunnel.run_command("ls -la")
+# print(out)
+# tunnel.send_file("/local/file.txt", "/remote/file.txt")
+# tunnel.receive_file("/remote/file.txt", "/local/downloaded.txt")
+# tunnel.close()

tunnel_manager/tunnel_manager_mcp.py

@@ -0,0 +1,316 @@
+#!/usr/bin/python
+# coding: utf-8
+import argparse
+import os
+import sys
+import logging
+from typing import Optional
+from tunnel_manager.tunnel_manager import Tunnel
+from fastmcp import FastMCP, Context
+from pydantic import Field
+
+logging.basicConfig(
+    filename="tunnel_mcp.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+mcp = FastMCP(name="TunnelServer")
+
+
+@mcp.tool(
+    annotations={
+        "title": "Run Remote Command",
+        "readOnlyHint": True,
+        "destructiveHint": True,
+        "idempotentHint": False,
+        "openWorldHint": False,
+    },
+    tags={"remote_access"},
+)
+async def run_remote_command(
+    remote_host: str = Field(
+        description="The remote host to connect to.",
+        default=os.environ.get("TUNNEL_REMOTE_HOST", None),
+    ),
+    remote_port: str = Field(
+        description="The remote host's port to connect to.",
+        default=os.environ.get("TUNNEL_REMOTE_PORT", None),
+    ),
+    command: str = Field(
+        description="The shell command to run on the remote host.", default=None
+    ),
+    identity_file: Optional[str] = Field(
+        description="Path to the private key file.",
+        default=os.environ.get("TUNNEL_IDENTITY_FILE", None),
+    ),
+    certificate_file: Optional[str] = Field(
+        description="Path to the certificate file (for Teleport).",
+        default=os.environ.get("TUNNEL_CERTIFICATE", None),
+    ),
+    proxy_command: Optional[str] = Field(
+        description="Proxy command (for Teleport).",
+        default=os.environ.get("TUNNEL_PROXY_COMMAND", None),
+    ),
+    log_file: Optional[str] = Field(
+        description="Path to log file for this operation.",
+        default=os.environ.get("TUNNEL_LOG_FILE", None),
+    ),
+    ctx: Context = Field(
+        description="MCP context for progress reporting.", default=None
+    ),
+) -> str:
+    """Runs a shell command on a remote host via SSH or Teleport."""
+    logger = logging.getLogger("TunnelServer")
+    logger.debug(
+        f"Starting run_remote_command for host: {remote_host}, command: {command}"
+    )
+
+    if not remote_host or not command:
+        raise ValueError("remote_host and command must be provided.")
+
+    try:
+        tunnel = Tunnel(
+            remote_host, identity_file, certificate_file, proxy_command, log_file
+        )
+
+        if ctx:
+            await ctx.report_progress(progress=0, total=100)
+            logger.debug("Reported initial progress: 0/100")
+
+        tunnel.connect()
+        out, err = tunnel.run_command(command)
+
+        if ctx:
+            await ctx.report_progress(progress=100, total=100)
+            logger.debug("Reported final progress: 100/100")
+
+        logger.debug(f"Command output: {out}, error: {err}")
+        return f"Output:\n{out}\nError:\n{err}"
+    except Exception as e:
+        logger.error(f"Failed to run command: {str(e)}")
+        raise RuntimeError(f"Failed to run command: {str(e)}")
+    finally:
+        if "tunnel" in locals():
+            tunnel.close()
+
+
+@mcp.tool(
+    annotations={
+        "title": "Upload File",
+        "readOnlyHint": False,
+        "destructiveHint": True,
+        "idempotentHint": False,
+        "openWorldHint": False,
+    },
+    tags={"remote_access"},
+)
+async def upload_file(
+    remote_host: str = Field(
+        description="The remote host to connect to.",
+        default=os.environ.get("TUNNEL_REMOTE_HOST", None),
+    ),
+    remote_port: str = Field(
+        description="The remote host's port to connect to.",
+        default=os.environ.get("TUNNEL_REMOTE_PORT", None),
+    ),
+    local_path: str = Field(description="Local file path to upload.", default=None),
+    remote_path: str = Field(description="Remote destination path.", default=None),
+    identity_file: Optional[str] = Field(
+        description="Path to the private key file.",
+        default=os.environ.get("TUNNEL_IDENTITY_FILE", None),
+    ),
+    certificate_file: Optional[str] = Field(
+        description="Path to the certificate file (for Teleport).",
+        default=os.environ.get("TUNNEL_CERTIFICATE", None),
+    ),
+    proxy_command: Optional[str] = Field(
+        description="Proxy command (for Teleport).",
+        default=os.environ.get("TUNNEL_PROXY_COMMAND", None),
+    ),
+    log_file: Optional[str] = Field(
+        description="Path to log file for this operation.",
+        default=os.environ.get("TUNNEL_LOG_FILE", None),
+    ),
+    ctx: Context = Field(
+        description="MCP context for progress reporting.", default=None
+    ),
+) -> str:
+    """Uploads a file to a remote host via SSH or Teleport."""
+    logger = logging.getLogger("TunnelServer")
+    logger.debug(
+        f"Starting upload_file for host: {remote_host}, local: {local_path}, remote: {remote_path}"
+    )
+
+    if not remote_host or not local_path or not remote_path:
+        raise ValueError("remote_host, local_path, and remote_path must be provided.")
+
+    if not os.path.exists(local_path):
+        raise ValueError(f"Local file does not exist: {local_path}")
+
+    try:
+        tunnel = Tunnel(
+            remote_host, identity_file, certificate_file, proxy_command, log_file
+        )
+        tunnel.connect()
+
+        if ctx:
+            await ctx.report_progress(progress=0, total=100)
+            logger.debug("Reported initial progress: 0/100")
+
+        sftp = tunnel.ssh_client.open_sftp()
+        file_size = os.path.getsize(local_path)
+        transferred = 0
+
+        def progress_callback(transf, total):
+            nonlocal transferred
+            transferred = transf
+
+        sftp.put(local_path, remote_path, callback=progress_callback)
+
+        if ctx:
+            await ctx.report_progress(progress=100, total=100)
+            logger.debug("Reported final progress: 100/100")
+
+        sftp.close()
+        logger.debug(f"File uploaded: {local_path} -> {remote_path}")
+        return f"File uploaded successfully to {remote_path}"
+    except Exception as e:
+        logger.error(f"Failed to upload file: {str(e)}")
+        raise RuntimeError(f"Failed to upload file: {str(e)}")
+    finally:
+        if "tunnel" in locals():
+            tunnel.close()
+
+
+@mcp.tool(
+    annotations={
+        "title": "Download File",
+        "readOnlyHint": False,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    },
+    tags={"remote_access"},
+)
+async def download_file(
+    remote_host: str = Field(
+        description="The remote host to connect to.",
+        default=os.environ.get("TUNNEL_REMOTE_HOST", None),
+    ),
+    remote_port: str = Field(
+        description="The remote host's port to connect to.",
+        default=os.environ.get("TUNNEL_REMOTE_PORT", None),
+    ),
+    remote_path: str = Field(description="Remote file path to download.", default=None),
+    local_path: str = Field(description="Local destination path.", default=None),
+    identity_file: Optional[str] = Field(
+        description="Path to the private key file.",
+        default=os.environ.get("TUNNEL_IDENTITY_FILE", None),
+    ),
+    certificate_file: Optional[str] = Field(
+        description="Path to the certificate file (for Teleport).",
+        default=os.environ.get("TUNNEL_CERTIFICATE", None),
+    ),
+    proxy_command: Optional[str] = Field(
+        description="Proxy command (for Teleport).",
+        default=os.environ.get("TUNNEL_PROXY_COMMAND", None),
+    ),
+    log_file: Optional[str] = Field(
+        description="Path to log file for this operation.",
+        default=os.environ.get("TUNNEL_LOG_FILE", None),
+    ),
+    ctx: Context = Field(
+        description="MCP context for progress reporting.", default=None
+    ),
+) -> str:
+    """Downloads a file from a remote host via SSH or Teleport."""
+    logger = logging.getLogger("TunnelServer")
+    logger.debug(
+        f"Starting download_file for host: {remote_host}, remote: {remote_path}, local: {local_path}"
+    )
+
+    if not remote_host or not remote_path or not local_path:
+        raise ValueError("remote_host, remote_path, and local_path must be provided.")
+
+    try:
+        tunnel = Tunnel(
+            remote_host, identity_file, certificate_file, proxy_command, log_file
+        )
+        tunnel.connect()
+
+        if ctx:
+            await ctx.report_progress(progress=0, total=100)
+            logger.debug("Reported initial progress: 0/100")
+
+        sftp = tunnel.ssh_client.open_sftp()
+        remote_attr = sftp.stat(remote_path)
+        file_size = remote_attr.st_size
+        transferred = 0
+
+        def progress_callback(transf, total):
+            nonlocal transferred
+            transferred = transf
+
+        sftp.get(remote_path, local_path, callback=progress_callback)
+
+        if ctx:
+            await ctx.report_progress(progress=100, total=100)
+            logger.debug("Reported final progress: 100/100")
+
+        sftp.close()
+        logger.debug(f"File downloaded: {remote_path} -> {local_path}")
+        return f"File downloaded successfully to {local_path}"
+    except Exception as e:
+        logger.error(f"Failed to download file: {str(e)}")
+        raise RuntimeError(f"Failed to download file: {str(e)}")
+    finally:
+        if "tunnel" in locals():
+            tunnel.close()
+
+
+def tunnel_mcp():
+    parser = argparse.ArgumentParser(
+        description="Tunnel MCP Server for remote SSH and file operations",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "-t",
+        "--transport",
+        choices=["stdio", "http"],
+        default="stdio",
+        help="Transport method for the MCP server (stdio or http).",
+    )
+    parser.add_argument(
+        "--host", default="0.0.0.0", help="Host address for HTTP transport."
+    )
+    parser.add_argument(
+        "-p",
+        "--port",
+        type=int,
+        default=8000,
+        help="Port for HTTP transport (0-65535).",
+    )
+
+    args = parser.parse_args()
+
+    if args.port < 0 or args.port > 65535:
+        print(f"Error: Port {args.port} is out of valid range (0-65535).")
+        sys.exit(1)
+
+    logger = logging.getLogger("TunnelServer")
+    if args.transport == "stdio":
+        logger.info("Starting MCP server with stdio transport")
+        mcp.run(transport="stdio")
+    elif args.transport == "http":
+        logger.info(
+            f"Starting MCP server with HTTP transport on {args.host}:{args.port}"
+        )
+        mcp.run(transport="http", host=args.host, port=args.port)
+    else:
+        logger.error("Transport not supported")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    tunnel_mcp()

tunnel_manager-0.0.2.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: tunnel-manager
+Version: 0.0.2
+Summary: Create SSH Tunnels to your remote hosts and host as an MCP Server for Agentic AI!
+Author-email: Audel Rouhi <knucklessg1@gmail.com>
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: Public Domain
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastmcp>=2.11.3
+Requires-Dist: paramiko>=4.0.0
+Dynamic: license-file
+
+# Tunnel Manager
+
+![PyPI - Version](https://img.shields.io/pypi/v/tunnel-manager)
+![PyPI - Downloads](https://img.shields.io/pypi/dd/tunnel-manager)
+![GitHub Repo stars](https://img.shields.io/github/stars/Knuckles-Team/tunnel-manager)
+![GitHub forks](https://img.shields.io/github/forks/Knuckles-Team/tunnel-manager)
+![GitHub contributors](https://img.shields.io/github/contributors/Knuckles-Team/tunnel-manager)
+![PyPI - License](https://img.shields.io/pypi/l/tunnel-manager)
+![GitHub](https://img.shields.io/github/license/Knuckles-Team/tunnel-manager)
+
+![GitHub last commit (by committer)](https://img.shields.io/github/last-commit/Knuckles-Team/tunnel-manager)
+![GitHub pull requests](https://img.shields.io/github/issues-pr/Knuckles-Team/tunnel-manager)
+![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/Knuckles-Team/tunnel-manager)
+![GitHub issues](https://img.shields.io/github/issues/Knuckles-Team/tunnel-manager)
+
+![GitHub top language](https://img.shields.io/github/languages/top/Knuckles-Team/tunnel-manager)
+![GitHub language count](https://img.shields.io/github/languages/count/Knuckles-Team/tunnel-manager)
+![GitHub repo size](https://img.shields.io/github/repo-size/Knuckles-Team/tunnel-manager)
+![GitHub repo file count (file type)](https://img.shields.io/github/directory-file-count/Knuckles-Team/tunnel-manager)
+![PyPI - Wheel](https://img.shields.io/pypi/wheel/tunnel-manager)
+![PyPI - Implementation](https://img.shields.io/pypi/implementation/tunnel-manager)
+
+*Version: 0.0.2*
+
+This project provides a Python-based `Tunnel` class for secure SSH connections and file transfers,
+integrated with a FastMCP server (`tunnel_mcp.py`) to expose these capabilities as tools for AI-driven workflows.
+The implementation supports both standard SSH (e.g., for local networks) and
+Teleport's secure access platform, leveraging the `paramiko` library for SSH operations.
+
+## Features
+
+### Tunnel Class
+- **Purpose**: Facilitates secure SSH connections and file transfers to remote hosts.
+- **Key Functionality**:
+    - **Run Remote Commands**: Execute shell commands on a remote host and retrieve output.
+    - **File Upload/Download**: Transfer files to/from a remote host using SFTP.
+    - **Teleport Support**: Seamlessly integrates with Teleport's certificate-based authentication and proxying.
+    - **Configuration Flexibility**: Loads SSH settings from `~/.ssh/config` by default, with optional overrides for identity files, certificates, and proxy commands.
+    - **Logging**: Optional file-based logging for debugging and auditing.
+
+### FastMCP Server
+- **Purpose**: Exposes `Tunnel` class functionality as a FastMCP server, enabling AI tools to perform remote operations programmatically.
+- **Tools Provided**:
+    - `run_remote_command`: Runs a shell command on a remote host and returns output.
+    - `upload_file`: Uploads a file to a remote host via SFTP.
+    - `download_file`: Downloads a file from a remote host via SFTP.
+- **Transport Options**: Supports `stdio` (for local scripting) and `http` (for networked access) transport modes.
+- **Progress Reporting**: Integrates with FastMCP's `Context` for progress updates during operations.
+- **Logging**: Comprehensive logging to a file (`tunnel_mcp.log` by default).
+
+
+<details>
+  <summary><b>Usage:</b></summary>
+
+## Tunnel Class
+The `Tunnel` class can be used standalone for SSH operations. Example:
+
+```python
+from tunnel_manager import Tunnel
+
+# Initialize with a remote host (assumes ~/.ssh/config or explicit params)
+tunnel = Tunnel(
+    remote_host="example.com",
+    identity_file="/path/to/id_rsa",
+    certificate_file="/path/to/cert",  # Optional for Teleport
+    proxy_command="tsh proxy ssh %h",  # Optional for Teleport
+    log_file="tunnel.log"
+)
+
+# Connect and run a command
+tunnel.connect()
+out, err = tunnel.run_command("ls -la /tmp")
+print(f"Output: {out}\nError: {err}")
+
+# Upload a file
+tunnel.send_file("/local/file.txt", "/remote/file.txt")
+
+# Download a file
+tunnel.receive_file("/remote/file.txt", "/local/downloaded.txt")
+
+# Close the connection
+tunnel.close()
+```
+
+
+## FastMCP Server
+The FastMCP server exposes the `Tunnel` functionality as AI-accessible tools. Start the server with:
+
+```bash
+python tunnel_mcp.py --transport stdio
+```
+
+Or for HTTP transport:
+```bash
+python tunnel_mcp.py --transport http --host 127.0.0.1 --port 8080
+```
+
+</details>
+
+<details>
+  <summary><b>Installation Instructions:</b></summary>
+
+## Use with AI
+
+Configure `mcp.json`
+```json
+{
+  "mcpServers": {
+    "tunnel_manager": {
+      "command": "uv",
+      "args": [
+        "run",
+        "--with",
+        "tunnel-manager",
+        "tunnel-manager-mcp"
+      ],
+      "env": {
+        "TUNNEL_REMOTE_HOST": "user@192.168.1.12", // Optional
+        "TUNNEL_REMOTE_PORT": "22",                // Optional
+        "TUNNEL_IDENTITY_FILE": "",                // Optional
+        "TUNNEL_CERTIFICATE": "",                  // Optional
+        "TUNNEL_PROXY_COMMAND": "",                // Optional
+        "TUNNEL_LOG_FILE": "~./tunnel_log.txt"     // Optional
+      },
+      "timeout": 200000
+    }
+  }
+}
+```
+
+### Deploy MCP Server as a container
+```bash
+docker pull knucklessg1/tunnel-manager:latest
+```
+
+Modify the `compose.yml`
+
+```compose
+services:
+  tunnel-manager:
+    image: knucklessg1/tunnel-manager:latest
+    environment:
+      - HOST=0.0.0.0
+      - PORT=8021
+    ports:
+      - 8021:8021
+```
+
+### Install Python Package
+
+```bash
+python -m pip install tunnel-manager
+```
+
+or
+
+```bash
+uv pip install --upgrade tunnel-manager
+```
+
+
+</details>
+
+<details>
+  <summary><b>Repository Owners:</b></summary>
+
+
+<img width="100%" height="180em" src="https://github-readme-stats.vercel.app/api?username=Knucklessg1&show_icons=true&hide_border=true&&count_private=true&include_all_commits=true" />
+
+![GitHub followers](https://img.shields.io/github/followers/Knucklessg1)
+![GitHub User's stars](https://img.shields.io/github/stars/Knucklessg1)
+</details>

tunnel_manager-0.0.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+tunnel_manager/__init__.py,sha256=9I_qajRiMP4bxiKdEIx0bKIeTg8b4x1TsYnTMfbWIJA,273
+tunnel_manager/__main__.py,sha256=Z1uxNLjwIjJpvu97bXrvsawnghJScA52E2wtAgg5MLo,152
+tunnel_manager/tunnel_manager.py,sha256=_MokYwLLe0ekQA1CeAaH_4JTRx0TctGUJLwai3MIQvc,6565
+tunnel_manager/tunnel_manager_mcp.py,sha256=LWMRPCyXDo-UlrdvH9whXC542YwkKXUeqSAPXWeyrmk,10541
+tunnel_manager-0.0.2.dist-info/licenses/LICENSE,sha256=Z1xmcrPHBnGCETO_LLQJUeaSNBSnuptcDVTt4kaPUOE,1060
+tunnel_manager-0.0.2.dist-info/METADATA,sha256=9iZ-KRwPqLNDZ37RWmXj-4zYqVZdoYb4IW1e6LoKVa4,6568
+tunnel_manager-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tunnel_manager-0.0.2.dist-info/entry_points.txt,sha256=mxjinmmRNDVn_VbKHi63vkSvj7pp8btUKFQeXLm4-WY,92
+tunnel_manager-0.0.2.dist-info/top_level.txt,sha256=AlbS1pBPQr8wIlDsmwNxGDLK4L4s4CY_X9AellT3-x8,15
+tunnel_manager-0.0.2.dist-info/RECORD,,

tunnel_manager-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tunnel_manager-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tunnel-manager-mcp = tunnel_manager.tunnel_manager_mcp:tunnel_manager_mcp

tunnel_manager-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012-2023 Audel Rouhi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

tunnel_manager-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+tunnel_manager