authenticator-tui 1.0.0__py3-none-any.whl

authenticator_tui/__main__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from .app import AuthenticatorApp
+
+
+def main() -> None:
+    file_path = Path(sys.argv[1]).expanduser() if len(sys.argv) > 1 else None
+    app = AuthenticatorApp(file_path=file_path)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

authenticator_tui/app.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Button, Footer, Header, Input, Label, ListView
+
+from .models import OTPEntry
+from .otp_file import load_file, save_file
+from .widgets.otp_item import OTPItem
+from .widgets.add_modal import AddOTPModal
+from .widgets.big_code_modal import BigCodeModal
+
+
+class FilePickerModal(ModalScreen[Path | None]):
+    DEFAULT_CSS = """
+    FilePickerModal {
+        align: center middle;
+    }
+    FilePickerModal > Vertical {
+        width: 60;
+        height: auto;
+        background: $surface;
+        border: thick $accent;
+        padding: 1 2;
+    }
+    FilePickerModal .modal-title {
+        text-style: bold;
+        text-align: center;
+        margin-bottom: 1;
+    }
+    FilePickerModal .error-msg {
+        color: $error;
+        height: 1;
+        margin-top: 1;
+    }
+    FilePickerModal .buttons {
+        margin-top: 2;
+        align: right middle;
+        height: 3;
+    }
+    FilePickerModal Button {
+        margin-left: 1;
+    }
+    """
+
+    def __init__(self, default_path: str = "") -> None:
+        super().__init__()
+        self._default_path = default_path
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label("Open OTP file", classes="modal-title")
+            yield Label("File path:", classes="field-label")
+            yield Input(value=self._default_path, placeholder="path/to/otp.txt", id="path-input")
+            yield Label("", classes="error-msg", id="path-error")
+            with Horizontal(classes="buttons"):
+                yield Button("Cancel", variant="default", id="cancel")
+                yield Button("Open", variant="primary", id="open")
+
+    def on_mount(self) -> None:
+        self.query_one("#path-input", Input).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "cancel":
+            self.dismiss(None)
+            return
+        self._submit()
+
+    def on_input_submitted(self, _event: Input.Submitted) -> None:
+        self._submit()
+
+    def _submit(self) -> None:
+        raw = self.query_one("#path-input", Input).value.strip()
+        path = Path(raw).expanduser()
+        if not path.exists():
+            self.query_one("#path-error", Label).update(f"File not found: {path}")
+            return
+        self.dismiss(path)
+
+    def on_key(self, event) -> None:
+        if event.key == "escape":
+            event.stop()
+            self.dismiss(None)
+
+
+class ExportModal(ModalScreen[Path | None]):
+    DEFAULT_CSS = """
+    ExportModal {
+        align: center middle;
+    }
+    ExportModal > Vertical {
+        width: 60;
+        height: auto;
+        background: $surface;
+        border: thick $accent;
+        padding: 1 2;
+    }
+    ExportModal .modal-title {
+        text-style: bold;
+        text-align: center;
+        margin-bottom: 1;
+    }
+    ExportModal .error-msg {
+        color: $error;
+        height: 1;
+        margin-top: 1;
+    }
+    ExportModal .buttons {
+        margin-top: 2;
+        align: right middle;
+        height: 3;
+    }
+    ExportModal Button {
+        margin-left: 1;
+    }
+    """
+
+    def __init__(self, default_path: str = "") -> None:
+        super().__init__()
+        self._default_path = default_path
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label("Export OTP file", classes="modal-title")
+            yield Label("Export path:", classes="field-label")
+            yield Input(value=self._default_path, placeholder="path/to/export.txt", id="export-path")
+            yield Label("", classes="error-msg", id="export-error")
+            with Horizontal(classes="buttons"):
+                yield Button("Cancel", variant="default", id="cancel")
+                yield Button("Export", variant="primary", id="export")
+
+    def on_mount(self) -> None:
+        self.query_one("#export-path", Input).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "cancel":
+            self.dismiss(None)
+            return
+        self._submit()
+
+    def on_input_submitted(self, _event: Input.Submitted) -> None:
+        self._submit()
+
+    def _submit(self) -> None:
+        raw = self.query_one("#export-path", Input).value.strip()
+        if not raw:
+            self.query_one("#export-error", Label).update("Please enter a path.")
+            return
+        self.dismiss(Path(raw).expanduser())
+
+    def on_key(self, event) -> None:
+        if event.key == "escape":
+            event.stop()
+            self.dismiss(None)
+
+
+class AuthenticatorApp(App[None]):
+    TITLE = "Authenticator TUI"
+    CSS = """
+    #filter-input {
+        dock: top;
+        margin: 0 1;
+    }
+    #otp-list {
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("a", "add_otp", "Add"),
+        Binding("d", "delete_otp", "Delete"),
+        Binding("e", "export", "Export"),
+        Binding("f", "focus_filter", "Filter"),
+        Binding("escape", "blur_filter", "Back to list", show=False),
+        Binding("q", "quit", "Quit"),
+    ]
+
+    def __init__(self, file_path: Path | None = None) -> None:
+        super().__init__()
+        self._file_path: Path | None = file_path
+        self._entries: list[OTPEntry] = []
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Input(placeholder="Filter by issuer or account...", id="filter-input")
+        yield ListView(id="otp-list")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        if self._file_path and self._file_path.exists():
+            self._load(self._file_path)
+        else:
+            default = ""
+            if Path("otp.txt").exists():
+                default = "otp.txt"
+            self.push_screen(FilePickerModal(default), self._on_file_picked)
+
+    def _on_file_picked(self, path: Path | None) -> None:
+        if path is None:
+            self.exit()
+            return
+        self._file_path = path
+        self._load(path)
+
+    def _load(self, path: Path) -> None:
+        try:
+            self._entries = load_file(path)
+            self._populate_list(self._entries)
+            self.query_one("#filter-input", Input).focus()
+            self.notify(f"Loaded {len(self._entries)} entries from {path.name}", timeout=3)
+        except Exception as e:
+            self.notify(f"Error loading file: {e}", severity="error")
+
+    def _populate_list(self, entries: list[OTPEntry]) -> None:
+        lst = self.query_one("#otp-list", ListView)
+        lst.clear()
+        for entry in entries:
+            lst.append(OTPItem(entry))
+
+    def _save(self) -> None:
+        if self._file_path:
+            try:
+                save_file(self._file_path, self._entries)
+            except Exception as e:
+                self.notify(f"Save error: {e}", severity="error")
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "filter-input":
+            text = event.value
+            filtered = [e for e in self._entries if not text or e.matches_filter(text)]
+            self._populate_list(filtered)
+
+    def action_add_otp(self) -> None:
+        self.push_screen(AddOTPModal(), self._on_entry_added)
+
+    def _on_entry_added(self, entry: OTPEntry | None) -> None:
+        if entry is None:
+            return
+        self._entries.append(entry)
+        self._save()
+        filter_text = self.query_one("#filter-input", Input).value
+        if not filter_text or entry.matches_filter(filter_text):
+            self.query_one("#otp-list", ListView).append(OTPItem(entry))
+        self.notify(f"Added {entry.issuer or entry.account}", timeout=2)
+
+    def action_delete_otp(self) -> None:
+        lst = self.query_one("#otp-list", ListView)
+        idx = lst.index
+        if idx is None:
+            return
+        items = list(lst.query(OTPItem))
+        if not items or idx >= len(items):
+            return
+        entry = items[idx].entry
+        self._entries = [e for e in self._entries if e is not entry]
+        self._save()
+        lst.remove_items([idx])
+        self.notify(f"Deleted {entry.issuer or entry.account}", timeout=2)
+
+    def action_export(self) -> None:
+        default = str(self._file_path) if self._file_path else "otp.txt"
+        self.push_screen(ExportModal(default), self._on_export_path)
+
+    def _on_export_path(self, path: Path | None) -> None:
+        if path is None:
+            return
+        try:
+            save_file(path, self._entries)
+            self.notify(f"Exported {len(self._entries)} entries to {path}", timeout=3)
+        except Exception as e:
+            self.notify(f"Export error: {e}", severity="error")
+
+    def action_focus_filter(self) -> None:
+        self.query_one("#filter-input", Input).focus()
+
+    def action_blur_filter(self) -> None:
+        inp = self.query_one("#filter-input", Input)
+        if inp.has_focus:
+            inp.clear()
+            self.query_one("#otp-list", ListView).focus()
+        else:
+            self.exit()
+
+    def on_key(self, event) -> None:
+        inp = self.query_one("#filter-input", Input)
+        lst = self.query_one("#otp-list", ListView)
+        if event.key == "down" and inp.has_focus:
+            lst.focus()
+            if lst.index is None:
+                lst.action_cursor_down()
+        elif event.key == "up" and lst.has_focus and (lst.index is None or lst.index == 0):
+            inp.focus()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        if isinstance(event.item, OTPItem):
+            self.push_screen(BigCodeModal(event.item.entry))

authenticator_tui/models.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from urllib.parse import parse_qs, quote, unquote, urlencode, urlparse
+
+import pyotp
+
+_URLENCODE_KWARGS = {"quote_via": quote}
+
+
+@dataclass
+class OTPEntry:
+    otp_type: str  # "totp" or "hotp"
+    label: str
+    issuer: str
+    account: str
+    secret: str
+    algorithm: str = "SHA1"
+    digits: int = 6
+    period: int = 30
+    counter: int = 0
+
+    @staticmethod
+    def from_url(url: str) -> OTPEntry:
+        parsed = urlparse(url)
+        if parsed.scheme != "otpauth":
+            raise ValueError(f"Not an otpauth URL: {url}")
+
+        otp_type = parsed.netloc  # "totp" or "hotp"
+        label = unquote(parsed.path.lstrip("/"))
+
+        # Split issuer:account from label
+        if ":" in label:
+            issuer_from_label, account = label.split(":", 1)
+        else:
+            issuer_from_label, account = "", label
+
+        params = parse_qs(parsed.query)
+
+        def first(key: str, default: str = "") -> str:
+            return params.get(key, [default])[0]
+
+        issuer = first("issuer") or issuer_from_label
+        secret = first("secret")
+        algorithm = first("algorithm", "SHA1").upper()
+        digits = int(first("digits", "6"))
+        period = int(first("period", "30"))
+        counter = int(first("counter", "0"))
+
+        return OTPEntry(
+            otp_type=otp_type,
+            label=label,
+            issuer=issuer,
+            account=account,
+            secret=secret,
+            algorithm=algorithm,
+            digits=digits,
+            period=period,
+            counter=counter,
+        )
+
+    def to_url(self) -> str:
+        label = quote(self.label, safe="")
+        params: dict[str, str] = {"secret": self.secret, "issuer": self.issuer}
+        if self.algorithm != "SHA1":
+            params["algorithm"] = self.algorithm
+        if self.digits != 6:
+            params["digits"] = str(self.digits)
+        if self.otp_type == "totp" and self.period != 30:
+            params["period"] = str(self.period)
+        if self.otp_type == "hotp":
+            params["counter"] = str(self.counter)
+        return f"otpauth://{self.otp_type}/{label}?{urlencode(params, quote_via=quote)}"
+
+    def get_code(self) -> str:
+        if self.otp_type == "totp":
+            totp = pyotp.TOTP(
+                self.secret,
+                digits=self.digits,
+                digest=_digest(self.algorithm),
+                interval=self.period,
+            )
+            code = totp.now()
+        else:
+            hotp = pyotp.HOTP(self.secret, digits=self.digits, digest=_digest(self.algorithm))
+            code = hotp.at(self.counter)
+
+        # Insert a space in the middle for readability
+        mid = len(code) // 2
+        return code[:mid] + " " + code[mid:]
+
+    def time_remaining(self) -> int:
+        if self.otp_type != "totp":
+            return 0
+        return self.period - int(time.time()) % self.period
+
+    def matches_filter(self, text: str) -> bool:
+        text = text.lower()
+        return text in self.issuer.lower() or text in self.account.lower()
+
+
+def _digest(algorithm: str):
+    import hashlib
+
+    return {
+        "SHA1": hashlib.sha1,
+        "SHA256": hashlib.sha256,
+        "SHA512": hashlib.sha512,
+    }.get(algorithm, hashlib.sha1)

authenticator_tui/otp_file.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .models import OTPEntry
+
+
+def load_file(path: Path) -> list[OTPEntry]:
+    entries = []
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        try:
+            entries.append(OTPEntry.from_url(line))
+        except Exception as e:
+            raise ValueError(f"Invalid OTP URL: {line!r}") from e
+    return entries
+
+
+def save_file(path: Path, entries: list[OTPEntry]) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text("\n".join(e.to_url() for e in entries) + "\n")
+    tmp.rename(path)

authenticator_tui/widgets/__init__.py

@@ -0,0 +1,3 @@
+from .otp_item import OTPItem
+
+__all__ = ["OTPItem"]

authenticator_tui/widgets/add_modal.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Vertical, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, Select, TabbedContent, TabPane, TextArea
+
+from ..models import OTPEntry
+
+
+class AddOTPModal(ModalScreen[OTPEntry | None]):
+    DEFAULT_CSS = """
+    AddOTPModal {
+        align: center middle;
+    }
+    AddOTPModal > Vertical {
+        width: 70;
+        height: auto;
+        max-height: 80%;
+        background: $surface;
+        border: thick $accent;
+        padding: 1 2;
+    }
+    AddOTPModal .modal-title {
+        text-style: bold;
+        text-align: center;
+        margin-bottom: 1;
+    }
+    AddOTPModal .field-label {
+        margin-top: 1;
+        color: $text-muted;
+    }
+    AddOTPModal .buttons {
+        margin-top: 2;
+        align: right middle;
+        height: 3;
+    }
+    AddOTPModal Button {
+        margin-left: 1;
+    }
+    AddOTPModal .error-msg {
+        color: $error;
+        height: 1;
+        margin-top: 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label("Add OTP", classes="modal-title")
+            with TabbedContent():
+                with TabPane("Paste URL", id="tab-url"):
+                    yield Label("Paste an otpauth:// URL:", classes="field-label")
+                    yield TextArea(id="url-input")
+                    yield Label("", classes="error-msg", id="url-error")
+
+                with TabPane("Manual", id="tab-manual"):
+                    yield Label("Issuer", classes="field-label")
+                    yield Input(placeholder="e.g. GitHub", id="issuer")
+                    yield Label("Account", classes="field-label")
+                    yield Input(placeholder="e.g. user@example.com", id="account")
+                    yield Label("Secret (required)", classes="field-label")
+                    yield Input(placeholder="Base32 secret", id="secret")
+                    yield Label("Algorithm", classes="field-label")
+                    yield Select(
+                        [("SHA1", "SHA1"), ("SHA256", "SHA256"), ("SHA512", "SHA512")],
+                        value="SHA1",
+                        id="algorithm",
+                    )
+                    yield Label("Digits", classes="field-label")
+                    yield Select(
+                        [("6", "6"), ("8", "8")],
+                        value="6",
+                        id="digits",
+                    )
+                    yield Label("Period (seconds)", classes="field-label")
+                    yield Input(value="30", id="period")
+                    yield Label("", classes="error-msg", id="manual-error")
+
+            with Horizontal(classes="buttons"):
+                yield Button("Cancel", variant="default", id="cancel")
+                yield Button("Add", variant="primary", id="add")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "cancel":
+            self.dismiss(None)
+            return
+
+        tabs = self.query_one(TabbedContent)
+        active = tabs.active
+
+        if active == "tab-url":
+            self._submit_url()
+        else:
+            self._submit_manual()
+
+    def _submit_url(self) -> None:
+        error_label = self.query_one("#url-error", Label)
+        text = self.query_one("#url-input", TextArea).text.strip()
+        if not text:
+            error_label.update("Please paste an otpauth:// URL.")
+            return
+        try:
+            entry = OTPEntry.from_url(text)
+            self.dismiss(entry)
+        except Exception as e:
+            error_label.update(f"Invalid URL: {e}")
+
+    def _submit_manual(self) -> None:
+        error_label = self.query_one("#manual-error", Label)
+
+        secret = self.query_one("#secret", Input).value.strip()
+        if not secret:
+            error_label.update("Secret is required.")
+            return
+
+        issuer = self.query_one("#issuer", Input).value.strip()
+        account = self.query_one("#account", Input).value.strip()
+        algorithm = str(self.query_one("#algorithm", Select).value)
+        digits_str = str(self.query_one("#digits", Select).value)
+        period_str = self.query_one("#period", Input).value.strip()
+
+        try:
+            period = int(period_str)
+        except ValueError:
+            error_label.update("Period must be an integer.")
+            return
+
+        if issuer and account:
+            label = f"{issuer}:{account}"
+        else:
+            label = account or issuer or secret
+
+        entry = OTPEntry(
+            otp_type="totp",
+            label=label,
+            issuer=issuer,
+            account=account,
+            secret=secret,
+            algorithm=algorithm,
+            digits=int(digits_str),
+            period=period,
+        )
+
+        try:
+            entry.get_code()  # validate that secret works
+        except Exception as e:
+            error_label.update(f"Invalid secret: {e}")
+            return
+
+        self.dismiss(entry)
+
+    def on_key(self, event) -> None:
+        if event.key == "escape":
+            event.stop()
+            self.dismiss(None)

authenticator_tui/widgets/big_code_modal.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Digits, Label, Static
+from textual.containers import Vertical
+
+from ..models import OTPEntry
+
+
+class BigCodeModal(ModalScreen[None]):
+    DEFAULT_CSS = """
+    BigCodeModal {
+        align: center middle;
+    }
+    BigCodeModal > Vertical {
+        width: auto;
+        height: auto;
+        background: $surface;
+        border: thick $accent;
+        padding: 2 4;
+    }
+    BigCodeModal .entry-label {
+        text-align: center;
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    BigCodeModal Digits {
+        color: $success;
+        width: auto;
+    }
+    BigCodeModal #big-timer {
+        text-align: center;
+        color: $accent;
+        margin-top: 1;
+    }
+    BigCodeModal .dismiss-hint {
+        text-align: center;
+        color: $text-muted;
+        margin-top: 1;
+    }
+    """
+
+    def __init__(self, entry: OTPEntry) -> None:
+        super().__init__()
+        self._entry = entry
+
+    def compose(self) -> ComposeResult:
+        label = (
+            f"{self._entry.issuer} / {self._entry.account}"
+            if self._entry.issuer
+            else self._entry.account
+        )
+        with Vertical():
+            yield Label(label, classes="entry-label")
+            yield Digits("", id="big-code")
+            yield Static("", id="big-timer")
+            yield Label("Press any key or click to dismiss", classes="dismiss-hint")
+
+    def on_mount(self) -> None:
+        self._refresh()
+        self.set_interval(1, self._refresh)
+
+    def _refresh(self) -> None:
+        try:
+            code = self._entry.get_code()
+            remaining = self._entry.time_remaining()
+            period = self._entry.period
+            bar_width = 30
+            filled = round((remaining / period) * bar_width)
+            bar = "=" * filled + "-" * (bar_width - filled)
+            self.query_one("#big-code", Digits).update(code)
+            self.query_one("#big-timer", Static).update(f"[{bar}] {remaining}s")
+        except Exception:
+            self.query_one("#big-code", Digits).update("---")
+
+    def on_key(self, event) -> None:
+        event.stop()
+        self.dismiss()
+
+    def on_click(self) -> None:
+        self.dismiss()

authenticator_tui/widgets/otp_item.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.widgets import ListItem, Label, Static
+from textual.reactive import reactive
+
+from ..models import OTPEntry
+
+
+BAR_WIDTH = 10
+
+
+def _progress_bar(remaining: int, period: int) -> str:
+    filled = round((remaining / period) * BAR_WIDTH)
+    return "█" * filled + "░" * (BAR_WIDTH - filled)
+
+
+class OTPItem(ListItem):
+    DEFAULT_CSS = """
+    OTPItem {
+        height: 3;
+        padding: 0 1;
+    }
+    OTPItem > .otp-row {
+        layout: horizontal;
+        height: 1;
+    }
+    OTPItem .otp-label {
+        width: 1fr;
+        color: $text;
+    }
+    OTPItem .otp-code {
+        width: 10;
+        text-align: center;
+        color: $success;
+        text-style: bold;
+    }
+    OTPItem .otp-bar {
+        width: 14;
+        text-align: right;
+        color: $accent;
+    }
+    OTPItem.--highlight .otp-code {
+        color: $success-lighten-2;
+    }
+    """
+
+    code: reactive[str] = reactive("", layout=False)
+    remaining: reactive[int] = reactive(30, layout=False)
+
+    def __init__(self, entry: OTPEntry) -> None:
+        super().__init__()
+        self.entry = entry
+
+    def compose(self) -> ComposeResult:
+        label = f"{self.entry.issuer} / {self.entry.account}" if self.entry.issuer else self.entry.account
+        with Static(classes="otp-row"):
+            yield Label(label, classes="otp-label")
+            yield Label("", classes="otp-code", id=f"code-{id(self)}")
+            yield Label("", classes="otp-bar", id=f"bar-{id(self)}")
+
+    def on_mount(self) -> None:
+        self._refresh_code()
+        self.set_interval(1, self._refresh_code)
+
+    def _refresh_code(self) -> None:
+        try:
+            code = self.entry.get_code()
+            remaining = self.entry.time_remaining()
+            bar = _progress_bar(remaining, self.entry.period)
+            self.query_one(f"#code-{id(self)}", Label).update(code)
+            self.query_one(f"#bar-{id(self)}", Label).update(f"{bar} {remaining:2d}s")
+        except Exception:
+            self.query_one(f"#code-{id(self)}", Label).update("ERROR")
+            self.query_one(f"#bar-{id(self)}", Label).update("")
+
+    def on_click(self) -> None:
+        try:
+            import pyperclip
+            code = self.entry.get_code().replace(" ", "")
+            pyperclip.copy(code)
+            self.app.notify(f"Copied: {code}", timeout=2)
+        except Exception:
+            pass

authenticator_tui-1.0.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: authenticator-tui
+Version: 1.0.0
+Summary: A keyboard-driven terminal UI for managing TOTP/HOTP one-time passwords
+Project-URL: Homepage, https://gitlab.com/riphixel/authenticator-tui
+Project-URL: Repository, https://gitlab.com/riphixel/authenticator-tui
+Project-URL: Issues, https://gitlab.com/riphixel/authenticator-tui/-/issues
+Author-email: Pierre Gronlier <pierre@gronlier.fr>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 2fa,authenticator,hotp,mfa,otp,terminal,textual,totp,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Requires-Dist: pyotp>=2.10.0
+Requires-Dist: pyperclip>=1.11.0
+Requires-Dist: textual>=8.2.7
+Description-Content-Type: text/markdown
+
+# authenticator-tui
+
+A terminal UI for managing TOTP/HOTP one-time passwords stored as `otpauth://` URLs.
+
+<img width="700" src="screenshots/main.svg" alt="Main screen">
+
+## Features
+
+- **Live codes** — TOTP codes refresh every second with a countdown progress bar
+- **Filter** — press `f` and type to narrow the list by issuer or account
+- **Add** — paste an `otpauth://` URL or fill in fields manually
+- **Delete** — remove an entry with auto-save
+- **Big code view** — press Enter on any entry to display the code in large digits
+- **Clipboard** — click any entry to copy the code
+- **Export** — write all entries to a file as `otpauth://` URLs
+
+## Install
+
+```bash
+uv tool install git+https://gitlab.com/riphixel/authenticator-tui
+```
+
+Or run directly without installing:
+
+```bash
+uvx --from git+https://gitlab.com/riphixel/authenticator-tui authenticator-tui otp.txt
+```
+
+## Usage
+
+```bash
+authenticator-tui [path/to/otp.txt]
+```
+
+If no file is given (or the path doesn't exist) a file picker appears on startup.
+The file is auto-saved on every add or delete.
+
+## Keybindings
+
+| Key | Action |
+|---|---|
+| `f` | Focus filter input |
+| `↓` in filter | Jump to first list entry |
+| `↑` on first entry | Jump back to filter |
+| `a` | Add OTP (modal) |
+| `d` | Delete selected OTP |
+| `e` | Export to file (modal) |
+| Enter | Show code in big digits |
+| Click | Copy code to clipboard |
+| Escape | Clear filter / close modal |
+| `q` | Quit |
+
+## Screenshots
+
+### Filter
+
+<img width="700" src="screenshots/filter.svg" alt="Filter">
+
+### Add OTP
+
+<img width="700" src="screenshots/add_modal.svg" alt="Add OTP modal">
+
+### Big code view
+
+<img width="700" src="screenshots/big_code.svg" alt="Big code">
+
+## File format
+
+One `otpauth://` URL per line. Blank lines and lines starting with `#` are ignored.
+
+```
+otpauth://totp/GitHub:alice@example.com?secret=JBSWY3DPEHPK3PXP&issuer=GitHub
+otpauth://totp/PayPal:alice@example.com?secret=JBSWY3DPEHPK3PXP&issuer=PayPal
+```
+
+## Development
+
+```bash
+uv sync
+uv run authenticator-tui otp.txt
+
+# tests
+uv run pytest
+
+# lint
+uvx ruff check .
+uvx ruff format --check .
+```

authenticator_tui-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+authenticator_tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+authenticator_tui/__main__.py,sha256=H2JUwM1uECoSGut0E8zn5bOBBTkK5sEqzEoIIWKQ5PA,309
+authenticator_tui/app.py,sha256=kKVHMwL3R8lglsz2dxxxgLpVulFDVlSJZcz4YRjEnho,9742
+authenticator_tui/models.py,sha256=gKH5mNioyAdopDGChTvZChAoAkLHZ5twQfn_cR-UxMs,3303
+authenticator_tui/otp_file.py,sha256=BSeLGz9Gqhc4mxvwxhgutjxE30mSTP_XuKYStlW4Q_Q,675
+authenticator_tui/widgets/__init__.py,sha256=2ED13TyjDXYMZbPJiYiJRzJ5cxFQQBIOBhATFzE340E,53
+authenticator_tui/widgets/add_modal.py,sha256=DGjpL98mbR4CfN8ihf-QdNz5fFre6VdalaCJSCsT44s,5186
+authenticator_tui/widgets/big_code_modal.py,sha256=01qFxxyKX9IGXLz0DtgcsVk8jm8bq83Koe8hfeFJwiI,2305
+authenticator_tui/widgets/otp_item.py,sha256=EsMq5h7598_VGWkuxfUOZKStj0_o6T60E_-E7cPLekM,2449
+authenticator_tui-1.0.0.dist-info/METADATA,sha256=U_yZd4bKEs7UhyXK3wIY21b9r1ldzanOmfZLXd1a9Mo,3320
+authenticator_tui-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+authenticator_tui-1.0.0.dist-info/entry_points.txt,sha256=lZ4DKLsRls5w7HbT_kwlZOKlIB-hmaOcXE_ZQfdK-1w,70
+authenticator_tui-1.0.0.dist-info/licenses/LICENSE,sha256=mEzskvKveEYNqkkVrP9Q81V836L1XzdWDIz3FGs8Hc8,1072
+authenticator_tui-1.0.0.dist-info/RECORD,,

authenticator_tui-1.0.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

authenticator_tui-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+authenticator-tui = authenticator_tui.__main__:main

authenticator_tui-1.0.0.dist-info/licenses/LICENSE

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