aws-ssh-utils 0.2.5__tar.gz → 0.2.7__tar.gz

{aws_ssh_utils-0.2.5 → aws_ssh_utils-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aws-ssh-utils
-Version: 0.2.5
+Version: 0.2.7
 Summary: Easy AWS SSHing
 Project-URL: Homepage, https://github.com/mvanderlee/aws-ssh-utils
 Author-email: Michiel Vanderlee <jmt.vanderlee@gmail.com>
@@ -41,15 +41,15 @@ Description-Content-Type: text/markdown
 [![Supported Python Versions](https://img.shields.io/pypi/pyversions/aws-ssh-utils.svg)](https://pypi.org/project/aws-ssh-utils/)
 
 ```shell
-pip install aws-ssh-utils
+uvx aws-ssh-utils
 
-aws_ssh ec2
+uvx aws-ssh-utils app  # optional - `app` is default.
+uvx aws-ssh-utils ec2
+uvx aws-ssh-utils emr
+uvx aws-ssh-utils emr-all
 
-aws_ssh emr
-
-aws_ssh emr-all
-
-aws_ssh app
+# Also exposed as `aws_ssh`
+uvx --from aws-ssh-utils aws_ssh
 ```
 
 This allows you to interactively SSH to an EC2 instance, EMR instance, or all EMR instances with TMUX.

{aws_ssh_utils-0.2.5 → aws_ssh_utils-0.2.7}/README.md

@@ -1,114 +1,114 @@
-# AWS SSH Utils
-
-[![Version](https://img.shields.io/pypi/v/aws-ssh-utils.svg)](https://pypi.org/project/aws-ssh-utils/)
-[![License](https://img.shields.io/pypi/l/aws-ssh-utils.svg)](#)
-[![Supported Python Versions](https://img.shields.io/pypi/pyversions/aws-ssh-utils.svg)](https://pypi.org/project/aws-ssh-utils/)
-
-```shell
-pip install aws-ssh-utils
-
-aws_ssh ec2
-
-aws_ssh emr
-
-aws_ssh emr-all
-
-aws_ssh app
-```
-
-This allows you to interactively SSH to an EC2 instance, EMR instance, or all EMR instances with TMUX.
-
-It utilizes [questionary](https://pypi.org/project/questionary/) to ask you which instance you want to connect to.
-
-## App
-
-Terminal UI to browse EC2 instances and EMR clusters, with SSH shells in tabs.
-It's the default command, so `aws_ssh` and `aws_ssh -p my-profile` launch it too.
-Each connection tries, in order: `~/.ssh/config`, SSH over AWS SSM (`session-manager-plugin`), opkssh (via instance/cluster tags),
-the instance's EC2 key found in `~/.ssh`, then your default keys/ssh-agent.
-Unknown host keys are accepted and appended to `~/.ssh/known_hosts`; changed host keys are rejected.
-
-```shell
-$ aws_ssh app --help
-Usage: aws_ssh app [OPTIONS]
-
-  Browse EC2 instances and EMR clusters, and open SSH shells in tabs.
-
-Options:
-  -p, --profile TEXT          Which AWS profile to use
-  -r, --region TEXT           Which AWS region to use
-  --scrollback INTEGER RANGE  Lines of scrollback per shell. Defaults to your
-                              tmux or Windows Terminal setting, else 1000.
-                              [x>=0]
-  --help                      Show this message and exit.
-```
-
-Scroll back with the mouse wheel or `shift+PgUp`/`shift+PgDn`; typing jumps back to the prompt.
-`F12` shows/hides the sidebar, `ctrl+w` closes a failed tab, `ctrl+q` quits. Every other key goes to the focused shell.
-Logs are viewable with `textual console`.
-
-## EC2
-
-Select an instance from an interactive list. You can filter the instances by name.
-
-```shell
-$ aws_auth ec2 --help
-Usage: aws_ssh ec2 [OPTIONS]
-
-  Asks user which EC2 instance they want to connect to, then opens an
-  interactive SSH session to the instance
-
-Options:
-  -p, --profile TEXT    Which AWS profile to use
-  -r, --region TEXT     Which AWS region to use
-  -u, --user TEXT       Which user to connect as
-  --private / --public  Connect to the instance's private or public IP
-  -k, --key-file FILE   Which key file to use to connect
-  --scrollback INTEGER RANGE
-                        Lines of scrollback per shell. Defaults to your tmux or
-                        Windows Terminal setting, else 1000.  [x>=0]
-  --help                Show this message and exit.
-```
-
-## EMR
-
-Select the EMR cluster, instance group, and instance to connect to.
-
-```shell
-$ aws_ssh emr --help
-Usage: aws_ssh emr [OPTIONS]
-
-  Asks user which Cluster and EC2 instance they want to connect to, then opens an interactive SSH session to the instance
-
-Options:
-  -p, --profile TEXT    Which AWS profile to use
-  -r, --region TEXT     Which AWS region to use
-  -u, --user TEXT       Which user to connect as
-  --private / --public  Connect to the instance's private or public IP
-  -k, --key-file FILE   Which key file to use to connect
-  --scrollback INTEGER RANGE
-                        Lines of scrollback per shell. Defaults to your tmux or
-                        Windows Terminal setting, else 1000.  [x>=0]
-  --help                Show this message and exit.
-```
-
-## EMR All
-
-Select the EMR cluster to connect to. Then creates a new TMUX session with a window per instance. Each window will have an SSH connection to that instance open.
-
-```shell
-$ aws_ssh emr-all --help
-Usage: aws_ssh emr-all [OPTIONS]
-
-  Asks user which Cluster and EC2 instance they want to connect to, Then
-  prints a tmux cli statement that will open a new session with a window per
-  ec2 instance with ssh shell already opened.
-
-Options:
-  -p, --profile TEXT    Which AWS profile to use
-  -r, --region TEXT     Which AWS region to use
-  -u, --user TEXT       Which user to connect as
-  --private / --public  Connect to the instance's private or public IP
-  -k, --key-file FILE   Which key file to use to connect
-  --help                Show this message and exit.
-```
+# AWS SSH Utils
+
+[![Version](https://img.shields.io/pypi/v/aws-ssh-utils.svg)](https://pypi.org/project/aws-ssh-utils/)
+[![License](https://img.shields.io/pypi/l/aws-ssh-utils.svg)](#)
+[![Supported Python Versions](https://img.shields.io/pypi/pyversions/aws-ssh-utils.svg)](https://pypi.org/project/aws-ssh-utils/)
+
+```shell
+uvx aws-ssh-utils
+
+uvx aws-ssh-utils app  # optional - `app` is default.
+uvx aws-ssh-utils ec2
+uvx aws-ssh-utils emr
+uvx aws-ssh-utils emr-all
+
+# Also exposed as `aws_ssh`
+uvx --from aws-ssh-utils aws_ssh
+```
+
+This allows you to interactively SSH to an EC2 instance, EMR instance, or all EMR instances with TMUX.
+
+It utilizes [questionary](https://pypi.org/project/questionary/) to ask you which instance you want to connect to.
+
+## App
+
+Terminal UI to browse EC2 instances and EMR clusters, with SSH shells in tabs.
+It's the default command, so `aws_ssh` and `aws_ssh -p my-profile` launch it too.
+Each connection tries, in order: `~/.ssh/config`, SSH over AWS SSM (`session-manager-plugin`), opkssh (via instance/cluster tags),
+the instance's EC2 key found in `~/.ssh`, then your default keys/ssh-agent.
+Unknown host keys are accepted and appended to `~/.ssh/known_hosts`; changed host keys are rejected.
+
+```shell
+$ aws_ssh app --help
+Usage: aws_ssh app [OPTIONS]
+
+  Browse EC2 instances and EMR clusters, and open SSH shells in tabs.
+
+Options:
+  -p, --profile TEXT          Which AWS profile to use
+  -r, --region TEXT           Which AWS region to use
+  --scrollback INTEGER RANGE  Lines of scrollback per shell. Defaults to your
+                              tmux or Windows Terminal setting, else 1000.
+                              [x>=0]
+  --help                      Show this message and exit.
+```
+
+Scroll back with the mouse wheel or `shift+PgUp`/`shift+PgDn`; typing jumps back to the prompt.
+`F12` shows/hides the sidebar, `ctrl+w` closes a failed tab, `ctrl+q` quits. Every other key goes to the focused shell.
+Logs are viewable with `textual console`.
+
+## EC2
+
+Select an instance from an interactive list. You can filter the instances by name.
+
+```shell
+$ aws_auth ec2 --help
+Usage: aws_ssh ec2 [OPTIONS]
+
+  Asks user which EC2 instance they want to connect to, then opens an
+  interactive SSH session to the instance
+
+Options:
+  -p, --profile TEXT    Which AWS profile to use
+  -r, --region TEXT     Which AWS region to use
+  -u, --user TEXT       Which user to connect as
+  --private / --public  Connect to the instance's private or public IP
+  -k, --key-file FILE   Which key file to use to connect
+  --scrollback INTEGER RANGE
+                        Lines of scrollback per shell. Defaults to your tmux or
+                        Windows Terminal setting, else 1000.  [x>=0]
+  --help                Show this message and exit.
+```
+
+## EMR
+
+Select the EMR cluster, instance group, and instance to connect to.
+
+```shell
+$ aws_ssh emr --help
+Usage: aws_ssh emr [OPTIONS]
+
+  Asks user which Cluster and EC2 instance they want to connect to, then opens an interactive SSH session to the instance
+
+Options:
+  -p, --profile TEXT    Which AWS profile to use
+  -r, --region TEXT     Which AWS region to use
+  -u, --user TEXT       Which user to connect as
+  --private / --public  Connect to the instance's private or public IP
+  -k, --key-file FILE   Which key file to use to connect
+  --scrollback INTEGER RANGE
+                        Lines of scrollback per shell. Defaults to your tmux or
+                        Windows Terminal setting, else 1000.  [x>=0]
+  --help                Show this message and exit.
+```
+
+## EMR All
+
+Select the EMR cluster to connect to. Then creates a new TMUX session with a window per instance. Each window will have an SSH connection to that instance open.
+
+```shell
+$ aws_ssh emr-all --help
+Usage: aws_ssh emr-all [OPTIONS]
+
+  Asks user which Cluster and EC2 instance they want to connect to, Then
+  prints a tmux cli statement that will open a new session with a window per
+  ec2 instance with ssh shell already opened.
+
+Options:
+  -p, --profile TEXT    Which AWS profile to use
+  -r, --region TEXT     Which AWS region to use
+  -u, --user TEXT       Which user to connect as
+  --private / --public  Connect to the instance's private or public IP
+  -k, --key-file FILE   Which key file to use to connect
+  --help                Show this message and exit.
+```

aws_ssh_utils-0.2.7/aws_ssh_utils/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.7"

{aws_ssh_utils-0.2.5 → aws_ssh_utils-0.2.7}/aws_ssh_utils/cli_utils.py

@@ -6,10 +6,11 @@ import json
 import os
 import subprocess
 import sys
-from collections.abc import Callable
+import time
+from collections.abc import Callable, Sequence
 from pathlib import Path
 from shutil import which
-from typing import ParamSpec, TypeVar
+from typing import ParamSpec, TypeVar, cast
 
 import click
 import paramiko
@@ -17,11 +18,14 @@ import questionary
 from botocore.exceptions import ClientError
 from loguru import logger
 from rich.console import Console
+from rich.live import Live
 from rich.markup import escape
+from rich.spinner import Spinner
 from rich.status import Status
+from rich.text import Text
 
 from aws_ssh_utils.commands.healthcheck import is_aws_ssm_installed, is_opkssh_installed
-from aws_ssh_utils.connection import Environment, Target, connect, open_shell_channel
+from aws_ssh_utils.connection import Attempt, Environment, Target, connect, open_shell_channel
 from aws_ssh_utils.terminal import ShellApp
 
 P = ParamSpec('P')
@@ -37,6 +41,7 @@ WINDOWS_TERMINAL_SETTINGS = (
 """Relative to %LOCALAPPDATA%: Store, Store preview, and unpackaged installs."""
 
 console = Console(stderr=True)
+connecting_spinner = Spinner('dots')
 
 
 class ShellError(Exception):
@@ -50,6 +55,29 @@ def spinner(message: str = '') -> Status:
     return console.status(message, spinner='dots')
 
 
+def render_attempts(attempts: Sequence[Attempt]) -> Text:
+    """The connection checklist: done attempts, the current one with a spinner, and the remaining ones muted."""
+
+    def line(attempt: Attempt) -> Text:
+        match attempt.state:
+            case 'connecting':
+                frame = cast(Text, connecting_spinner.render(time.monotonic()))
+                return Text.assemble(frame, f" Connecting via {attempt.via} ...")
+            case 'connected':
+                return Text(f"✓ Connected via {attempt.via}", 'green')
+            case 'failed':
+                return Text.assemble(
+                    f"❌ Failed to connect via {attempt.via} - {attempt.detail}\n",
+                    (f"    {attempt.command}", 'dim'),
+                )
+            case 'skipped':
+                return Text(f"  {attempt.detail}, skipping.", 'dim')
+            case 'pending':
+                return Text(f"  {attempt.via}", 'dim')
+
+    return Text('\n').join(line(a) for a in attempts)
+
+
 def handle_errors(func: Callable[P, R]) -> Callable[P, R]:
     """Log ShellErrors and AWS errors, and exit, instead of printing a traceback."""
 
@@ -145,10 +173,28 @@ def open_shell(target: Target, env: Environment, title: str, scrollback: int | N
 
     `scrollback` defaults to the terminal's own setting, see `detect_scrollback`.
     """
-    result = connect(target, env, on_output=logger.info, on_waiting=lambda: None, confirm_host_key=confirm_host_key)
-    if isinstance(result, list):
-        for line in result:
-            console.print(escape(line))
+    attempts: list[Attempt] = []
+    with Live(console=console, get_renderable=lambda: render_attempts(attempts)) as live:
+
+        def on_progress(snapshot: list[Attempt]):
+            attempts[:] = snapshot
+
+        def confirm(hostname: str, key: paramiko.PKey) -> bool:
+            live.stop()
+            try:
+                return confirm_host_key(hostname, key)
+            finally:
+                live.start()
+
+        result = connect(
+            target,
+            env,
+            on_output=lambda line: live.console.print(escape(line)),
+            on_waiting=lambda: None,
+            on_progress=on_progress,
+            confirm_host_key=confirm,
+        )
+    if result is None:
         raise ShellError(f'Failed to connect to {target.user}@{target.ip}')
 
     channel = open_shell_channel(result.client)

{aws_ssh_utils-0.2.5 → aws_ssh_utils-0.2.7}/aws_ssh_utils/commands/app.py

@@ -22,8 +22,8 @@ from textual.widgets import Footer, Input, OptionList, RichLog, Static, TabbedCo
 from textual.widgets.option_list import Option
 from textual.widgets.tree import TreeNode
 
-from aws_ssh_utils.cli_utils import detect_environment, detect_scrollback, scrollback_option
-from aws_ssh_utils.connection import Environment, Target, connect, open_shell_channel
+from aws_ssh_utils.cli_utils import detect_environment, detect_scrollback, render_attempts, scrollback_option
+from aws_ssh_utils.connection import Attempt, Environment, Target, connect, open_shell_channel
 from aws_ssh_utils.ec2_utils import ec2_name, ec2_target, get_running_ec2_instances
 from aws_ssh_utils.emr_utils import emr_target, get_emr_clusters, get_emr_instances, group_role, group_sort_key
 from aws_ssh_utils.terminal import ShellStatus, Terminal
@@ -99,8 +99,10 @@ class ShellPane(TabPane):
         self.scrollback = scrollback
         self.status: Status = 'connecting'
         self.spinner = Spinner('dots')
+        self.attempts: list[Attempt] = []
 
     def compose(self) -> ComposeResult:
+        yield Static(classes='attempts')
         yield RichLog(wrap=True, markup=True)
 
     def on_mount(self):
@@ -110,6 +112,11 @@ class ShellPane(TabPane):
     def update_label(self):
         icon = cast(Text, self.spinner.render(time.monotonic())) if self.status == 'connecting' else STATUS_ICONS[self.status]
         self.query_ancestor(TabbedContent).get_tab(self).label = Text.assemble(icon, ' ', self.title_)
+        self.query_one('.attempts', Static).update(render_attempts(self.attempts))
+
+    def set_attempts(self, attempts: list[Attempt]):
+        self.attempts = attempts
+        self.update_label()
 
     def set_status(self, status: Status):
         self.status = status
@@ -131,10 +138,9 @@ class ShellPane(TabPane):
                 self.env,
                 on_output=write,
                 on_waiting=lambda: self.app.call_from_thread(self.set_status, 'waiting'),
+                on_progress=lambda attempts: self.app.call_from_thread(self.set_attempts, attempts),
             )
-            if isinstance(result, list):
-                for line in result:
-                    write(line)
+            if result is None:
                 self.app.call_from_thread(self.set_status, 'failed')
                 return
 
@@ -149,6 +155,7 @@ class ShellPane(TabPane):
 
     async def attach(self, via: str, terminal: Terminal):
         await self.query_one(RichLog).remove()
+        await self.query_one('.attempts').remove()
         await self.mount(ShellStatus(via), terminal)
         self.set_status('connected')
 

{aws_ssh_utils-0.2.5 → aws_ssh_utils-0.2.7}/aws_ssh_utils/connection.py

@@ -7,12 +7,12 @@ import subprocess
 import threading
 import time
 from collections.abc import Callable, Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field, replace
 from fnmatch import fnmatch
 from functools import partial
 from hashlib import sha256
 from pathlib import Path
-from typing import IO, cast
+from typing import IO, Literal, cast
 
 import paramiko
 from loguru import logger
@@ -59,14 +59,29 @@ class Connection:
     """How the connection was made: AWS SSM, opkssh, a key name, ..."""
 
 
+@dataclass(frozen=True)
+class Attempt:
+    via: str
+    command: str
+    """The equivalent command line, to retry by hand."""
+    open_client: Callable[[], paramiko.SSHClient] = field(repr=False, compare=False)
+    state: Literal['pending', 'connecting', 'connected', 'failed', 'skipped'] = 'pending'
+    detail: str = ''
+    """The error when failed, the reason when skipped."""
+
+
+OnProgress = Callable[[list[Attempt]], None]
+
+
 def connect(
     target: Target,
     env: Environment,
     on_output: OnOutput,
     on_waiting: Callable[[], None],
+    on_progress: OnProgress,
     confirm_host_key: ConfirmHostKey | None = None,
-) -> Connection | list[str]:
-    """Return the first successful connection, or the failure checklist.
+) -> Connection | None:
+    """Return the first successful connection, or None when all fail.
 
     Tried in order:
     1. ~/.ssh/config, when a Host pattern (other than `*`) matches the instance id, an alias or the IP.
@@ -75,76 +90,82 @@ def connect(
     4. The EC2 key pair (or `target.key_file`), when a matching file is found in ~/.ssh.
     5. The ssh-agent and default ~/.ssh/id_* keys.
 
+    `on_progress` gets a snapshot of all attempts whenever one changes state.
     Unknown host keys are trusted, unless `confirm_host_key` declines them.
     """
-    failures: list[str] = []
     open_ssh_ = partial(open_ssh, confirm_host_key=confirm_host_key)
-
-    def attempt(via: str, failure: str, open_client: Callable[[], paramiko.SSHClient]) -> Connection | None:
-        logger.info(f"Connecting via {via}")
-        try:
-            return Connection(open_client(), via)
-        except Exception as e:
-            logger.debug(f"{failure}: {e!r}")
-            failures.append(f"{failure}\n    {e or type(e).__name__}")
-            return None
+    attempts: list[Attempt] = []
 
     config = find_ssh_config(target)
     if config is not None:
         alias, options = config
-        if connection := attempt(
-            f"ssh config ({alias})",
-            f":x: Failed with ssh config - ssh {alias}",
-            lambda: open_with_config(alias, options, target, confirm_host_key),
-        ):
-            return connection
+        attempts.append(
+            Attempt(
+                f"ssh config ({alias})",
+                shlex.join(['ssh', alias]),
+                lambda: open_with_config(alias, options, target, confirm_host_key),
+            ),
+        )
 
     ec2_key = target.key_file or find_ssh_key_file(target.key_name)
     known_keys = [k for k in (valid_opkssh_key_file(target.opkssh_provider), ec2_key) if k]
-
-    if not env.ssm_installed:
-        failures.append(":x: AWS session-manager-plugin not installed")
-    elif connection := attempt(
+    ssm_proxy = ssm_command(target.instance_id, env)
+    ssm = Attempt(
         "AWS SSM",
-        ":x: Failed to start session with AWS session-manager",
+        ssh_command(target.user, target.instance_id, known_keys, proxy=ssm_proxy),
         lambda: open_ssh_(
             target.instance_id,
             target.user,
             known_keys,
             use_defaults=True,
-            sock=proxy_socket(ssm_command(target.instance_id, env), on_output),
+            sock=proxy_socket(ssm_proxy, on_output),
         ),
-    ):
-        return connection
-
-    if target.opkssh_provider is not None:
-        provider = target.opkssh_provider
-        if not env.opkssh_installed:
-            failures.append(":x: Failed to authenticate with opkssh\n    opkssh not installed")
-        elif connection := attempt(
+    )
+    attempts.append(ssm if env.ssm_installed else replace(ssm, state='skipped', detail="session-manager-plugin not installed"))
+
+    if (provider := target.opkssh_provider) is not None:
+        opkssh_key = str(opkssh_key_path(provider))
+        opkssh = Attempt(
             "opkssh",
-            ":x: Failed to authenticate with opkssh",
+            f"{shlex.join(opkssh_login_command(provider, opkssh_key))} && "
+            + ssh_command(target.user, target.ip, [opkssh_key], identities_only=True),
             lambda: open_ssh_(target.ip, target.user, [opkssh_login(provider, on_output, on_waiting)], use_defaults=False),
-        ):
-            return connection
-
-    if ec2_key is not None and (
-        connection := attempt(
-            Path(ec2_key).stem,
-            f":x: Key found, but failed - ssh -o IdentitiesOnly=yes -i {ec2_key} {target.user}@{target.ip}",
-            lambda: open_ssh_(target.ip, target.user, [ec2_key], use_defaults=False),
         )
-    ):
-        return connection
+        attempts.append(opkssh if env.opkssh_installed else replace(opkssh, state='skipped', detail="opkssh not installed"))
+
+    if ec2_key is not None:
+        attempts.append(
+            Attempt(
+                Path(ec2_key).stem,
+                ssh_command(target.user, target.ip, [ec2_key], identities_only=True),
+                lambda: open_ssh_(target.ip, target.user, [ec2_key], use_defaults=False),
+            ),
+        )
 
-    if connection := attempt(
-        "default key",
-        f":x: Failed with default key - ssh {target.user}@{target.ip}",
-        lambda: open_ssh_(target.ip, target.user, [], use_defaults=True),
-    ):
-        return connection
+    attempts.append(
+        Attempt(
+            "default key",
+            ssh_command(target.user, target.ip),
+            lambda: open_ssh_(target.ip, target.user, [], use_defaults=True),
+        ),
+    )
 
-    return failures
+    for i, attempt in enumerate(attempts):
+        if attempt.state == 'skipped':
+            continue
+        attempts[i] = replace(attempt, state='connecting')
+        on_progress(list(attempts))
+        try:
+            client = attempt.open_client()
+        except Exception as e:
+            logger.debug(f"Failed to connect via {attempt.via}: {e!r}")
+            attempts[i] = replace(attempt, state='failed', detail=str(e) or type(e).__name__)
+            on_progress(list(attempts))
+            continue
+        attempts[i] = replace(attempt, state='connected')
+        on_progress(list(attempts))
+        return Connection(client, attempt.via)
+    return None
 
 
 def open_ssh(
@@ -186,6 +207,25 @@ def open_ssh(
     return client
 
 
+def ssh_command(
+    user: str,
+    host: str,
+    key_files: Sequence[str] = (),
+    *,
+    identities_only: bool = False,
+    proxy: list[str] | None = None,
+) -> str:
+    """The OpenSSH command line equivalent of an `open_ssh` call."""
+    cmd = ['ssh']
+    if proxy:
+        cmd += ['-o', f'ProxyCommand={shlex.join(proxy)}']
+    if identities_only:
+        cmd += ['-o', 'IdentitiesOnly=yes']
+    for key_file in key_files:
+        cmd += ['-i', key_file]
+    return shlex.join([*cmd, f'{user}@{host}'])
+
+
 def open_shell_channel(client: paramiko.SSHClient) -> paramiko.Channel:
     channel = client.get_transport().open_session()  # pyright: ignore[reportOptionalMemberAccess]
     channel.get_pty(term='xterm-256color')
@@ -357,6 +397,10 @@ def valid_opkssh_key_file(provider: str | None) -> str | None:
     return str(key) if key.is_file() and key.stat().st_mtime > time.time() - OPKSSH_KEY_MAX_AGE else None
 
 
+def opkssh_login_command(provider: str, key_file: str) -> list[str]:
+    return ['opkssh', 'login', '--provider', provider, '-i', key_file]
+
+
 def opkssh_login(provider: str, on_output: OnOutput, on_waiting: Callable[[], None]) -> str:
     """Return a valid opkssh key file, logging in when missing or expired."""
     if key_file := valid_opkssh_key_file(provider):
@@ -368,7 +412,7 @@ def opkssh_login(provider: str, on_output: OnOutput, on_waiting: Callable[[], No
         path.unlink(missing_ok=True)
 
     proc = subprocess.Popen(  # noqa: S603
-        ['opkssh', 'login', '--provider', provider, '-i', str(key)],  # noqa: S607
+        opkssh_login_command(provider, str(key)),
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         text=True,

{aws_ssh_utils-0.2.5 → aws_ssh_utils-0.2.7}/aws_ssh_utils/ssh.py

@@ -53,8 +53,12 @@ def cli(
     )
     level = "DEBUG" if verbose else 100 if quiet else "INFO"
 
+    def to_stdout(message: str):
+        # Look up sys.stdout per message, so rich.live can redirect it above its display.
+        sys.stdout.write(message)
+
     logger.remove()
-    logger.add(sys.stdout, level=level, format=log_format, colorize=True)
+    logger.add(to_stdout, level=level, format=log_format, colorize=True)
 
 
 for command in (app, ec2, emr, emr_all, healthcheck):

{aws_ssh_utils-0.2.5 → aws_ssh_utils-0.2.7}/pyproject.toml

@@ -60,6 +60,7 @@ Homepage = "https://github.com/mvanderlee/aws-ssh-utils"
 
 [project.scripts]
 aws_ssh = "aws_ssh_utils.ssh:cli"
+aws-ssh-utils = "aws_ssh_utils.ssh:cli"
 
 [tool.hatch.build]
 include = [

aws_ssh_utils-0.2.5/aws_ssh_utils/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.5"