nate2-scripts 1.0.0__py3-none-any.whl

nate2_scripts/__init__.py

@@ -0,0 +1,4 @@
+import sys
+
+if sys.platform != "darwin":
+    raise RuntimeError("nate2-scripts only supports macOS")

nate2_scripts/bing_wrapper.py

@@ -0,0 +1,170 @@
+"""PTY wrapper for cdk that plays a sound when (y/n) prompts appear."""
+
+import fcntl
+import os
+import select
+import signal
+import struct
+import subprocess
+import sys
+import termios
+import tty
+import argparse
+
+# _PATTERN = b"(y/n)"
+# _WINDOW = len(_PATTERN) * 2
+
+
+def _get_winsize(fd: int) -> bytes:
+    return fcntl.ioctl(fd, termios.TIOCGWINSZ, b"\x00" * 8)
+
+
+def _set_winsize(fd: int, winsize: bytes) -> None:
+    fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
+
+
+def run(args: argparse.Namespace) -> None:
+    patterns = [p.encode() for p in args.patterns] if args.patterns else []
+    window = max(map(len, patterns)) * 2 if patterns else 1
+    # Capture real terminal dimensions before creating the PTY.
+    # pty.spawn() leaves the PTY at {0,0,0,0}, which makes CDK format
+    # output to width 1. Using os.openpty() lets us set the size before
+    # forking so cdk reads correct dimensions from its very first TIOCGWINSZ.
+    try:
+        winsize = _get_winsize(sys.stdout.fileno())
+    except OSError:
+        winsize = struct.pack("HHHH", 24, 80, 0, 0)
+
+    master_fd, slave_fd = os.openpty()
+    _set_winsize(master_fd, winsize)
+
+    pid = os.fork()
+    if pid == 0:
+        # ---- child ----
+        os.close(master_fd)
+        os.setsid()
+        # Acquire slave as the controlling terminal.
+        fcntl.ioctl(slave_fd, termios.TIOCSCTTY, 0)
+        for fd in (0, 1, 2):
+            os.dup2(slave_fd, fd)
+        if slave_fd > 2:
+            os.close(slave_fd)
+        os.execvp(args.command[0], args.command)
+        os._exit(1)
+
+    # ---- parent ----
+    os.close(slave_fd)
+
+    # Propagate terminal resizes to the child (also sends SIGWINCH to it).
+    def _sigwinch(signum: int, frame) -> None:
+        try:
+            _set_winsize(master_fd, _get_winsize(sys.stdout.fileno()))
+        except OSError:
+            pass
+
+    signal.signal(signal.SIGWINCH, _sigwinch)
+
+    stdin_fd = sys.stdin.fileno()
+    old_settings = None
+    try:
+        old_settings = termios.tcgetattr(stdin_fd)
+        tty.setraw(stdin_fd)
+    except termios.error:
+        pass
+
+    buf = b""
+    try:
+        while True:
+            try:
+                r, _, _ = select.select([master_fd, stdin_fd], [], [])
+            except (OSError, ValueError):
+                break
+
+            if master_fd in r:
+                try:
+                    data = os.read(master_fd, 1024)
+                except OSError:
+                    break
+                if not data:
+                    break
+
+                check = buf + data
+                for pattern in patterns:
+                    if pattern in check:
+                        subprocess.Popen(["afplay", args.sound_pattern])
+                        buf = b""
+                        break
+
+                buf = check[-window:]
+
+                sys.stdout.buffer.write(data)
+                sys.stdout.buffer.flush()
+
+            if stdin_fd in r:
+                try:
+                    data = os.read(stdin_fd, 1024)
+                except OSError:
+                    break
+                if data:
+                    try:
+                        os.write(master_fd, data)
+                    except OSError:
+                        break
+    finally:
+        if old_settings is not None:
+            try:
+                termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_settings)
+            except termios.error:
+                pass
+
+    _, status = os.waitpid(pid, 0)
+
+    if args.end:
+        subprocess.Popen(["afplay", args.sound_end])
+    if os.WIFEXITED(status):
+        sys.exit(os.WEXITSTATUS(status))
+    elif os.WIFSIGNALED(status):
+        sys.exit(128 + os.WTERMSIG(status))
+    else:
+        sys.exit(1)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="PTY wrapper for cdk that plays a sound when (y/n) prompts appear."
+    )
+    parser.add_argument("command", nargs="*", help="Command to run")
+    parser.add_argument(
+        "--end", help="make sound at end of command", action="store_true"
+    )
+    parser.add_argument(
+        "--pattern",
+        help="make sound when pattern in seen",
+        type=str,
+        action="append",
+        dest="patterns",
+    )
+    parser.add_argument(
+        "--sound-end",
+        help="change the sound at end of command",
+        type=str,
+        default="/System/Library/Sounds/Glass.aiff",
+    )
+    parser.add_argument(
+        "--sound-pattern",
+        help="change the sound when pattern is seen",
+        type=str,
+        default="/System/Library/Sounds/Glass.aiff",
+    )
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    run(args)
+
+
+if __name__ == "__main__":
+    main()

nate2_scripts/console/__init__.py

@@ -0,0 +1,174 @@
+# PYTHON_ARGCOMPLETE_OK
+
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+import urllib.parse
+import webbrowser
+import argparse
+from dataclasses import dataclass
+from pathlib import Path
+
+import argcomplete
+import boto3
+
+from nate2_scripts.console.destitationResolver import DestinationResolver
+
+from nate2_scripts.console.hashGrabber import HashGrabber
+from nate2_scripts.console.regionCache import RegionCache
+from nate2_scripts.console.sessionCache import SessionCache
+
+
+def get_account_id() -> str:
+    return boto3.client("sts").get_caller_identity()["Account"]
+
+
+def get_credentials() -> dict:
+    result = subprocess.run(
+        ["aws", "configure", "export-credentials"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        print(f"Error: Failed to export credentials.\n{result.stderr}", file=sys.stderr)
+        sys.exit(1)
+    return json.loads(result.stdout)
+
+
+def get_signin_token(creds: dict) -> str:
+    session = json.dumps(
+        {
+            "sessionId": creds["AccessKeyId"],
+            "sessionKey": creds["SecretAccessKey"],
+            "sessionToken": creds["SessionToken"],
+        }
+    )
+    sess = urllib.parse.quote(session)
+    token_url = (
+        f"https://signin.aws.amazon.com/federation?Action=getSigninToken&Session={sess}"
+    )
+    result = subprocess.run(
+        ["curl", "-s", token_url], capture_output=True, text=True, check=True
+    )
+    try:
+        return json.loads(result.stdout)["SigninToken"]
+    except json.JSONDecodeError:
+        print("Error: Failed to parse JSON response. You may not have credentials.")
+        sys.exit(1)
+
+
+def build_console_url(destination: str, signin_token: str) -> str:
+    dest = urllib.parse.quote(destination, safe="")
+    return f"https://signin.aws.amazon.com/federation?Action=login&Issuer=&Destination={dest}&SigninToken={signin_token}"
+
+
+def get_profile() -> str:
+    profile_name = os.environ.get("AWS_PROFILE", "")
+    if not profile_name:
+        print(
+            "Error: AWS_PROFILE environment variable is not set. run asp.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    return profile_name
+
+
+def parse_args(region_cache: RegionCache) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Open AWS console for a specific service."
+    )
+    svc_arg = parser.add_argument(
+        "service",
+        type=str,
+        default="",
+        nargs="?",
+        help="The AWS service to open in the console, or an AWS ARN.",
+    )
+    setattr(
+        svc_arg,
+        "completer",
+        argcomplete.completers.ChoicesCompleter(
+            list(DestinationResolver.get_service_list())
+        ),
+    )
+    parser.add_argument(
+        "-r",
+        "--region",
+        type=str,
+        default="",
+        choices=region_cache.get_regions(),
+        help="The AWS region to use.",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        help="Force new federations. This will reset the federations cache.",
+    )
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args()
+
+    return args
+
+
+def main() -> None:
+    profile_name = get_profile()
+    region_cache = RegionCache()
+    session_cache = SessionCache()
+
+    print("Loading regions from cache:", region_cache.get_regions())
+    print("Loading default region from cache:", region_cache.get_default_region())
+
+    args = parse_args(region_cache)
+
+    if args.force:
+        print("Force passed. Reseting session cache.")
+        session_cache.reset()
+
+    if args.region:
+        print("Default region is now:", args.region)
+
+    creds = get_credentials()
+    account_id = get_account_id()
+    hash = session_cache.get_session_hash(profile_name, creds)
+
+    multisession_domain_name = ""
+    signin_token = None
+    if hash is None:
+        print(f"{profile_name} has no cached session. Grabbing signin token.")
+        signin_token = get_signin_token(creds)
+    elif len(hash) == 0:
+        print(f"{profile_name} cache is single session")
+    else:
+        multisession_domain_name = f"{account_id}-{hash}."
+        print(
+            f"{profile_name} cache is multi session with domain: {multisession_domain_name}"
+        )
+
+    resolver = DestinationResolver(account_id, region_cache, multisession_domain_name)
+
+    destination = resolver.parse_destination(args.service, args.region)
+
+    print("parsed destination:", destination)
+
+    if signin_token is not None:
+        print("Building signin url")
+        console_url = build_console_url(destination, signin_token)
+        webbrowser.open(console_url)
+        start_time = time.time()
+        print(
+            "Waiting for up to 10 seconds to allow the browser to open before exiting..."
+        )
+        hash = HashGrabber.get_hash(account_id, start_time)
+        print(f"Hash found: {hash}")
+        session_cache.record_valid_hash(profile_name, hash)
+    else:
+        print("Opening url")
+        webbrowser.open(destination)
+
+
+if __name__ == "__main__":
+    main()