tmail-cli 0.1.0__py3-none-any.whl

tmail/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

tmail/api.py

@@ -0,0 +1,36 @@
+import requests
+
+MAIL_ENDPOINT = "https://api.internal.temp-mail.io/api/v3/email/new"
+INBOX_ENDPOINT = "https://api.internal.temp-mail.io/api/v3/email/{email}/messages"
+ATTACHMENT_ENDPOINT = "https://api.internal.temp-mail.io/api/v3/attachment/{id}?download=1"
+
+
+def get_random_email():
+    """Generates a new random email address."""
+    json_data = {"min_name_length": 10, "max_name_length": 10}
+    response = requests.post(MAIL_ENDPOINT, json=json_data)
+    response.raise_for_status()
+    return response.json()["email"]
+
+
+def fetch_messages(email):
+    """Fetches messages for a given email address."""
+    url = INBOX_ENDPOINT.format(email=email)
+    response = requests.get(url)
+    response.raise_for_status()
+    return response.json()
+
+
+def get_attachment_url(att_id):
+    """Returns the download URL for an attachment."""
+    return ATTACHMENT_ENDPOINT.format(id=att_id)
+
+
+def download_attachment(att_id, save_path):
+    """Downloads an attachment to the given file path."""
+    url = ATTACHMENT_ENDPOINT.format(id=att_id)
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+    with open(save_path, "wb") as f:
+        for chunk in response.iter_content(chunk_size=8192):
+            f.write(chunk)

tmail/cli.py

@@ -0,0 +1,546 @@
+import sys
+import time
+import json
+from pathlib import Path
+
+import requests
+from rich.live import Live
+from rich.prompt import Prompt
+
+from .api import get_random_email, fetch_messages, get_attachment_url, download_attachment
+from .storage import (
+    save_email,
+    get_old_emails,
+    delete_email,
+    load_seen_mail_ids,
+    save_seen_mail_ids,
+    save_unread_count,
+    get_unread_counts,
+    clear_unread_count,
+    remove_unread_entry,
+    load_config,
+    save_config,
+    remove_all_data,
+    ATTACHMENTS_DIR,
+)
+from .ui import (
+    show_logo,
+    get_main_menu_panel,
+    get_email_actions_panel,
+    get_settings_panel,
+    show_emails_with_unread,
+    show_inbox_header,
+    build_inbox_table,
+    show_full_message,
+    show_messages_selection,
+    ask_choice,
+    wait_for_enter,
+    show_error,
+    show_success,
+    show_info,
+    console,
+)
+
+
+# ── helpers for non-interactive (CLI flag) use ──────────────────────
+
+def _print_messages_plain(messages):
+    """Print messages as plain text (for --inbox / --watch)."""
+    if not messages:
+        print("No messages.")
+        return
+    for i, msg in enumerate(messages, 1):
+        print(f"--- Message {i} ---")
+        print(f"From:    {msg['from']}")
+        print(f"To:      {msg['to']}")
+        print(f"Subject: {msg['subject']}")
+        print(f"Body:    {msg['body_text']}")
+        if msg.get("attachments"):
+            names = ", ".join(a["name"] for a in msg["attachments"])
+            print(f"Attachments: {names}")
+        print()
+
+
+def _copy_silent(text):
+    """Copy to clipboard without UI messages (for --generate)."""
+    import subprocess
+    import shutil
+    try:
+        import pyperclip
+        pyperclip.copy(text)
+        return True
+    except Exception:
+        pass
+    for name, cmd in [
+        ("xclip", ["xclip", "-selection", "clipboard"]),
+        ("xsel", ["xsel", "--clipboard", "--input"]),
+        ("wl-copy", ["wl-copy"]),
+    ]:
+        if shutil.which(name):
+            try:
+                proc = subprocess.run(cmd, input=text, text=True, capture_output=True, timeout=5)
+                if proc.returncode == 0:
+                    return True
+            except Exception:
+                continue
+    return False
+
+
+# ── Interactive TUI functions ───────────────────────────────────────
+
+def display_inbox(email, poll_interval):
+    """Displays the inbox for a given email address with live polling.
+
+    Returns the number of new messages received this session.
+    """
+    show_inbox_header(email)
+
+    seen_mail_ids = load_seen_mail_ids()
+    session_new_count = 0
+
+    with Live(console=console, screen=False, auto_refresh=False) as live:
+        while True:
+            try:
+                messages = fetch_messages(email)
+                table, has_new, batch_count = build_inbox_table(
+                    messages, seen_mail_ids, get_attachment_url
+                )
+
+                if has_new:
+                    session_new_count += batch_count
+                    live.update(table, refresh=True)
+                    save_seen_mail_ids(seen_mail_ids)
+
+                time.sleep(poll_interval)
+            except requests.RequestException as e:
+                show_error(f"Error fetching inbox: {e}")
+                time.sleep(poll_interval)
+            except KeyboardInterrupt:
+                break
+            except json.JSONDecodeError:
+                time.sleep(poll_interval)
+
+    return session_new_count
+
+
+def view_full_message(email):
+    """Fetch all messages and let the user pick one to read in full."""
+    try:
+        messages = fetch_messages(email)
+    except requests.RequestException as e:
+        show_error(f"Error fetching messages: {e}")
+        return
+
+    if not messages:
+        show_info("No messages found.")
+        return
+
+    show_messages_selection(messages)
+    choices = [str(i) for i in range(1, len(messages) + 1)]
+    choice = ask_choice(
+        "[bold]Enter message index to view[/bold]",
+        choices=choices,
+        show_choices=False,
+    )
+    msg = messages[int(choice) - 1]
+    show_full_message(msg)
+    wait_for_enter()
+
+
+def download_attachments(email):
+    """List messages with attachments and let the user download them."""
+    try:
+        messages = fetch_messages(email)
+    except requests.RequestException as e:
+        show_error(f"Error fetching messages: {e}")
+        return
+
+    with_attachments = [m for m in messages if m.get("attachments")]
+    if not with_attachments:
+        show_info("No messages with attachments found.")
+        return
+
+    show_messages_selection(with_attachments)
+    choices = [str(i) for i in range(1, len(with_attachments) + 1)]
+    choice = ask_choice(
+        "[bold]Enter message index to download attachments[/bold]",
+        choices=choices,
+        show_choices=False,
+    )
+    msg = with_attachments[int(choice) - 1]
+    atts = msg["attachments"]
+
+    save_dir = ATTACHMENTS_DIR / email
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    for att in atts:
+        dest = save_dir / att["name"]
+        try:
+            download_attachment(att["id"], dest)
+            show_success(f"Downloaded: {att['name']}")
+        except requests.RequestException as e:
+            show_error(f"Failed to download {att['name']}: {e}")
+
+    wait_for_enter()
+
+
+def copy_to_clipboard(text):
+    """Copy text to clipboard (interactive — shows UI messages)."""
+    import subprocess
+    import shutil
+
+    try:
+        import pyperclip
+        pyperclip.copy(text)
+        show_success(f"Copied to clipboard: {text}")
+        wait_for_enter()
+        return
+    except Exception:
+        pass
+
+    backends = [
+        ("xclip", ["xclip", "-selection", "clipboard"]),
+        ("xsel", ["xsel", "--clipboard", "--input"]),
+        ("wl-copy", ["wl-copy"]),
+    ]
+
+    for name, cmd in backends:
+        if shutil.which(name):
+            try:
+                proc = subprocess.run(cmd, input=text, text=True, capture_output=True, timeout=5)
+                if proc.returncode == 0:
+                    show_success(f"Copied to clipboard: {text}")
+                    wait_for_enter()
+                    return
+            except Exception:
+                continue
+
+    show_info(
+        "Clipboard copy requires a clipboard tool.\n"
+        "  X11: sudo apt install xclip   (or xsel)\n"
+        "  Wayland: sudo apt install wl-clipboard"
+    )
+    wait_for_enter()
+
+
+def email_actions_menu(email):
+    """Submenu for actions on a specific email after exiting inbox."""
+    config = load_config()
+    poll_interval = config["poll_interval"]
+
+    while True:
+        show_logo()
+        console.print(get_email_actions_panel(email))
+
+        choice = ask_choice(
+            "[bold]Choose an option[/bold]",
+            choices=["1", "2", "3", "4", "5", "6"],
+            default="1",
+        )
+
+        if choice == "1":
+            clear_unread_count(email)
+            session_count = display_inbox(email, poll_interval)
+            if session_count > 0:
+                save_unread_count(email, session_count)
+        elif choice == "2":
+            view_full_message(email)
+        elif choice == "3":
+            download_attachments(email)
+        elif choice == "4":
+            copy_to_clipboard(email)
+        elif choice == "5":
+            if delete_email(email):
+                remove_unread_entry(email)
+                show_success(f"Deleted email: {email}")
+                wait_for_enter()
+                return
+            show_error("Email not found in history.")
+            wait_for_enter()
+        elif choice == "6":
+            return
+
+
+def login_to_old_email():
+    """Allows the user to select an old email to log in to."""
+    old_emails = get_old_emails()
+    if not old_emails:
+        show_info("No old emails to log in to.")
+        return None
+
+    unread_counts = get_unread_counts()
+    show_emails_with_unread(old_emails, unread_counts)
+    choice = ask_choice(
+        "[bold]Enter the index of the email to restore[/bold]",
+        choices=[str(i) for i in range(1, len(old_emails) + 1)],
+        show_choices=False,
+    )
+    return old_emails[int(choice) - 1]
+
+
+def delete_email_saved():
+    """Main menu: delete a specific email from history."""
+    old_emails = get_old_emails()
+    if not old_emails:
+        show_info("No saved emails to delete.")
+        wait_for_enter()
+        return
+
+    unread_counts = get_unread_counts()
+    show_emails_with_unread(old_emails, unread_counts)
+    choice = ask_choice(
+        "[bold]Enter the index of the email to delete[/bold]",
+        choices=[str(i) for i in range(1, len(old_emails) + 1)],
+        show_choices=False,
+    )
+    email = old_emails[int(choice) - 1]
+
+    confirm = Prompt.ask(
+        f"Delete [bold]{email}[/bold]? (y/n)", choices=["y", "n"], default="n"
+    )
+    if confirm == "y":
+        if delete_email(email):
+            remove_unread_entry(email)
+            show_success(f"Deleted email: {email}")
+        else:
+            show_error("Email not found in history.")
+    wait_for_enter()
+
+
+def settings_menu():
+    """Settings menu for configuring poll interval."""
+    config = load_config()
+
+    while True:
+        show_logo()
+        console.print(get_settings_panel(config["poll_interval"]))
+
+        choice = ask_choice(
+            "[bold]Choose an option[/bold]",
+            choices=["1", "2"],
+            default="2",
+        )
+
+        if choice == "1":
+            interval = Prompt.ask(
+                "[bold]Poll interval in seconds[/bold]",
+                default=str(config["poll_interval"]),
+            )
+            try:
+                val = int(interval)
+                if val < 1:
+                    show_info("Minimum interval is 1 second.")
+                    continue
+                config["poll_interval"] = val
+                save_config(config)
+                show_success(f"Poll interval set to {val}s")
+                wait_for_enter()
+            except ValueError:
+                show_error("Invalid number.")
+                wait_for_enter()
+        elif choice == "2":
+            return
+
+
+def main_menu():
+    """Displays the main menu and handles user choices."""
+    config = load_config()
+    poll_interval = config["poll_interval"]
+
+    while True:
+        show_logo()
+        console.print(get_main_menu_panel())
+
+        choice = ask_choice(
+            "[bold]Choose an option[/bold]",
+            choices=["1", "2", "3", "4", "5", "6", "7"],
+            default="1",
+        )
+
+        if choice == "1":
+            try:
+                email = get_random_email()
+            except requests.RequestException as e:
+                show_error(f"Error generating email: {e}")
+                continue
+            save_email(email)
+            show_success(f"Your new email is: {email}")
+            session_count = display_inbox(email, poll_interval)
+            if session_count > 0:
+                save_unread_count(email, session_count)
+            email_actions_menu(email)
+        elif choice == "2":
+            emails = get_old_emails()
+            unread_counts = get_unread_counts()
+            show_emails_with_unread(emails, unread_counts)
+            wait_for_enter()
+        elif choice == "3":
+            email = login_to_old_email()
+            if email:
+                clear_unread_count(email)
+                session_count = display_inbox(email, poll_interval)
+                if session_count > 0:
+                    save_unread_count(email, session_count)
+                email_actions_menu(email)
+        elif choice == "4":
+            delete_email_saved()
+        elif choice == "5":
+            remove_all_data()
+            show_success("Successfully removed all old mails data.")
+            wait_for_enter()
+        elif choice == "6":
+            settings_menu()
+            config = load_config()
+            poll_interval = config["poll_interval"]
+        elif choice == "7":
+            console.print("[bold cyan]Thanks for using tmail! Goodbye![/bold cyan]")
+            sys.exit()
+
+
+# ── CLI flags + entry point ─────────────────────────────────────────
+
+def _watch_inbox(email):
+    """Live-poll inbox in plain text mode (used by --watch)."""
+    seen_ids = load_seen_mail_ids()
+    config = load_config()
+    interval = config["poll_interval"]
+    print(f"Watching {email} (poll every {interval}s, Ctrl+C to stop)...")
+    try:
+        while True:
+            try:
+                messages = fetch_messages(email)
+                new = []
+                for msg in messages:
+                    mid = str(msg["id"])
+                    if mid not in seen_ids:
+                        seen_ids.add(mid)
+                        new.append(msg)
+                if new:
+                    _print_messages_plain(new)
+                    save_seen_mail_ids(seen_ids)
+                time.sleep(interval)
+            except requests.RequestException as e:
+                print(f"Error: {e}", file=sys.stderr)
+                time.sleep(interval)
+    except KeyboardInterrupt:
+        pass
+
+
+def main():
+    import argparse
+
+    try:
+        from importlib.metadata import version as _v
+        VERSION = _v("tmail-cli")
+    except Exception:
+        VERSION = "0.1.0"
+
+    parser = argparse.ArgumentParser(
+        description="Disposable email addresses in your terminal.",
+    )
+    parser.add_argument("-g", "--generate", action="store_true",
+                        help="generate a new random email and print it")
+    parser.add_argument("-l", "--list", action="store_true",
+                        help="list saved emails")
+    parser.add_argument("-i", "--inbox", metavar="EMAIL", nargs="?",
+                        const="__generate__",
+                        help="fetch inbox for EMAIL (one-shot, plain text)")
+    parser.add_argument("-w", "--watch", metavar="EMAIL", nargs="?",
+                        const="__generate__",
+                        help="live-poll inbox for EMAIL (plain text, Ctrl+C to stop)")
+    parser.add_argument("-d", "--delete", metavar="EMAIL",
+                        help="delete EMAIL from history")
+    parser.add_argument("-n", "--interval", metavar="SECONDS", type=int,
+                        help="set poll interval in seconds")
+    parser.add_argument("-c", "--clear", action="store_true",
+                        help="clear all stored data")
+    parser.add_argument("-V", "--version", action="store_true",
+                        help="show version and exit")
+
+    args = parser.parse_args()
+
+    try:
+        if args.version:
+            print(f"tmail v{VERSION}")
+            return
+
+        # --generate can combine with --inbox or --watch
+        generated = None
+        if args.generate:
+            generated = get_random_email()
+            save_email(generated)
+            print(generated)
+            _copy_silent(generated)
+
+        if generated and not args.inbox and not args.watch:
+            return
+
+        if args.list:
+            emails = get_old_emails()
+            unread = get_unread_counts()
+            if not emails:
+                print("No saved emails.")
+                return
+            for i, email in enumerate(emails, 1):
+                count = unread.get(email, 0)
+                badge = f"  ({count} unread)" if count else ""
+                print(f"{i}. {email}{badge}")
+            return
+
+        if args.inbox:
+            target = args.inbox
+            if target == "__generate__" or generated is not None:
+                if generated is None:
+                    generated = get_random_email()
+                    save_email(generated)
+                    print(generated)
+                    _copy_silent(generated)
+                target = generated
+            _print_messages_plain(fetch_messages(target))
+            return
+
+        if args.watch:
+            target = args.watch
+            if target == "__generate__" or generated is not None:
+                if generated is None:
+                    generated = get_random_email()
+                    save_email(generated)
+                    print(generated)
+                    _copy_silent(generated)
+                target = generated
+            _watch_inbox(target)
+            return
+
+        if args.delete:
+            if delete_email(args.delete):
+                remove_unread_entry(args.delete)
+                print(f"Deleted: {args.delete}")
+            else:
+                print(f"Email not found: {args.delete}", file=sys.stderr)
+            return
+
+        if args.interval is not None:
+            config = load_config()
+            config["poll_interval"] = args.interval
+            save_config(config)
+            print(f"Poll interval set to {args.interval}s")
+            return
+
+        if args.clear:
+            remove_all_data()
+            print("All data cleared.")
+            return
+
+        # Default: interactive TUI
+        main_menu()
+
+    except requests.RequestException as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        console.print("\n[bold cyan]Goodbye![/bold cyan]")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

tmail/storage.py

@@ -0,0 +1,149 @@
+import json
+from pathlib import Path
+
+DATA_DIR = Path(".tmail_data")
+OLD_MAILS_FILE = DATA_DIR / "old_mails.json"
+SEEN_MAILS_FILE = DATA_DIR / "seen_mails.json"
+CONFIG_FILE = DATA_DIR / "config.json"
+UNREAD_FILE = DATA_DIR / "unread.json"
+ATTACHMENTS_DIR = DATA_DIR / "attachments"
+
+
+# --- Email history ---
+
+def save_email(email):
+    """Saves a generated email to the history."""
+    DATA_DIR.mkdir(exist_ok=True)
+    if not OLD_MAILS_FILE.exists():
+        with open(OLD_MAILS_FILE, "w") as f:
+            json.dump([], f)
+
+    with open(OLD_MAILS_FILE, "r+") as f:
+        try:
+            emails = json.load(f)
+        except json.JSONDecodeError:
+            emails = []
+        if email not in emails:
+            emails.append(email)
+            f.seek(0)
+            json.dump(emails, f, indent=4)
+
+
+def get_old_emails():
+    """Retrieves the list of previously generated emails."""
+    if not OLD_MAILS_FILE.exists():
+        return []
+    with open(OLD_MAILS_FILE, "r") as f:
+        try:
+            return json.load(f)
+        except json.JSONDecodeError:
+            return []
+
+
+def delete_email(email):
+    """Removes a specific email from the history. Returns True if found."""
+    emails = get_old_emails()
+    if email not in emails:
+        return False
+    emails.remove(email)
+    with open(OLD_MAILS_FILE, "w") as f:
+        json.dump(emails, f, indent=4)
+    return True
+
+
+# --- Seen mail IDs ---
+
+def load_seen_mail_ids():
+    """Loads the set of seen mail IDs from disk."""
+    if not SEEN_MAILS_FILE.exists():
+        return set()
+    with open(SEEN_MAILS_FILE, "r") as f:
+        try:
+            return set(json.load(f))
+        except json.JSONDecodeError:
+            return set()
+
+
+def save_seen_mail_ids(ids):
+    """Persists the set of seen mail IDs to disk."""
+    with open(SEEN_MAILS_FILE, "w") as f:
+        json.dump(list(ids), f)
+
+
+# --- Unread counts ---
+
+def save_unread_count(email, count):
+    """Saves the unread message count for an email address."""
+    DATA_DIR.mkdir(exist_ok=True)
+    data = {}
+    if UNREAD_FILE.exists():
+        with open(UNREAD_FILE, "r") as f:
+            try:
+                data = json.load(f)
+            except json.JSONDecodeError:
+                pass
+    data[email] = count
+    with open(UNREAD_FILE, "w") as f:
+        json.dump(data, f, indent=4)
+
+
+def get_unread_counts():
+    """Returns the dict of email -> unread count."""
+    if not UNREAD_FILE.exists():
+        return {}
+    with open(UNREAD_FILE, "r") as f:
+        try:
+            return json.load(f)
+        except json.JSONDecodeError:
+            return {}
+
+
+def clear_unread_count(email):
+    """Resets the unread count for an email to zero."""
+    save_unread_count(email, 0)
+
+
+def remove_unread_entry(email):
+    """Removes the unread tracking entry for an email."""
+    data = get_unread_counts()
+    if email in data:
+        del data[email]
+        with open(UNREAD_FILE, "w") as f:
+            json.dump(data, f, indent=4)
+
+
+# --- Config ---
+
+def load_config():
+    """Loads user settings from config file."""
+    if not CONFIG_FILE.exists():
+        return {"poll_interval": 5}
+    with open(CONFIG_FILE, "r") as f:
+        try:
+            return json.load(f)
+        except json.JSONDecodeError:
+            return {"poll_interval": 5}
+
+
+def save_config(config):
+    """Saves user settings to config file."""
+    DATA_DIR.mkdir(exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=4)
+
+
+# --- Cleanup ---
+
+def remove_all_data():
+    """Removes all stored data files and the data directory."""
+    for p in [OLD_MAILS_FILE, SEEN_MAILS_FILE, CONFIG_FILE, UNREAD_FILE]:
+        if p.exists():
+            p.unlink()
+    if ATTACHMENTS_DIR.exists():
+        import shutil
+        shutil.rmtree(ATTACHMENTS_DIR)
+    if DATA_DIR.exists():
+        try:
+            DATA_DIR.rmdir()
+        except OSError:
+            pass

tmail/ui.py

@@ -0,0 +1,193 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+import pyfiglet
+
+console = Console()
+
+
+def show_logo():
+    """Displays the application logo and welcome panel."""
+    console.clear()
+    banner = pyfiglet.figlet_format("tMail", font="slant")
+    console.print(f"[bold green]{banner}[/bold green]")
+    logo = Panel(
+        "[dim]Your disposable email solution[/dim]",
+        title="[bold cyan]Welcome[/bold cyan]",
+        border_style="green",
+        expand=False,
+    )
+    console.print(logo)
+
+
+def get_main_menu_panel():
+    """Returns the main menu options panel."""
+    return Panel(
+        "[1] Generate Random Mail\n"
+        "[2] See Mails You Created\n"
+        "[3] Log In To Old Mails\n"
+        "[4] Delete Email From History\n"
+        "[5] Remove All Old Mail's Data\n"
+        "[6] Settings\n"
+        "[7] Exit",
+        title="[bold cyan]Choose Your Option[/bold cyan]",
+        border_style="blue",
+    )
+
+
+def get_email_actions_panel(email):
+    """Returns the email action submenu panel."""
+    return Panel(
+        "[1] View Inbox (live)\n"
+        "[2] View Full Message\n"
+        "[3] Download Attachments\n"
+        "[4] Copy Email Address\n"
+        "[5] Delete This Email\n"
+        "[6] Back to Main Menu",
+        title=f"[bold cyan]Email: {email}[/bold cyan]",
+        border_style="blue",
+    )
+
+
+def get_settings_panel(poll_interval):
+    """Returns the settings menu panel."""
+    return Panel(
+        f"Poll interval: [bold]{poll_interval}s[/bold]\n\n"
+        "[1] Change Poll Interval\n"
+        "[2] Back to Main Menu",
+        title="[bold cyan]Settings[/bold cyan]",
+        border_style="blue",
+    )
+
+
+def show_emails_with_unread(emails, unread_counts):
+    """Displays a list of emails with unread counts in a table."""
+    if not emails:
+        console.print("[yellow]No old emails found.[/yellow]")
+        return
+
+    table = Table(title="[bold green]Your Created Emails[/bold green]")
+    table.add_column("Index", style="cyan")
+    table.add_column("Email Address", style="magenta")
+    table.add_column("Unread", style="yellow", justify="right")
+
+    for i, email in enumerate(emails, 1):
+        count = unread_counts.get(email, 0)
+        badge = str(count) if count else ""
+        table.add_row(str(i), email, badge)
+
+    console.print(table)
+
+
+def show_emails_table(emails):
+    """Displays a simple list of emails without unread counts."""
+    show_emails_with_unread(emails, {})
+
+
+def show_inbox_header(email):
+    """Prints the inbox header for a given email."""
+    console.print(Panel(f"Inbox for: [bold green]{email}[/bold green]", expand=False))
+    console.print("[dim]Press Ctrl+C to go back to the email menu...[/dim]")
+
+
+def build_inbox_table(messages, seen_ids, attachment_url_fn):
+    """Builds a Rich table from fetched messages, filtering seen IDs.
+
+    Returns (table, has_new_messages, new_count).
+    """
+    table = Table(title="[bold blue]Inbox[/bold blue]")
+    table.add_column("From", style="cyan")
+    table.add_column("To", style="cyan")
+    table.add_column("Subject", style="magenta")
+    table.add_column("Body", style="white")
+    table.add_column("Attachments", style="yellow")
+
+    new_count = 0
+    for msg in messages:
+        msg_id = str(msg["id"])
+        if msg_id in seen_ids:
+            continue
+        new_count += 1
+        seen_ids.add(msg_id)
+
+        attachments = []
+        if msg.get("attachments"):
+            for att in msg["attachments"]:
+                download_url = attachment_url_fn(att["id"])
+                attachments.append(f"[link={download_url}]{att['name']}[/link]")
+
+        body = msg["body_text"]
+        if len(body) > 100:
+            body = body[:100] + "..."
+
+        table.add_row(
+            msg["from"],
+            msg["to"],
+            msg["subject"],
+            body,
+            "\n".join(attachments) if attachments else "None",
+        )
+
+    return table, new_count > 0, new_count
+
+
+def show_full_message(msg):
+    """Displays a single message with full body in a Panel."""
+    header = (
+        f"[bold]From:[/bold] {msg['from']}\n"
+        f"[bold]To:[/bold] {msg['to']}\n"
+        f"[bold]Subject:[/bold] {msg['subject']}\n"
+    )
+    body = msg["body_text"]
+    content = f"{header}\n{body}"
+
+    if msg.get("attachments"):
+        att_names = ", ".join(a["name"] for a in msg["attachments"])
+        content += f"\n\n[bold]Attachments:[/bold] {att_names}"
+
+    console.print(Panel(content, title="[bold cyan]Message[/bold cyan]", border_style="cyan"))
+
+
+def show_messages_selection(messages):
+    """Displays an indexed table of messages for selection.
+
+    Returns list of (index, message) tuples.
+    """
+    table = Table(title="[bold blue]Messages[/bold blue]")
+    table.add_column("Idx", style="cyan")
+    table.add_column("From", style="cyan")
+    table.add_column("Subject", style="magenta")
+    table.add_column("Attachments", style="yellow")
+
+    for i, msg in enumerate(messages, 1):
+        att_count = len(msg.get("attachments") or [])
+        att_text = f"{att_count} file(s)" if att_count else "None"
+        table.add_row(str(i), msg["from"], msg["subject"], att_text)
+
+    console.print(table)
+
+
+def ask_choice(prompt_text, choices, default="1", **kwargs):
+    """Prompts the user to make a choice from a list."""
+    return Prompt.ask(prompt_text, choices=choices, default=default, **kwargs)
+
+
+def wait_for_enter():
+    """Waits for the user to press Enter."""
+    Prompt.ask("[bold]Press Enter to go back...[/bold]")
+
+
+def show_error(message):
+    """Prints an error message in red."""
+    console.print(f"[bold red]{message}[/bold red]")
+
+
+def show_success(message):
+    """Prints a success message in green."""
+    console.print(f"[bold green]{message}[/bold green]")
+
+
+def show_info(message):
+    """Prints an informational message in yellow."""
+    console.print(f"[bold yellow]{message}[/bold yellow]")

tmail_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: tmail-cli
+Version: 0.1.0
+Summary: CLI tool for generating temporary email addresses and viewing inboxes
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: pyfiglet
+Requires-Dist: pyperclip
+Requires-Dist: requests
+Requires-Dist: rich
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://img.shields.io/badge/tmail-v0.1.0-blue" alt="version">
+  <img src="https://img.shields.io/badge/python-%3E%3D3.10-green" alt="python">
+  <img src="https://img.shields.io/badge/license-MIT-yellow" alt="license">
+</p>
+
+<h1 align="center">📧 tmail</h1>
+<p align="center"><em>Disposable email addresses, right from your terminal.</em></p>
+
+---
+
+tmail is a lightweight CLI tool that generates temporary email addresses
+and live-polls their inbox. Built with Python and [Rich](https://github.com/Textualize/rich).
+
+## Quick start
+
+```bash
+pip install uv
+uv tool install tmail
+tmail           # interactive TUI
+```
+
+## CLI flags
+
+| Command | Description |
+|---|---|
+| `tmail` | Open the interactive TUI menu |
+| `tmail -g` | Generate a new email, print it, copy to clipboard |
+| `tmail -g -w` | Generate and immediately watch the new inbox |
+| `tmail -g -i` | Generate and fetch inbox once (one-shot) |
+| `tmail -l` | List saved emails with unread counts |
+| `tmail -i <email>` | Fetch inbox once (plain text, good for scripts) |
+| `tmail -w <email>` | Live-poll inbox (plain text, Ctrl+C to stop) |
+| `tmail -d <email>` | Delete an email from history |
+| `tmail -n <seconds>` | Set poll interval |
+| `tmail -c` | Clear all stored data |
+| `tmail -V` | Show version |
+| `tmail -h` | Show help |
+
+## Documentation
+
+| Doc | What's inside |
+|---|---|
+| [User Guide](docs/guide.md) | Full feature walkthrough, menu reference, settings, clipboard, attachments |
+| [Development Guide](docs/development.md) | Architecture, module breakdown, code examples, adding features |
+
+## Data
+
+All data is stored in `.tmail_data/` as JSON files — no database required.
+
+## License
+
+MIT

tmail_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+tmail/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tmail/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+tmail/api.py,sha256=jwhnmNkZLAHGG0GNM11pZ2iZXq7PDwG0RmEWq7W2zoc,1238
+tmail/cli.py,sha256=4pQuKS4MYLEALPpLEUeIvRq7mFCJarPWjmDgLC0mhlc,17335
+tmail/storage.py,sha256=_DPCCwsB77hfcvdsXsZ-AebTkYo4uCNQV2BUNBuuIsI,3906
+tmail/ui.py,sha256=gV2XfvXwutYvbM152Hm4iz7bAIyFvPNK94WcLNkpcFk,5954
+tmail_cli-0.1.0.dist-info/METADATA,sha256=IloI3kroziPTFSivx_5tQDeLsItBflXNPsigYF9UuQk,2030
+tmail_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+tmail_cli-0.1.0.dist-info/entry_points.txt,sha256=XPP86TGHc5338jEDKUKm_j99fESb6LgY8T95lYzKCPY,41
+tmail_cli-0.1.0.dist-info/licenses/LICENSE,sha256=TX9sLhh2IQXkFJ_xzF4GJuTPcW29clNZ8YVPVVIXw-M,1066
+tmail_cli-0.1.0.dist-info/RECORD,,

tmail_cli-0.1.0.dist-info/WHEEL

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

tmail_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tmail = tmail.cli:main

tmail_cli-0.1.0.dist-info/licenses/LICENSE

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