awsuser 0.1.0__py3-none-any.whl

awsuser/__init__.py

@@ -0,0 +1,3 @@
+"""awsuser — Python CLI for AWS IAM user authentication with MFA."""
+
+__version__ = "0.1.0"

awsuser/mfa_login.py

@@ -0,0 +1,513 @@
+"""awsuser — Authenticate as an AWS IAM user with password + MFA via Console sign-in."""
+
+import argparse
+import configparser
+import json
+import os
+import platform
+import re
+import stat
+import sys
+from pathlib import Path
+
+from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeout
+
+from awsuser.utils import LOG, add_common_arguments, setup_session
+
+KEYRING_SERVICE = "awsuser"
+DEFAULT_REGION = "us-east-1"
+def _default_browser() -> str:
+    """Return the default browser path based on the OS."""
+    system = platform.system()
+    if system == "Darwin":
+        return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+    if system == "Windows":
+        username = os.environ.get("USERNAME", os.environ.get("USER", ""))
+        return f"C:\\Users\\{username}\\AppData\\Local\\Google\\Chrome\\Application\\chrome.exe"
+    return "chromium"
+
+
+DEFAULT_BROWSER = _default_browser()
+
+_ACCOUNT_PATTERN = re.compile(r"^\d{12}$")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Construct the argument parser."""
+    parser = argparse.ArgumentParser(
+        description="Authenticate as an AWS IAM user with password + MFA.",
+    )
+    add_common_arguments(parser)  # --aws-profile, --region, -v
+
+    parser.add_argument(
+        "--account",
+        "-a",
+        required=True,
+        help="AWS account ID (12 digits).",
+    )
+    parser.add_argument(
+        "--user",
+        "-u",
+        required=True,
+        help="IAM username.",
+    )
+    parser.add_argument(
+        "--profile",
+        "-p",
+        default="default",
+        help="Profile name to write credentials to (default: 'default').",
+    )
+    parser.add_argument(
+        "--output",
+        choices=["credentials-file", "env"],
+        default="credentials-file",
+        help="Output format: write to credentials file or print env exports.",
+    )
+    parser.add_argument(
+        "--save",
+        action="store_true",
+        default=False,
+        help="Save the password to the system keyring.",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        default=False,
+        help="Enable debug logging output.",
+    )
+    parser.add_argument(
+        "--browser",
+        default=DEFAULT_BROWSER,
+        help="Browser executable path or Playwright browser name (chromium, firefox, webkit). "
+             "On macOS defaults to Google Chrome.",
+    )
+
+    return parser
+
+
+# ---------------------------------------------------------------------------
+# Keyring helpers
+# ---------------------------------------------------------------------------
+
+
+def _get_keyring_password(account: str, user: str) -> str | None:
+    """Retrieve IAM user password from system keyring.
+
+    Key format: {account}/{user}
+    """
+    key = f"{account}/{user}"
+    try:
+        import keyring
+        password = keyring.get_password(KEYRING_SERVICE, key)
+        if password:
+            LOG.info("Retrieved password from keyring for %s", key)
+        return password
+    except ImportError:
+        LOG.debug("keyring package not installed, skipping keyring lookup.")
+        return None
+    except Exception as exc:
+        LOG.debug("Failed to read from keyring: %s", exc)
+        return None
+
+
+def _save_keyring_password(account: str, user: str, password: str) -> None:
+    """Save IAM user password to system keyring."""
+    key = f"{account}/{user}"
+    try:
+        import keyring
+        keyring.set_password(KEYRING_SERVICE, key, password)
+        print(f"Password saved to keyring for {key}", file=sys.stderr)
+    except ImportError:
+        print(
+            "Error: keyring package is not installed. "
+            "Install it with: pip install keyring",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    except Exception as exc:
+        print(f"Error: Failed to save to keyring: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Password and TOTP input
+# ---------------------------------------------------------------------------
+
+
+def get_password(account: str, user: str) -> str:
+    """Get IAM user password from env var, keyring, or interactive prompt.
+
+    Resolution order:
+    1. USER_PASSWORD environment variable
+    2. System keyring (keyed by account/user)
+    3. Interactive prompt
+    """
+    # 1. Check USER_PASSWORD env var
+    password = os.environ.get("USER_PASSWORD")
+    if password is not None and password.strip():
+        LOG.info("Using password from USER_PASSWORD environment variable.")
+        return password.strip()
+
+    # 2. Check keyring
+    keyring_password = _get_keyring_password(account, user)
+    if keyring_password:
+        return keyring_password
+
+    # 3. Interactive prompt
+    try:
+        import getpass
+        password = getpass.getpass("Enter IAM user password: ")
+    except EOFError:
+        print("Error: no input received (EOF).", file=sys.stderr)
+        sys.exit(1)
+
+    if not password.strip():
+        print("Error: password cannot be empty.", file=sys.stderr)
+        sys.exit(1)
+
+    return password.strip()
+
+
+def prompt_for_token() -> str:
+    """Prompt for the 6-digit MFA TOTP code. Always interactive."""
+    try:
+        token_code = input("Enter MFA token code: ")
+    except EOFError:
+        print("Error: no input received (EOF).", file=sys.stderr)
+        sys.exit(1)
+
+    token_code = token_code.strip()
+
+    if not token_code.isdigit() or len(token_code) != 6:
+        print("MFA token must be exactly 6 digits.", file=sys.stderr)
+        sys.exit(1)
+
+    return token_code
+
+
+# ---------------------------------------------------------------------------
+# Console sign-in flow (Playwright headless browser)
+# ---------------------------------------------------------------------------
+
+
+def console_sign_in(account: str, username: str, password: str, mfa_code: str, region: str, browser_type: str = "chromium") -> dict:  # pragma: no cover
+    """Authenticate via the AWS Console using a headless browser and return temporary credentials.
+
+    Uses Playwright to automate the full sign-in flow including MFA.
+
+    Returns:
+        Dict with keys: access_key_id, secret_access_key, session_token, expiration
+    """
+    signin_url = f"https://{account}.signin.aws.amazon.com/console"
+
+    with sync_playwright() as p:
+        # Determine if browser_type is a path or a Playwright browser name
+        if browser_type in ("chromium", "firefox", "webkit"):
+            browser_launcher = getattr(p, browser_type)
+            browser = browser_launcher.launch(headless=True)
+        else:
+            # Treat as executable path — use chromium channel with custom path
+            browser = p.chromium.launch(headless=True, executable_path=browser_type)
+        context = browser.new_context()
+        page = context.new_page()
+
+        try:
+            # Navigate to the IAM user sign-in page
+            LOG.debug("Navigating to %s", signin_url)
+            page.goto(signin_url, timeout=60000)
+
+            # Fill username
+            LOG.debug("Filling username")
+            page.get_by_role("textbox", name="IAM username").fill(username)
+
+            # Fill password
+            LOG.debug("Filling password")
+            page.get_by_role("textbox", name="Password").fill(password)
+
+            # Click sign-in button
+            LOG.debug("Clicking sign-in")
+            page.get_by_test_id("sign-in").click()
+
+            # Wait for MFA input to appear
+            LOG.debug("Waiting for MFA prompt")
+            try:
+                page.get_by_role("textbox", name="MFA code").wait_for(timeout=15000)
+            except PlaywrightTimeout:
+                # Check if we're already in the console (no MFA) or there's an error
+                if "console.aws.amazon.com" in page.url:
+                    LOG.info("Sign-in successful (no MFA required)")
+                else:
+                    error_el = page.query_selector('[data-testid="error-message"], .error-message')
+                    error_text = error_el.inner_text() if error_el else "Unknown error (check credentials)"
+                    print(f"Error: Sign-in failed: {error_text}", file=sys.stderr)
+                    sys.exit(1)
+            else:
+                # Fill MFA code
+                LOG.debug("Filling MFA code")
+                page.get_by_role("textbox", name="MFA code").fill(mfa_code)
+
+                # Click MFA submit button
+                LOG.debug("Submitting MFA")
+                page.get_by_test_id("mfa-submit-button").click()
+
+            # Wait for console to load
+            LOG.debug("Waiting for console to load")
+            try:
+                page.wait_for_url("**/console/**", timeout=30000)
+                LOG.info("Console sign-in successful.")
+            except PlaywrightTimeout:
+                # Check for error
+                error_el = page.query_selector('[data-testid="error-message"], .error-message')
+                if error_el:
+                    print(f"Error: {error_el.inner_text()}", file=sys.stderr)
+                else:
+                    print(f"Error: Timed out waiting for console. URL: {page.url}", file=sys.stderr)
+                sys.exit(1)
+
+            # Determine the region from the current Console URL
+            console_region_match = re.search(
+                r"https://([^.]+)\.console\.aws\.amazon\.com", page.url
+            )
+            actual_region = console_region_match.group(1) if console_region_match else region
+            LOG.debug("Console region: %s", actual_region)
+
+            # Navigate to CloudShell via the Console search bar
+            LOG.debug("Opening CloudShell via search")
+            page.get_by_test_id("awsc-concierge-input").click()
+            page.get_by_test_id("awsc-concierge-input").fill("cloudshell")
+            page.get_by_test_id("services-search-result-link-scallop").click()
+
+            # Dismiss welcome dialog if it appears
+            try:
+                welcome_close = page.get_by_test_id("welcome-close")
+                welcome_close.wait_for(timeout=10000)
+                welcome_close.click()
+                LOG.debug("Dismissed CloudShell welcome dialog")
+            except PlaywrightTimeout:
+                LOG.debug("No welcome dialog appeared")
+
+            # Wait for the terminal input to be ready
+            LOG.debug("Waiting for CloudShell terminal input")
+            terminal_input = page.get_by_role("textbox", name="CloudShell terminal input")
+            terminal_input.wait_for(timeout=60000)
+            # Give the shell prompt time to appear
+            page.wait_for_timeout(3000)
+
+            # Click the terminal area to focus it
+            page.locator(".ace_content").click()
+            page.wait_for_timeout(500)
+
+            # Type the credential export command
+            LOG.debug("Typing credential export command")
+            terminal_input.fill("")
+            terminal_input.type("aws configure export-credentials | jq -c '.'", delay=20)
+            terminal_input.press("Enter")
+
+            # Wait for command to execute
+            LOG.debug("Waiting for command output")
+            page.wait_for_timeout(5000)
+
+            # Read terminal content
+            terminal_text = page.evaluate("""() => {
+                const ace = document.querySelector('.ace_content');
+                if (ace) return ace.innerText;
+                return '';
+            }""")
+
+            LOG.debug("Terminal text length: %d", len(terminal_text) if terminal_text else 0)
+            LOG.debug("Terminal text (last 1500): %s", terminal_text[-1500:] if terminal_text else "empty")
+
+            # Parse credentials from output
+            creds_data = None
+
+            if terminal_text:
+                # The output is JSON from `aws configure export-credentials`
+                # Find JSON by looking for the opening { before "AccessKeyId" or "Version"
+                # and the closing } after "Expiration"
+                # Try to find a complete JSON object
+                start_idx = terminal_text.find('{"')
+                if start_idx == -1:
+                    start_idx = terminal_text.find('{\n')
+                if start_idx >= 0:
+                    # Find the matching closing brace
+                    brace_count = 0
+                    end_idx = start_idx
+                    for i in range(start_idx, len(terminal_text)):
+                        if terminal_text[i] == '{':
+                            brace_count += 1
+                        elif terminal_text[i] == '}':
+                            brace_count -= 1
+                            if brace_count == 0:
+                                end_idx = i + 1
+                                break
+
+                    if end_idx > start_idx:
+                        json_str = terminal_text[start_idx:end_idx]
+                        # Strip terminal control characters
+                        json_str = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', json_str)
+                        try:
+                            parsed = json.loads(json_str)
+                            if "AccessKeyId" in parsed or "SessionToken" in parsed:
+                                creds_data = {
+                                    "access_key_id": parsed.get("AccessKeyId", ""),
+                                    "secret_access_key": parsed.get("SecretAccessKey", ""),
+                                    "session_token": parsed.get("SessionToken", parsed.get("Token", "")),
+                                    "expiration": parsed.get("Expiration", "unknown"),
+                                }
+                                LOG.info("Extracted credentials from CloudShell")
+                        except json.JSONDecodeError as e:
+                            LOG.debug("JSON parse failed: %s", e)
+
+                # Fallback: try export KEY=VALUE format
+                if not creds_data:
+                    ak_match = re.search(r'export AWS_ACCESS_KEY_ID=(\S+)', terminal_text)
+                    sk_match = re.search(r'export AWS_SECRET_ACCESS_KEY=(\S+)', terminal_text)
+                    st_match = re.search(r'export AWS_SESSION_TOKEN=(\S+)', terminal_text)
+                    if ak_match and sk_match and st_match:
+                        creds_data = {
+                            "access_key_id": ak_match.group(1),
+                            "secret_access_key": sk_match.group(1),
+                            "session_token": st_match.group(1),
+                            "expiration": "unknown",
+                        }
+                        LOG.info("Extracted credentials from export format")
+
+            if not creds_data:
+                print("Error: Could not extract credentials from CloudShell.", file=sys.stderr)
+                print("Try running 'aws configure export-credentials' manually in CloudShell.", file=sys.stderr)
+                sys.exit(1)
+
+            return creds_data
+
+        finally:
+            browser.close()
+
+
+# ---------------------------------------------------------------------------
+# Credential output
+# ---------------------------------------------------------------------------
+
+
+def format_env_export(credentials: dict) -> str:
+    """Format credentials as shell export statements."""
+
+    def _escape(value: str) -> str:
+        return value.replace("'", "'\\''")
+
+    lines = [
+        f"export AWS_ACCESS_KEY_ID='{_escape(credentials['access_key_id'])}'",
+        f"export AWS_SECRET_ACCESS_KEY='{_escape(credentials['secret_access_key'])}'",
+        f"export AWS_SESSION_TOKEN='{_escape(credentials['session_token'])}'",
+    ]
+    return "\n".join(lines)
+
+
+def write_credentials_to_file(
+    credentials: dict, profile_name: str, credentials_path: Path | None = None
+) -> None:
+    """Write temporary credentials to the AWS credentials file."""
+    if credentials_path is None:
+        credentials_path = Path.home() / ".aws" / "credentials"
+
+    LOG.debug("Credentials path: %s", credentials_path)
+
+    # Ensure ~/.aws/ directory exists with mode 700
+    aws_dir = credentials_path.parent
+    try:
+        if not aws_dir.exists():
+            aws_dir.mkdir(mode=0o700, parents=True)
+            LOG.debug("Created directory: %s (mode 700)", aws_dir)
+    except OSError as exc:
+        print(f"Error: Unable to create directory '{aws_dir}': {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    # Check existing file permissions
+    if credentials_path.exists():
+        try:
+            file_stat = os.stat(credentials_path)
+            file_mode = stat.S_IMODE(file_stat.st_mode)
+            if file_mode & 0o177:
+                print(
+                    f"Warning: '{credentials_path}' has permissions "
+                    f"{oct(file_mode)} which are more permissive than 600. "
+                    f"Consider running: chmod 600 {credentials_path}",
+                    file=sys.stderr,
+                )
+        except OSError as exc:
+            LOG.debug("Could not check file permissions: %s", exc)
+
+    # Read existing credentials file
+    config = configparser.ConfigParser()
+    try:
+        config.read(str(credentials_path))
+    except (configparser.Error, OSError) as exc:
+        LOG.debug("Could not read existing credentials file: %s", exc)
+        config = configparser.ConfigParser()
+
+    # Create or update the target profile section
+    if not config.has_section(profile_name):
+        config.add_section(profile_name)
+
+    config.set(profile_name, "aws_access_key_id", credentials["access_key_id"])
+    config.set(profile_name, "aws_secret_access_key", credentials["secret_access_key"])
+    config.set(profile_name, "aws_session_token", credentials["session_token"])
+
+    # Write the credentials file
+    try:
+        with open(credentials_path, "w", encoding="utf-8") as f:
+            config.write(f)
+    except OSError as exc:
+        print(f"Error: Unable to write credentials file '{credentials_path}': {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    # Display confirmation
+    expiration = credentials["expiration"]
+    if hasattr(expiration, "isoformat"):
+        expiration_str = expiration.isoformat()
+    else:
+        expiration_str = str(expiration)
+
+    print(f"Credentials written to profile [{profile_name}]. Expires: {expiration_str}", file=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+
+def _main() -> None:
+    """Entry point registered as console script 'awsuser'."""
+    parser = build_parser()
+    args = parser.parse_args()
+
+    # Setup logging
+    if args.debug:
+        args.verbose = 3
+    setup_session(args)
+
+    # Validate account ID
+    if not _ACCOUNT_PATTERN.match(args.account):
+        print(f"Error: Invalid account ID '{args.account}'. Must be exactly 12 digits.", file=sys.stderr)
+        sys.exit(1)
+
+    region = args.region or DEFAULT_REGION
+
+    # Get password (env var, keyring, or prompt)
+    password = get_password(args.account, args.user)
+
+    # Save password to keyring if --save was specified
+    if args.save:
+        _save_keyring_password(args.account, args.user, password)
+
+    # Always prompt for TOTP code (rotates every 30s, never stored)
+    token_code = prompt_for_token()
+
+    # Authenticate via Console sign-in flow
+    LOG.info("Authenticating as %s in account %s...", args.user, args.account)
+    credentials = console_sign_in(args.account, args.user, password, token_code, region, args.browser)
+
+    # Output credentials
+    if args.output == "env":
+        print(format_env_export(credentials))
+    else:
+        write_credentials_to_file(credentials, args.profile)

awsuser/utils.py

@@ -0,0 +1,49 @@
+"""Shared utilities for awsuser commands."""
+
+import argparse
+import logging
+
+LOG = logging.getLogger("awsuser")
+
+# Disk cache directory — credentials must NOT be stored here
+CACHE_DIR = "~/.awsuser"
+
+# Simple dict-based cache for non-sensitive values
+CACHE: dict = {}
+
+
+def set_level(verbosity: int) -> None:
+    """Set logging level based on verbosity count."""
+    if verbosity >= 3:
+        logging.basicConfig(level=logging.DEBUG)
+    elif verbosity >= 2:
+        logging.basicConfig(level=logging.DEBUG)
+    elif verbosity >= 1:
+        logging.basicConfig(level=logging.INFO)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    # Suppress noisy keyring backend discovery logs
+    logging.getLogger("keyring.backend").setLevel(logging.WARNING)
+
+
+def add_common_arguments(parser: argparse.ArgumentParser) -> None:
+    """Add standard --region, -v flags to a parser."""
+    parser.add_argument(
+        "--region",
+        default=None,
+        help="AWS region (default: us-east-1).",
+    )
+    parser.add_argument(
+        "-v",
+        action="count",
+        default=0,
+        dest="verbose",
+        help="Increase verbosity (repeatable: -v, -vv, -vvv).",
+    )
+
+
+def setup_session(args: argparse.Namespace) -> None:
+    """Configure logging from CLI arguments."""
+    set_level(getattr(args, "verbose", 0))
+    LOG.debug("Logging configured, verbosity=%s", getattr(args, "verbose", 0))

awsuser-0.1.0.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: awsuser
+Version: 0.1.0
+Summary: CLI tool to authenticate AWS IAM users with password + MFA via Console sign-in (no access keys needed)
+Project-URL: Homepage, https://github.com/tmb28054/awsuser
+Project-URL: Repository, https://github.com/tmb28054/awsuser
+Project-URL: Issues, https://github.com/tmb28054/awsuser/issues
+Project-URL: Changelog, https://github.com/tmb28054/awsuser/blob/main/CHANGELOG.md
+Author: Topaz Bott
+License-Expression: MIT
+License-File: LICENSE
+Keywords: auth,aws,cli,user
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Systems Administration
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: keyring>=23.0
+Requires-Dist: playwright>=1.40
+Provides-Extra: dev
+Requires-Dist: bandit>=1.7; extra == 'dev'
+Requires-Dist: pylint>=3.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=4.0; extra == 'test'
+Requires-Dist: pytest>=7.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# awsuser
+
+Python CLI for AWS IAM user authentication with password + MFA. Automates the AWS Console sign-in flow using a headless browser to obtain temporary credentials — no pre-existing access keys needed.
+
+## Installation
+
+```bash
+pip install awsuser
+playwright install chromium
+```
+
+Or from source:
+
+```bash
+pip install -e ".[test]"
+playwright install chromium
+```
+
+> **Note:** On macOS and Windows, `awsuser` uses your installed Google Chrome by default. You only need `playwright install chromium` if Chrome isn't installed or you want to use the bundled Chromium.
+
+## Usage
+
+```bash
+# Basic usage (prompts for password and MFA code)
+awsuser -a 123456789012 -u alice
+
+# Save password to system keyring for next time
+awsuser -a 123456789012 -u alice --save
+
+# Output as environment variables
+source <(awsuser -a 123456789012 -u alice --output env)
+
+# Custom profile name
+awsuser -a 123456789012 -u alice -p myprofile
+
+# With specific region
+awsuser -a 123456789012 -u alice --region us-west-2
+
+# Use a specific browser
+awsuser -a 123456789012 -u alice --browser firefox
+
+# Debug mode (verbose logging)
+awsuser -a 123456789012 -u alice --debug
+```
+
+## How It Works
+
+1. Prompts for your IAM user password (or reads from keyring/`USER_PASSWORD` env var)
+2. Prompts for your 6-digit MFA TOTP code
+3. Opens a headless browser (Google Chrome on macOS/Windows, Chromium on Linux)
+4. Automates the AWS Console sign-in flow (account + username + password + MFA)
+5. Opens CloudShell and runs `aws configure export-credentials`
+6. Extracts temporary credentials and writes them to `~/.aws/credentials`
+
+## Running Tests
+
+```bash
+./run_tests.sh
+```
+
+Or manually:
+
+```bash
+python3 -m pytest tests/ --cov=awsuser --cov-report=term-missing --cov-fail-under=80 -v
+```
+
+## Documentation
+
+- [User Guide](docs/user-guide.md)
+- [FAQ](docs/faq.md)
+
+## License
+
+MIT
+
+## Disclaimer
+
+This tool automates the AWS Console sign-in flow using browser automation. It relies on the Console's UI structure which AWS may change without notice. If the tool stops working after an AWS Console update, please open an issue.

awsuser-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+awsuser/__init__.py,sha256=lAXuJP5v302eJEbSW2EBpX8ipxpcBWy4I5Bd9n2yMPU,94
+awsuser/mfa_login.py,sha256=kb4QYBFfxEMkKP1L7g-0ctjNUuYrcc8bDp2m_Ap8wh0,19657
+awsuser/utils.py,sha256=VhM8Z9BkDNR9RIFZevcpzj7-hQ8mvBjK2HxCdUXvmLA,1413
+awsuser-0.1.0.dist-info/METADATA,sha256=NbvjcBAlVabsZsPSQxPCIDLxGeIqJa08hrIP5X7aLVM,3779
+awsuser-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+awsuser-0.1.0.dist-info/entry_points.txt,sha256=ZcCMfmZKG8AVedlxXIIYoEvY0QFSJnDV4uePrwR15-g,52
+awsuser-0.1.0.dist-info/licenses/LICENSE,sha256=7yxHIYjGY_yLY2SAqQQui8YVj6rF73PTvGL2Xref8jY,1077
+awsuser-0.1.0.dist-info/RECORD,,

awsuser-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

awsuser-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+awsuser = awsuser.mfa_login:_main

awsuser-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 awsuser contributors
+
+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.