ssm-cli 1.0.2.dev0__tar.gz → 1.1.0.dev0__tar.gz

{ssm_cli-1.0.2.dev0/ssm_cli.egg-info → ssm_cli-1.1.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssm-cli
-Version: 1.0.2.dev0
+Version: 1.1.0.dev0
 Summary: CLI tool to help with SSM functionality, aimed at adminstrators
 Author-email: Simon Fletcher <simon.fletcher@lexisnexisrisk.com>
 License: MIT License
@@ -35,10 +35,10 @@ Description-Content-Type: text/markdown
 License-File: LICENCE
 Requires-Dist: boto3
 Requires-Dist: paramiko
-Requires-Dist: rich-argparse
 Requires-Dist: rich
 Requires-Dist: confclasses>=0.3.2
 Requires-Dist: xdg_base_dirs
+Requires-Dist: rich-click
 Dynamic: license-file
 
 # SSM CLI

{ssm_cli-1.0.2.dev0 → ssm_cli-1.1.0.dev0}/pyproject.toml

@@ -19,10 +19,10 @@ classifiers = [
 dependencies = [
     "boto3",
     "paramiko",
-    "rich-argparse",
     "rich",
     "confclasses>=0.3.2",
-    "xdg_base_dirs"
+    "xdg_base_dirs",
+    "rich-click"
 ]
 dynamic = ["version"]
 

{ssm_cli-1.0.2.dev0 → ssm_cli-1.1.0.dev0}/ssm_cli/__main__.py

@@ -6,4 +6,4 @@ from ssm_cli.cli import cli
 This is the entry point for the CLI when called as a module. (python -m ssm_cli)
 """
 if __name__ == "__main__":
-    sys.exit(cli())
+    cli()

ssm_cli-1.1.0.dev0/ssm_cli/app.py

@@ -0,0 +1,186 @@
+import rich_click as click
+import confclasses
+
+from ssm_cli.click import PluginGroup, version_option
+from ssm_cli.logging import set_log_level
+from ssm_cli.xdg import get_conf_root, get_conf_file, get_ssh_hostkey
+from ssm_cli.config import CONFIG
+from ssm_cli.ui import console, Table
+
+GREY = "grey50"
+
+import logging
+logger = logging.getLogger(__name__)
+
+@click.group(cls=PluginGroup)
+@click.option_panel("Global Options", options=['--profile', '--log-level', '--version', '--help'])
+@click.option('--profile', type=str, required=False, help="Which AWS profile to use")
+@click.option('--log-level', type=str, required=False, help="Set the logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)")
+@version_option('--version')
+def app(profile, log_level):
+    # Allow setup stuff to log at the right level if passed in
+    if log_level:
+        set_log_level(log_level)
+
+    try:
+        with open(get_conf_file(), 'r') as file:
+            confclasses.load(CONFIG, file)
+            logger.debug(f"Config: {CONFIG}")
+    except EnvironmentError as e:
+        console.print(f"Invalid config: {e}", style="red")
+    
+    if log_level:
+        CONFIG.log.level = log_level
+    if profile:
+        CONFIG.aws_profile = profile
+
+    if not log_level:
+        set_log_level(CONFIG.log.level)
+    elif log_level != logging.DEBUG:
+        for logger_name, level in CONFIG.log.loggers.items():
+            set_log_level(level, name=logger_name)
+
+
+@app.command(help='list all instances in a group, if no group provided, will list all available groups')
+@click.argument('group', required=False, type=str, help="group to run against")
+def list(group):
+    import ssm_cli.instances
+    logger.info(f"running list action (group: {group})")
+
+    instances = ssm_cli.instances.Instances()
+    table = Table()
+
+    if group:
+        table.add_column("ID")
+        table.add_column("Name")
+        table.add_column("IP")
+        table.add_column("Ping")
+        for instance in instances.list_instances(group, True):
+            table.add_row(instance.id, instance.name, instance.ip, instance.ping)
+        console.print(table)
+    else:
+        table.add_column("Group")
+        table.add_column("Total")
+        table.add_column("Online")
+        for group in sorted(instances.list_groups(), key=lambda x: x['name']):
+            table.add_row(group['name'], str(group['total']), str(group['online']))
+        console.print(table)
+
+
+@app.command(help='connects to instance using AWS-StartSession')
+@click.argument('group', type=str, help="group to run against")
+def shell(group):
+    import ssm_cli.instances
+
+    logger.info(f"running shell action (group: {group})")
+
+    instances = ssm_cli.instances.Instances()
+    try:
+        instance = instances.select_instance(group, "tui")
+    except KeyboardInterrupt:
+        logger.error("user cancelled")
+        console.print(f":x: [bold red]user cancelled[/bold red]")
+        return
+
+    if instance is None:
+        logger.error("failed to select host")
+        console.print(f":x: [bold red]failed to select host[/bold red]")
+        return
+
+    logger.info(f"connecting to {repr(instance)}")
+    console.print(f":computer: [bold green]connecting to {instance.name} ({instance.id})[/bold green]")
+
+    instance.start_session()
+
+@app.command(help="ssh proxy, used for automatic tunnels without ssh auth")
+@click.argument('group', type=str, help="group to run against")
+def sshproxy(group):
+    import ssm_cli.instances
+    import ssm_cli.ssh_proxy.server
+
+    logger.info(f"running proxycommand action (group: {group})")
+
+    instances = ssm_cli.instances.Instances()
+    instance = instances.select_instance(group, "first")
+
+    if instance is None:
+        logger.error("failed to select host")
+        raise RuntimeError("failed to select host")
+
+    logger.info(f"connecting to {repr(instance)}")
+    
+    server = ssm_cli.ssh_proxy.server.SshServer(instance)
+    server.start()
+
+@app.command(help="setups up ssm-cli, can be rerun safely")
+@click.option("--replace-config", is_flag=True, help="if we should replace existing config file")
+@click.option("--replace-hostkey", is_flag=True, help="if we should replace existing hostkey file (be careful with this option)")
+def setup(replace_config, replace_hostkey):
+    # Create the root config directory
+    root = get_conf_root(False)
+    logger.debug(f"Checking if {root} exists")
+    if root.exists():
+        logger.debug(f"{root} exists")
+        if not root.is_dir():
+            logger.error(f"{root} already exists and is not a directory. Manual cleanup is likely needed.")
+            console.print(f"{root} already exists and is not a directory. Manual cleanup is likely needed.", style="red bold")
+            return
+        console.print(f"{root} - skipping (already exists)", style=GREY)
+    else:
+        root.mkdir(511, True, True)
+        console.print(f"{root} created", style="green")
+
+
+    # Create the config file
+    path = get_conf_file(False)
+    logger.debug(f"Checking if {path} exists")
+    create_config = False
+    if path.exists():
+        logger.debug(f"{path} exists")
+        if replace_config:
+            logger.info(f"{path} exists and --replace-config was set, unlink {path}")
+            console.print(f"{path} removing", style="green")
+            path.unlink(True)
+            create_config = True
+    else:
+        logger.debug(f"{path} does not exist")
+        create_config = True
+
+    if create_config:
+        import rich.markup
+
+        logger.info(f"{path} creating")
+        console.print(f"{path} creating", style="green")
+        confclasses.from_dict(CONFIG, {})
+        text = rich.markup.escape(f"What tag to use to split up the instances [{CONFIG.group_tag_key}]: ")
+        tag_key = console.input(text)
+        CONFIG.group_tag_key = tag_key or CONFIG.group_tag_key
+        console.print(f"Using '{CONFIG.group_tag_key}' as the group tag", style=GREY)
+        logger.info(f"Writing config to {path}")
+
+        with path.open("w+") as f:
+            confclasses.save(CONFIG, f)
+            console.print(f"{path} created", style="green")
+
+    # Create the ssh hostkey
+    path = get_ssh_hostkey(False)
+    create_key = False
+    if path.exists():
+        logger.debug(f"{path} exists")
+        console.print(f"{path} skipping (already exists)")
+        if replace_hostkey:
+            logger.info(f"{path} exists and --replace-hostkey was set, unlink {path}")
+            console.print(f"{path} removing", style="green")
+            path.unlink(True)
+            create_key = True
+    else:
+        logger.debug(f"{path} does not exist")
+        create_key = True
+    
+    if create_key:
+        import paramiko
+
+        logger.info(f"{path} creating")
+        host_key = paramiko.RSAKey.generate(1024)
+        host_key.write_private_key_file(path)
+        console.print(f"{path} created")

{ssm_cli-1.0.2.dev0 → ssm_cli-1.1.0.dev0}/ssm_cli/aws.py

@@ -1,7 +1,13 @@
 import boto3
 import botocore
 import contextlib
-from ssm_cli.cli_args import ARGS
+from threading import local
+
+from ssm_cli.config import CONFIG
+
+_cache = local()
+_cache.client_cache = {}
+_cache.session_cache = None
 
 class AWSError(Exception):
     """ A generic exception for any AWS errors """
@@ -15,22 +21,20 @@ class AWSAccessDeniedError(AWSError):
     """ An exception for when the AWS credentials do not have the required permissions """
     pass
 
-_session_cache = []
-_client_cache = {}
-
 @contextlib.contextmanager
 def aws_session(use_cache=True):
     """ A context manager for creating a boto3 session with caching built in """
     try:
-        if len(_session_cache) > 0 and use_cache:
-            yield _session_cache[0]
+         # TODO, check its still valid
+        if _cache.session_cache is not None and use_cache:
+            yield _cache.session_cache
             return
         
-        session = boto3.Session(profile_name=ARGS.global_args.profile)
+        session = boto3.Session(profile_name=CONFIG.aws_profile)
         if session.region_name is None:
             raise AWSAuthError(f"AWS config missing region for profile {session.profile_name}")
         
-        _session_cache.append(session)
+        _cache.session_cache = session
         yield session
     except botocore.exceptions.ProfileNotFound as e:
         raise AWSAuthError(f"profile invalid") from e
@@ -45,10 +49,10 @@ def aws_session(use_cache=True):
 def aws_client(service_name, use_cache=True):
     """ A context manager for creating a boto3 client with caching built in """
     with aws_session(use_cache) as session:
-        if service_name in _client_cache and use_cache:
-            yield _client_cache[service_name]
+        if service_name in _cache.client_cache and use_cache:
+            yield _cache.client_cache[service_name]
             return
         
         client = session.client(service_name)
-        _client_cache[service_name] = client
+        _cache.client_cache[service_name] = client
         yield client

ssm_cli-1.1.0.dev0/ssm_cli/cli.py

@@ -0,0 +1,49 @@
+import sys
+from typing import List
+from ssm_cli.xdg import get_log_file
+from ssm_cli.aws import AWSAuthError, AWSAccessDeniedError
+from ssm_cli.ui import console
+from ssm_cli.logging import setup_logging, set_log_level
+from rich.markup import escape
+from ssm_cli.app import app
+
+import logging
+logger = logging.getLogger(__name__)
+
+def cli(argv:List[str]=None) -> int:
+    """ Entry point for ssm-cli, we use this wrapper to put all the aws errors in one place. Otherwise we would need to exit in the aws class and avoid finally statements being hit. """
+    if argv is None:
+        argv = sys.argv[1:]
+    
+    setup_logging()
+
+    # Manually set the log level now, so we get accurate logging during startup
+    for i, arg in enumerate(argv):
+        if arg == '--log-level':
+            set_log_level(argv[i+1])
+        if arg.startswith('--log-level='):
+            set_log_level(arg.split('=')[1])
+
+    logger.info(f"ssm cli called")
+    logger.debug(f"sys.argv {sys.argv}")
+
+    try:
+        app(argv)
+        logger.info(f"Command completed successfully")
+        return 0
+    except AWSAuthError as e:
+        console.print(f"AWS Authentication error: {e}", style="red")
+        return 1
+    except AWSAccessDeniedError as e:
+        logger.error(f"access denied: {e}")
+        console.print(f"Access denied, see README for details on required permissions", style="bold red")
+        console.print(escape(str(e.__cause__)), style="grey50")
+        return 1
+    except Exception as e:
+        logger.error(f"Unhandled exception")
+        log_path = str(get_log_file())
+        console.print(f"Unhandled exception, check [link=file://{log_path}]{log_path}[/link] for more information", style="red")
+        console.print(f"Error: {e}", style="red bold")
+        logger.exception(e, stack_info=True, stacklevel=20)
+        return 1
+    

ssm_cli-1.1.0.dev0/ssm_cli/click.py

@@ -0,0 +1,77 @@
+"""
+Keeping click (or rich_click) lower level logic in one place.
+"""
+
+from rich_click import RichCommand, RichContext, RichGroup, RichHelpFormatter, Context, Parameter, option
+
+def version_callback(ctx: Context, param: Parameter, value: bool) -> None:
+    """
+    Custom version printing logic to go and get install path and the smp version
+    """
+    if not value or ctx.resilient_parsing:
+        return
+    
+    import sys
+    import subprocess
+    import importlib.metadata
+    import os
+
+    try:
+        results = subprocess.run(["session-manager-plugin", "--version"], capture_output=True, text=True)
+    except FileNotFoundError:
+        print("session-manager-plugin not found", file=sys.stderr)
+    
+    pkg_dir = os.path.join(os.path.dirname(__file__), "..")
+    pkg_dir = os.path.abspath(pkg_dir)
+    print(f"ssm-cli {importlib.metadata.version('ssm-cli')} from {pkg_dir}")
+    v = sys.version_info
+    print(f"python {v.major}.{v.minor}.{v.micro}")
+    print(f"session-manager-plugin {results.stdout.strip()}")
+    ctx.exit()
+
+def version_option(*param_decls):
+    """
+    Use like the click.version_option.
+    """
+    return option(*param_decls, is_flag=True, expose_value=False, is_eager=True, help="Show the version and exit", callback=version_callback)
+
+class PluginCommand(RichCommand):
+    def format_help(self, ctx: RichContext, formatter: RichHelpFormatter) -> None:
+        # Subcommand help doesn't contain the options of global, so pull them in now
+        if ctx.parent is not None:
+            ctx.command.panels += ctx.parent.command.panels
+            ctx.command.params += ctx.parent.command.params
+        
+        super().format_help(ctx, formatter)
+
+class PluginGroup(RichGroup):
+    def __init__(self, **kwargs) -> None:
+        self.command_class = PluginCommand
+        
+        super().__init__(context_settings={
+            "allow_interspersed_args": True,
+            # When developing the allow_interspersed_args, I kept finding these other settings in examples.
+            # I haven't found them necessary, so leaving commented if they become useful:
+            # "allow_extra_args": True,
+            # "ignore_unknown_options": True
+        }, **kwargs)
+    
+    def parse_args(self, ctx, args):
+        # Intercept parsing args in the case of help because of the allow_interspersed_args setting.
+        # All we need to do is find out if a command is in the args as well and then pass the context down to that command.
+        # This is not perfect as it doesnt handle this example well: 
+        #   `--help --profile shell`
+        # Work arounds could be done but cannot see this happening in the wild. This is a complex fix for little gain.
+        # Time spent so far: 2 hours
+        args_set = set(args)
+        help_args = args_set & set(self.get_help_option_names(ctx))
+        if help_args:
+            cmd_args = args_set & set(self.list_commands(ctx))
+            if cmd_args:
+                cmd = self.get_command(ctx, cmd_args.pop())
+                if cmd:
+                    parent_ctx = ctx
+                    args.remove(cmd.name)
+                    ctx = cmd.make_context(cmd.name, args, parent=parent_ctx)
+
+        return super().parse_args(ctx, args)

{ssm_cli-1.0.2.dev0 → ssm_cli-1.1.0.dev0}/ssm_cli/config.py

@@ -1,16 +1,6 @@
 from typing import Dict
 from confclasses import confclass
 
-# See cli_args for more info but this needs a rethink to be easier to use/add to
-
-@confclass
-class ProxyCommandConfig:
-    selector: str = "first"
-
-@confclass
-class ActionsConfig:
-    proxycommand: ProxyCommandConfig
-    
 @confclass
 class LoggingConfig:
     level: str = "info"
@@ -23,8 +13,9 @@ class LoggingConfig:
 @confclass
 class Config:
     log: LoggingConfig
-    actions: ActionsConfig
     group_tag_key: str = "group"
     """Tag key to use when filtering, this is usually set during ssm setup."""
-
+    aws_profile: str = "default"
+    """AWS profile to use when connecting to AWS services, often overridden by --profile"""
+    
 CONFIG = Config()

{ssm_cli-1.0.2.dev0 → ssm_cli-1.1.0.dev0}/ssm_cli/logging.py

@@ -4,6 +4,7 @@ from datetime import datetime, timedelta
 from typing import Optional
 from ssm_cli.xdg import get_log_file, get_all_log_files
 
+logger = logging.getLogger(__name__)
 
 def setup_logging(name:str = "cli"):
     """Set up basic logging configuration with date-based rotation."""
@@ -17,8 +18,9 @@ def setup_logging(name:str = "cli"):
     start_log_cleanup()
 
 
-def configure_log_level(level: str, name: Optional[str] = None):
+def set_log_level(level: str, name: Optional[str] = None):
     """Configure logger level."""
+    logger.debug(f"setting logger {name} to {level}")
     logging.getLogger(name).setLevel(level.upper())
 
 

ssm_cli-1.1.0.dev0/ssm_cli/selectors/tui.py

@@ -0,0 +1,22 @@
+from ssm_cli.ui import console, LiveTableWithNavigation
+
+def select(instances: list):
+    with LiveTableWithNavigation(console=console, screen=True) as live:
+        table = live.table
+        table.add_column("Id")
+        table.add_column("Name")
+        table.add_column("Ping")
+        table.add_column("IP")
+        for instance in instances:
+            table.add_row(
+                instance.id,
+                instance.name,
+                instance.ping,
+                instance.ip,
+            )
+        
+        live.refresh()
+        while live.handle_input():
+            live.refresh()
+        
+        return instances[live.table._selected_row]

{ssm_cli-1.0.2.dev0/ssm_cli/commands → ssm_cli-1.1.0.dev0/ssm_cli}/ssh_proxy/forwarding.py

@@ -14,6 +14,7 @@ The manager side is the code that runs in a separate process and is responsible
 
 """
 
+import io
 import socket
 from typing import Dict, Any, List
 import time
@@ -22,10 +23,10 @@ import multiprocessing
 import threading
 from multiprocessing.connection import Connection
 
-from ssm_cli.aws import aws_client
-from ssm_cli.cli_args import ARGS
-from ssm_cli.config import CONFIG
+from ssm_cli.aws import aws_client, setup_aws, get_profile
 from ssm_cli.instances import Instance, SessionManagerPluginError, SessionManagerPluginPortError
+from ssm_cli.config import CONFIG
+from confclasses import load, save
 
 import logging
 
@@ -208,23 +209,25 @@ class PortForwardingManagerProcess(multiprocessing.Process):
     def __init__(self, pipe: Connection, instance: Instance):
         self.pipe = pipe
         self.instance = instance
-        self.log_level = CONFIG.log.level
-        self.log_loggers = CONFIG.log.loggers
-        self.profile = ARGS.global_args.profile
+
+        with io.StringIO() as f:
+            save(CONFIG, f)
+        
+        self.config_yaml = f.getvalue()
         super().__init__()
     
     def run(self):
         # Rebuild some global state that ssm_cli.cli normally deals with, the manager process is a clean slate,
         # We can be selective about what we rebuild
         # when config/args are refactored, this should be taken into account.
-        from ssm_cli.logging import setup_logging, configure_log_level
+        from ssm_cli.logging import setup_logging, set_log_level
         setup_logging("manager")
-        configure_log_level(self.log_level)
-        for logger_name, level in self.log_loggers.items():
-            configure_log_level(level, name=logger_name)
+        set_log_level(CONFIG.log.level)
+        for logger_name, level in CONFIG.log.loggers.items():
+            set_log_level(level, name=logger_name)
         
-        from ssm_cli.cli_args import ARGS, CliNamespace
-        ARGS.global_args = CliNamespace(profile=self.profile)
+        with io.StringIO(self.config_yaml) as f:
+            load(CONFIG, f)
         self.sessions = []
         self.pipe.send("ready")
         while True:

{ssm_cli-1.0.2.dev0/ssm_cli/commands → ssm_cli-1.1.0.dev0/ssm_cli}/ssh_proxy/server.py

@@ -2,13 +2,12 @@ import threading
 import paramiko
 import socket
 import time
-from typing import Dict
 import select
 
-from ssm_cli.commands.ssh_proxy.socket import StdIoSocket
-from ssm_cli.commands.ssh_proxy.shell import ShellThread
-from ssm_cli.commands.ssh_proxy.channels import Channels
-from ssm_cli.commands.ssh_proxy.forwarding import PortForwarding, PortForwardingSession
+from ssm_cli.ssh_proxy.socket import StdIoSocket
+from ssm_cli.ssh_proxy.shell import ShellThread
+from ssm_cli.ssh_proxy.channels import Channels
+from ssm_cli.ssh_proxy.forwarding import PortForwarding, PortForwardingSession
 from ssm_cli.xdg import get_ssh_hostkey
 from ssm_cli.instances import Instance
 

{ssm_cli-1.0.2.dev0/ssm_cli/commands → ssm_cli-1.1.0.dev0/ssm_cli}/ssh_proxy/shell.py

@@ -2,7 +2,7 @@ import threading
 import paramiko
 import select
 
-from ssm_cli.commands.ssh_proxy.channels import Channels
+from ssm_cli.ssh_proxy.channels import Channels
 
 import logging
 logger = logging.getLogger(__name__)

ssm_cli-1.1.0.dev0/ssm_cli/ui.py

@@ -0,0 +1,54 @@
+from rich import box
+from rich.live import Live
+from rich.table import Table as RichTable
+from rich.console import Console
+from rich.style import StyleType
+from readchar import readkey, key
+
+console = Console()
+
+class Table(RichTable):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('box', box.ROUNDED)
+        super().__init__(*args, **kwargs)
+
+class TableWithNavigation(Table):
+    def __init__(self, *args, selected_row=0, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._selected_row = selected_row
+
+    def up(self):
+        if self._selected_row > 0:
+            self._selected_row -= 1
+
+    def down(self):
+        if self._selected_row < len(self.rows) - 1:
+            self._selected_row += 1
+
+    def get_row_style(self, console: Console, index: int) -> StyleType:
+        style = super().get_row_style(console, index)
+        if index == self._selected_row:
+            style += console.get_style("on blue")
+        return style
+    
+class LiveTableWithNavigation(Live):
+    def __init__(self, *args, **kwargs):
+        self.table = TableWithNavigation()
+        kwargs.setdefault('auto_refresh', False)
+        super().__init__(*args, **kwargs)
+    
+    def get_renderable(self):
+        return self.table
+
+    def handle_input(self) -> bool:
+        """ Return False to exit """
+        ch=readkey()
+        if ch == key.UP:
+            self.table.up()
+        elif ch == key.DOWN:
+            self.table.down()
+        elif ch == key.CTRL_C:
+            raise KeyboardInterrupt()
+        elif ch in key.ENTER:
+            return False
+        return True

{ssm_cli-1.0.2.dev0 → ssm_cli-1.1.0.dev0/ssm_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssm-cli
-Version: 1.0.2.dev0
+Version: 1.1.0.dev0
 Summary: CLI tool to help with SSM functionality, aimed at adminstrators
 Author-email: Simon Fletcher <simon.fletcher@lexisnexisrisk.com>
 License: MIT License
@@ -35,10 +35,10 @@ Description-Content-Type: text/markdown
 License-File: LICENCE
 Requires-Dist: boto3
 Requires-Dist: paramiko
-Requires-Dist: rich-argparse
 Requires-Dist: rich
 Requires-Dist: confclasses>=0.3.2
 Requires-Dist: xdg_base_dirs
+Requires-Dist: rich-click
 Dynamic: license-file
 
 # SSM CLI

ssm_cli-1.1.0.dev0/ssm_cli.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENCE
+README.md
+pyproject.toml
+ssm_cli/__init__.py
+ssm_cli/__main__.py
+ssm_cli/app.py
+ssm_cli/aws.py
+ssm_cli/cli.py
+ssm_cli/click.py
+ssm_cli/config.py
+ssm_cli/instances.py
+ssm_cli/logging.py
+ssm_cli/ui.py
+ssm_cli/xdg.py
+ssm_cli.egg-info/PKG-INFO
+ssm_cli.egg-info/SOURCES.txt
+ssm_cli.egg-info/dependency_links.txt
+ssm_cli.egg-info/entry_points.txt
+ssm_cli.egg-info/requires.txt
+ssm_cli.egg-info/top_level.txt
+ssm_cli/selectors/__init__.py
+ssm_cli/selectors/first.py
+ssm_cli/selectors/tui.py
+ssm_cli/ssh_proxy/__init__.py
+ssm_cli/ssh_proxy/channels.py
+ssm_cli/ssh_proxy/forwarding.py
+ssm_cli/ssh_proxy/server.py
+ssm_cli/ssh_proxy/shell.py
+ssm_cli/ssh_proxy/socket.py