otpilot 3.2.0__tar.gz → 3.2.1__tar.gz

{otpilot-3.2.0 → otpilot-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: otpilot
-Version: 3.2.0
+Version: 3.2.1
 Summary: Privacy-focused CLI that retrieves email OTPs via IMAP and copies them to the clipboard.
 Project-URL: Repository, https://github.com/CodeWithJenil/otpilot3.0
 Project-URL: Issues, https://github.com/CodeWithJenil/otpilot3.0/issues
@@ -50,6 +50,8 @@ Description-Content-Type: text/markdown
 
 OTPilot is a local-first command-line tool for retrieving one-time passwords from Gmail over IMAP. Use it when you want a simpler workflow for email-based verification codes.
 
+![OTPilot demo](otpilot.gif)
+
 - **Clipboard support:** use `otpilot fetch --copy` to copy the detected OTP without printing its value to terminal output.
 - **Local-first design:** email retrieval happens on your machine; OTPilot does not require a hosted relay or sync service.
 - **Opt-in telemetry:** usage telemetry is disabled by default and is sent only if you explicitly enable it.

{otpilot-3.2.0 → otpilot-3.2.1}/README.md

@@ -9,6 +9,8 @@
 
 OTPilot is a local-first command-line tool for retrieving one-time passwords from Gmail over IMAP. Use it when you want a simpler workflow for email-based verification codes.
 
+![OTPilot demo](otpilot.gif)
+
 - **Clipboard support:** use `otpilot fetch --copy` to copy the detected OTP without printing its value to terminal output.
 - **Local-first design:** email retrieval happens on your machine; OTPilot does not require a hosted relay or sync service.
 - **Opt-in telemetry:** usage telemetry is disabled by default and is sent only if you explicitly enable it.

{otpilot-3.2.0 → otpilot-3.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "otpilot"
-version = "3.2.0"
+version = "3.2.1"
 description = "Privacy-focused CLI that retrieves email OTPs via IMAP and copies them to the clipboard."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -69,6 +69,7 @@ include = [
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+pythonpath = ["src"]
 addopts = "-q"
 
 [tool.ruff]

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/application/feedback.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import random
 import sys
-import typer
 import webbrowser
 from dataclasses import dataclass
 from typing import Protocol

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/application/ports.py

@@ -1,5 +1,7 @@
 """Application-layer ports implemented by infrastructure adapters."""
 
+from __future__ import annotations
+
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from pathlib import Path

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/application/services.py

@@ -130,14 +130,14 @@ class WatchService:
 
     Three monitoring modes are supported:
 
-    1. **Hotkey-enabled** ({\@literal hotkey_enabled=true}): Wait for the configured
+    1. **Hotkey-enabled** (`hotkey_enabled=True`): Wait for the configured
        global hotkey. Each valid hotkey activation triggers an immediate mailbox check.
        Overlapping checks are prevented.
 
-    2. **IMAP IDLE** ({\@literal idle_provider} is set): Uses IMAP IDLE for
+    2. **IMAP IDLE** (`idle_provider` is set): Uses IMAP IDLE for
        near-instant OTP detection. The provider must be authenticated.
 
-    3. **Polling fallback** (default): Checks the mailbox every {\@literal poll_interval_seconds}.
+    3. **Polling fallback** (default): Checks the mailbox every `poll_interval_seconds`.
        Both branches share the same duplicate-suppression logic via
        ``processed_message_ids``.
     """
@@ -146,12 +146,11 @@ class WatchService:
     poll_interval_seconds: float = 3.00
     sleep: Callable[[float], None] = field(default=sleep)
     hotkey_enabled: bool = False
-    idle_provider: object | None = field(default=None)
-    idle_account_id: AccountId | None = field(default=None)
-    status: Callable[[str], None] = field(default=lambda message: None)
+    hotkey: str = "ctrl+shift+o"
     # Set by the daemon factory to enable IMAP IDLE; None ⟹ polling fallback.
     idle_provider: object | None = field(default=None)
     idle_account_id: AccountId | None = field(default=None)
+    status: Callable[[str], None] = field(default=lambda message: None)
 
     def run(self) -> None:
         """Run the watch loop until interrupted or a fatal error occurs."""
@@ -160,13 +159,15 @@ class WatchService:
         try:
             if self.hotkey_enabled:
                 # ── Hotkey-enabled branch ─────────────────────────────────────
-                # Wait for the configured global hotkey.
-                # Each valid hotkey activation triggers an immediate mailbox check.
-                # Overlapping checks are prevented via the active lock.
+                # Wait for the configured global hotkey using HotkeyService.
                 from otpilot.infrastructure.hotkeys import PynputHotkeyListener
-                listener = PynputHotkeyListener()
-                listener.register(self.hotkey, self._on_hotkey_press)
-                listener.run()
+                hotkey_service = HotkeyService(
+                    fetch_service=self.fetch_service,
+                    listener=PynputHotkeyListener(),
+                    hotkey=self.hotkey,
+                    status=self.status,
+                )
+                hotkey_service.run()
             elif self.idle_provider is not None and hasattr(self.idle_provider, "idle_fetch"):
                 # ── IMAP IDLE branch ─────────────────────────────────────────
                 # idle_provider is already authenticated by the daemon factory.

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/cli/commands/config.py

@@ -31,7 +31,7 @@ def command(
     non_interactive: bool = typer.Option(
         False, "--non-interactive", "-n", help="Run in non-interactive mode."
     ),
-):
+) -> None:
     if ctx.invoked_subcommand is not None:
         return
     console = Console()

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/cli/commands/daemon.py

@@ -1,9 +1,9 @@
 """CLI commands for daemon management."""
 
 import sys
-import time
 import typer
 
+from otpilot.application.ports import DaemonManager, DaemonStatus
 from otpilot.application.services import FetchOtpService, WatchService
 from otpilot.application.settings import SettingsService
 from otpilot.cache.memory import InMemoryOtpCache
@@ -75,6 +75,7 @@ def build_daemon_watch_service() -> WatchService:
         poll_interval_seconds=config.poll_interval_seconds,
         status=lambda message: None,  # Silent in daemon mode
         hotkey_enabled=config.hotkey_enabled,
+        hotkey=config.hotkey,
         idle_provider=idle_provider,
         idle_account_id=idle_account_id,
     )
@@ -120,7 +121,7 @@ app = typer.Typer(
 )
 
 
-def _get_daemon_manager():
+def _get_daemon_manager() -> DaemonManager:
     """Get the platform-specific daemon manager."""
     try:
         return create_daemon_manager()
@@ -129,7 +130,7 @@ def _get_daemon_manager():
         raise typer.Exit(code=1) from exc
 
 
-def _print_status(status) -> None:
+def _print_status(status: DaemonStatus) -> None:
     """Print daemon status in a consistent format."""
     typer.echo(f"Installed: {'Yes' if status.installed else 'No'}")
     typer.echo(f"Running:   {'Yes' if status.running else 'No'}")

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/infrastructure/daemon/linux.py

@@ -80,7 +80,7 @@ WantedBy=default.target
         content = self._build_service_content()
         self._service_path.write_text(content, encoding="utf-8")
 
-    def _systemctl_user(self, *args: str) -> subprocess.CompletedProcess:
+    def _systemctl_user(self, *args: str) -> subprocess.CompletedProcess[str]:
         """Run systemctl --user command."""
         return subprocess.run(
             ["systemctl", "--user", *args],

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/infrastructure/daemon/macos.py

@@ -9,6 +9,7 @@ import subprocess
 import sys
 import time
 from pathlib import Path
+from typing import Any
 
 from otpilot.application.ports import DaemonManager, DaemonStatus
 from otpilot.domain.errors import OTPilotError
@@ -72,7 +73,7 @@ class MacOSDaemonManager(DaemonManager):
         if pid is None or not self._is_process_running(pid):
             self._clear_pid()
 
-    def _build_plist(self, autostart: bool = False) -> dict:
+    def _build_plist(self, autostart: bool = False) -> dict[str, Any]:
         """Build the LaunchAgent plist dictionary."""
         python_exe = self._get_python_executable()
         working_dir = self._get_working_directory()

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/infrastructure/logging/setup.py

@@ -5,8 +5,12 @@ import re
 from collections.abc import Mapping
 from typing import Any
 
+# BUG-01 fix: the original pattern used r"([^\\\s]+)" which in a raw string is
+# the character class [^\\s] ("not backslash or s"), capturing only the first
+# character of a secret value. The correct pattern is r"([^\s]+)" which means
+# "not whitespace", so the full secret value is always captured and redacted.
 SECRET_PATTERNS = (
-    re.compile(r"(?i)(password|app_password|token|secret|credential)=([^\\s]+)"),
+    re.compile(r"(?i)(password|app_password|token|secret|credential)=([^\s]+)"),
 )
 
 
@@ -29,4 +33,3 @@ def configure_logging(level: int = logging.INFO, extra: Mapping[str, Any] | None
     logging.basicConfig(level=level, handlers=[handler], force=True)
     if extra:
         logging.getLogger("otpilot").debug("logging configured", extra=dict(extra))
-

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/infrastructure/terminal/hotkey_capture.py

@@ -162,7 +162,7 @@ class HotkeyCapture:
 
         if isinstance(key, keyboard.KeyCode):
             if key.char:
-                char = key.char.lower()
+                char = str(key.char).lower()
                 if "\x01" <= char <= "\x1a":
                     # Ctrl+letter arrives as a control character (e.g. Ctrl+O
                     # is "\\x0f"); map it back to the plain letter.

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/infrastructure/terminal/keyboard.py

@@ -102,19 +102,20 @@ def parse_key(
     if ch == "\x04":
         return KeyEvent(key=Key.CTRL_D, ctrl=True)
     if ch == "\x1b":
-        next_ch = read_next() if read_next else None
-        if next_ch == "[":
-            third = read_next()
-            if third == "A":
-                return KeyEvent(key=Key.UP)
-            if third == "B":
-                return KeyEvent(key=Key.DOWN)
-            if third == "C":
-                return KeyEvent(key=Key.RIGHT)
-            if third == "D":
-                return KeyEvent(key=Key.LEFT)
-            if third == "3" and read_next() == "~":
-                return KeyEvent(key=Key.BACKSPACE)
+        if read_next is not None:
+            next_ch = read_next()
+            if next_ch == "[":
+                third = read_next()
+                if third == "A":
+                    return KeyEvent(key=Key.UP)
+                if third == "B":
+                    return KeyEvent(key=Key.DOWN)
+                if third == "C":
+                    return KeyEvent(key=Key.RIGHT)
+                if third == "D":
+                    return KeyEvent(key=Key.LEFT)
+                if third == "3" and read_next() == "~":
+                    return KeyEvent(key=Key.BACKSPACE)
         return KeyEvent(key=Key.ESCAPE)
     if ch in ("\r", "\n"):
         # macOS Return sends ``\r``; cooked terminals translate it to ``\n``.

{otpilot-3.2.0 → otpilot-3.2.1}/src/otpilot/providers/imap/provider.py

@@ -228,7 +228,7 @@ class ImapProvider:
                         # Enter IDLE for up to _IDLE_REFRESH_SECONDS seconds.
                         try:
                             client.idle()
-                            responses = client.idle_check(timeout=_IDLE_REFRESH_SECONDS)
+                            client.idle_check(timeout=_IDLE_REFRESH_SECONDS)
                             client.idle_done()
                         except IMAP_OPERATION_ERRORS as exc:
                             logger.warning("IMAP IDLE: connection error during IDLE: %s", exc)

otpilot-3.2.1/tests/test_logging.py

@@ -0,0 +1,53 @@
+import logging
+
+from otpilot.infrastructure.logging.setup import RedactingFormatter, redact
+
+
+def test_redact_masks_secret_like_values() -> None:
+    assert "password=[REDACTED]" in redact("password=abc123")
+    assert "abc123" not in redact("password=abc123")
+
+
+def test_redact_handles_characters_in_secret_value() -> None:
+    # Regression test for BUG-01: r"([^\\\s]+)" previously stopped at 's' and backslash
+    result = redact("password=mysecret123")
+    assert result == "password=[REDACTED]"
+    assert "secret" not in result
+
+    result_app_pw = redact("app_password=super-secret-password-xyz")
+    assert result_app_pw == "app_password=[REDACTED]"
+    assert "super" not in result_app_pw
+    assert "secret" not in result_app_pw
+
+
+def test_redact_all_secret_keys() -> None:
+    for key in ("password", "app_password", "token", "secret", "credential"):
+        log_line = f"Connecting with {key}=supersecretval now"
+        redacted = redact(log_line)
+        assert f"{key}=[REDACTED]" in redacted
+        assert "supersecretval" not in redacted
+
+
+def test_redact_case_insensitive() -> None:
+    log_line = "PASSWORD=TopSecretValue and Token=AnotherSecret"
+    redacted = redact(log_line)
+    assert "PASSWORD=[REDACTED]" in redacted
+    assert "Token=[REDACTED]" in redacted
+    assert "TopSecretValue" not in redacted
+    assert "AnotherSecret" not in redacted
+
+
+def test_redacting_formatter_redacts_record() -> None:
+    formatter = RedactingFormatter("%(levelname)s: %(message)s")
+    record = logging.LogRecord(
+        name="test",
+        level=logging.INFO,
+        pathname="",
+        lineno=0,
+        msg="Login failed with app_password=my-super-secret-1234",
+        args=(),
+        exc_info=None,
+    )
+    formatted = formatter.format(record)
+    assert "app_password=[REDACTED]" in formatted
+    assert "my-super-secret-1234" not in formatted

{otpilot-3.2.0 → otpilot-3.2.1}/tests/test_watch.py

@@ -202,3 +202,57 @@ def test_idle_watch_falls_back_to_poll_when_no_idle_provider() -> None:
     svc = FakeFetchService([make_result("poll-msg"), make_result("poll-msg")], [])
     WatchService(svc, sleep=stop_after_first_poll).run()
     assert svc.copied == ["482731"]
+
+
+def test_watch_service_fields_initialization() -> None:
+    """Regression test for BUG-02: WatchService fields should be unique and properly initialized."""
+    import dataclasses
+    field_names = [f.name for f in dataclasses.fields(WatchService)]
+    assert len(field_names) == len(set(field_names)), "WatchService has duplicate fields"
+
+    provider = object()
+    account_id = AccountId("test@example.com")
+    svc = FakeFetchService([], [])
+    watch = WatchService(
+        fetch_service=svc,  # type: ignore[arg-type]
+        idle_provider=provider,
+        idle_account_id=account_id,
+        hotkey_enabled=False,
+    )
+    assert watch.idle_provider is provider
+    assert watch.idle_account_id == account_id
+
+
+def test_watch_service_hotkey_enabled(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Regression test: WatchService with hotkey_enabled=True runs HotkeyService without AttributeError."""
+    class FakeListener:
+        def __init__(self) -> None:
+            self.registered_hotkey: str | None = None
+            self.ran = False
+
+        def register(self, hotkey: str, callback: object) -> None:
+            self.registered_hotkey = hotkey
+
+        def run(self) -> None:
+            self.ran = True
+            raise KeyboardInterrupt
+
+        def shutdown(self) -> None:
+            pass
+
+    fake_listener = FakeListener()
+    monkeypatch.setattr("otpilot.infrastructure.hotkeys.PynputHotkeyListener", lambda: fake_listener)
+
+    class FakeFetchWithReady(FakeFetchService):
+        def validate_ready(self) -> None:
+            pass
+
+    svc = FakeFetchWithReady([], [])
+    watch = WatchService(
+        fetch_service=svc,  # type: ignore[arg-type]
+        hotkey_enabled=True,
+        hotkey="ctrl+alt+o",
+    )
+    watch.run()
+    assert fake_listener.ran is True
+    assert fake_listener.registered_hotkey == "ctrl+alt+o"

otpilot-3.2.0/tests/test_logging.py

@@ -1,7 +0,0 @@
-from otpilot.infrastructure.logging.setup import redact
-
-
-def test_redact_masks_secret_like_values() -> None:
-    assert "password=[REDACTED]" in redact("password=abc123")
-    assert "abc123" not in redact("password=abc123")
-