gmcli 0.1.0__tar.gz → 0.1.2__tar.gz

{gmcli-0.1.0 → gmcli-0.1.2}/CLAUDE.md

@@ -160,6 +160,16 @@ Consequences when editing `cli.py`:
   near the bottom, or its commands will not be guarded.
 - To signal a failure, `raise` the appropriate `GmcliError` subclass with a
   `hint=` — do not call `sys.exit` or print-and-return.
+- An **option callback** (`--version`, `--upgrade`, `--account`) runs *outside*
+  those wrappers, so it must `_report` and `raise typer.Exit(code=…)` itself.
+
+The root callback is `invoke_without_command=True`, so global options with no
+command reach `_no_command()` instead of stopping at Click's bare "Missing
+command.": it prints the same help bare `gmail` does and exits 2 — except
+under `--json`, where the help would land on the pipe, so the error goes to
+stderr instead. `_account_callback` rejects an `--account` value with no `@`
+in it, because the parser hands the option whatever token follows and
+`gmail --account -A` otherwise made `-A` the mailbox name.
 
 ### Two command registration styles
 
@@ -178,6 +188,14 @@ called at the *bottom* of `commands/auth.py` (`setup.py` imports nothing from
 `auth.py`, so there is no cycle). It also reorders itself to the front of the
 group's help, since it is where a new user starts.
 
+`commands/auth.py` uses *both* styles: its `app` group is added with
+`add_typer`, and its `register(root)` additionally attaches `gmail login` and
+`gmail logout` to the root app — the same two callbacks, not copies, so the
+short spellings cannot drift from `gmail auth login`/`logout`. Each
+registration gets its own `_guard` wrapper, which is all `cli.py` needs.
+`test_the_two_spellings_of_login_and_logout_cannot_drift` compares the two
+parameter lists.
+
 ### The `ui/` package
 
 Five modules, and the split is load-bearing:

{gmcli-0.1.0 → gmcli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gmcli
-Version: 0.1.0
+Version: 0.1.2
 Summary: Manage Gmail from the terminal: read, search, send, and organize mail over the Gmail API.
 Project-URL: Homepage, https://github.com/snehangshu2002/gmcli
 Project-URL: Issues, https://github.com/snehangshu2002/gmcli/issues
@@ -190,9 +190,17 @@ Then hand it over:
 $ gmail auth login --credentials ~/Downloads/client_secret_1234.json
 ```
 
-gmcli copies the file into its own data directory at mode `0600`, so later
+gmcli installs the file into its own data directory at mode `0600`, so later
 logins need no flag.
 
+A file that came out of `~/Downloads` or `~/Desktop` is **moved** rather than
+copied — the browser wrote a working OAuth client into a directory that syncs,
+backs up, and gets shared out of, and gmcli will not leave a second copy of it
+there. The destination is written first and the original removed only once that
+succeeded, so there is always at least one readable copy. Pass
+`--keep-download` to leave the file where it is; a client anywhere else is
+copied and never touched.
+
 </details>
 
 Check it worked:
@@ -568,12 +576,17 @@ Exit codes:
 
 ```console
 $ gmail auth setup                                      # once, first account
-$ gmail auth login                                      # repeat per account
+$ gmail login                                           # repeat per account
 $ gmail auth list
 $ gmail auth switch work@example.com                    # set the default
 $ gmail --account personal@gmail.com ls                 # override per command
+$ gmail logout                                          # forget this machine's copy
+$ gmail logout --all                                    # every account
 ```
 
+`gmail login` and `gmail logout` are the same commands as `gmail auth login`
+and `gmail auth logout`, spelled where you would first look for them.
+
 ## Configuration
 
 `~/.config/gmcli/config.toml` (XDG-aware):

{gmcli-0.1.0 → gmcli-0.1.2}/README.md

@@ -153,9 +153,17 @@ Then hand it over:
 $ gmail auth login --credentials ~/Downloads/client_secret_1234.json
 ```
 
-gmcli copies the file into its own data directory at mode `0600`, so later
+gmcli installs the file into its own data directory at mode `0600`, so later
 logins need no flag.
 
+A file that came out of `~/Downloads` or `~/Desktop` is **moved** rather than
+copied — the browser wrote a working OAuth client into a directory that syncs,
+backs up, and gets shared out of, and gmcli will not leave a second copy of it
+there. The destination is written first and the original removed only once that
+succeeded, so there is always at least one readable copy. Pass
+`--keep-download` to leave the file where it is; a client anywhere else is
+copied and never touched.
+
 </details>
 
 Check it worked:
@@ -531,12 +539,17 @@ Exit codes:
 
 ```console
 $ gmail auth setup                                      # once, first account
-$ gmail auth login                                      # repeat per account
+$ gmail login                                           # repeat per account
 $ gmail auth list
 $ gmail auth switch work@example.com                    # set the default
 $ gmail --account personal@gmail.com ls                 # override per command
+$ gmail logout                                          # forget this machine's copy
+$ gmail logout --all                                    # every account
 ```
 
+`gmail login` and `gmail logout` are the same commands as `gmail auth login`
+and `gmail auth logout`, spelled where you would first look for them.
+
 ## Configuration
 
 `~/.config/gmcli/config.toml` (XDG-aware):

{gmcli-0.1.0 → gmcli-0.1.2}/src/gmcli/__init__.py

@@ -1,5 +1,5 @@
 """gmcli — manage Gmail from the terminal."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 
 __all__ = ["__version__"]

{gmcli-0.1.0 → gmcli-0.1.2}/src/gmcli/auth/flow.py

@@ -14,10 +14,16 @@ from __future__ import annotations
 
 import json
 import time
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from ..config import client_secret_path, write_secret_file
+from ..config import (
+    DOWNLOAD_DIRS,
+    client_secret_path,
+    is_in_download_dir,
+    write_secret_file,
+)
 from ..errors import AuthError
 from .client_config import ClientConfig, parse_client_file, resolve_client
 from .store import TokenStore, get_store, register_account
@@ -37,12 +43,37 @@ PUBLISHING_STATUS_HINT = (
 )
 
 
-def install_client_secret(source: Path) -> Path:
-    """Copy the user's OAuth client into our data dir so later logins are flagless.
+@dataclass(frozen=True)
+class Installed:
+    """Where the client went, and what happened to the file it came from."""
+
+    path: Path
+    source: Path
+    moved: bool = False
+    #: Set when the source was in a download directory but could not be removed.
+    left_behind: str | None = None
+
+    def __fspath__(self) -> str:
+        """So an ``Installed`` is still usable anywhere the path was."""
+        return str(self.path)
+
+
+def install_client_secret(source: Path, *, keep_source: bool = False) -> Installed:
+    """Install the user's OAuth client into our data dir, at ``0600``.
 
     Validation goes through the same parser the resolver uses, so a web client
     or a service-account key is rejected here with the same explanation rather
     than failing later inside the consent flow.
+
+    A client that came out of a download directory is *moved* rather than
+    copied: the browser wrote it world-readable into a directory that syncs,
+    backs up, and gets shared out of, and a copy left there is a live
+    credential nobody is looking after. It is safe to lose because it is not
+    lost — the destination is written and fsynced-into-place first, and the
+    source is only unlinked once that has succeeded, so a failure at any point
+    leaves at least one readable copy. Anywhere else the file is left exactly
+    where it is: a path the user typed or keeps in a repo is a path they
+    chose, and deleting it would be a surprise rather than a tidy-up.
     """
     source = source.expanduser()
     if not source.exists():
@@ -59,7 +90,80 @@ def install_client_secret(source: Path) -> Path:
 
     dest = client_secret_path()
     write_secret_file(dest, json.dumps(payload, indent=2))
-    return dest
+
+    if keep_source or not is_in_download_dir(source) or source.resolve() == dest:
+        return Installed(path=dest, source=source)
+    try:
+        source.unlink()
+    except OSError as exc:
+        # Not fatal: the client is installed and works. Say so, because the
+        # whole point was that the copy in Downloads should stop existing.
+        return Installed(path=dest, source=source, left_behind=str(exc))
+    return Installed(path=dest, source=source, moved=True)
+
+
+def install_notes(installed: "Installed", client_id: str) -> list[tuple[str, str]]:
+    """What a front end should say after an install, as ``(level, message)``.
+
+    The text lives here rather than in the commands because both ``auth login``
+    and ``auth setup`` install a client and must say the same thing about it;
+    the levels keep ``output.py`` in charge of how it looks.
+    """
+    notes: list[tuple[str, str]] = []
+    if installed.moved:
+        notes.append(
+            (
+                "info",
+                f"Moved {installed.source} out of your downloads — "
+                f"it now lives only at {installed.path} (0600).",
+            )
+        )
+    elif installed.left_behind:
+        notes.append(
+            (
+                "warn",
+                f"Could not remove {installed.source} ({installed.left_behind}). "
+                "It is a working OAuth client — delete it yourself.",
+            )
+        )
+
+    leftovers = [
+        p for p in other_downloaded_copies(client_id) if p != installed.source
+    ]
+    if leftovers:
+        listed = ", ".join(str(p) for p in leftovers)
+        notes.append(
+            (
+                "warn",
+                f"Another copy of this same client is still in your downloads: "
+                f"{listed}. gmcli will not delete a file it was not given.",
+            )
+        )
+    return notes
+
+
+def other_downloaded_copies(client_id: str) -> list[Path]:
+    """Client files in the download directories carrying this same client id.
+
+    Re-downloading gives you ``client_secret_… (1).json`` next to the original,
+    and moving one of them out solves nothing while its twin is still there.
+    These are only reported, never removed: gmcli takes responsibility for the
+    file it was handed, not for tidying a directory it does not own.
+    """
+    found: list[Path] = []
+    for name in DOWNLOAD_DIRS:
+        base = Path(name).expanduser()
+        if not base.is_dir():
+            continue
+        for path in sorted(base.glob("client_secret*.json")):
+            try:
+                payload = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                continue
+            block = payload.get("installed")
+            if isinstance(block, dict) and block.get("client_id") == client_id:
+                found.append(path)
+    return found
 
 
 def _serialize(creds: Any, account: str) -> dict[str, Any]:
@@ -226,10 +330,13 @@ __all__ = [
     "PUBLISHING_STATUS_HINT",
     "SCOPES",
     "TESTING_TOKEN_LIFETIME_DAYS",
+    "Installed",
     "fetch_account_email",
     "install_client_secret",
+    "install_notes",
     "load_credentials",
     "login",
     "logout",
+    "other_downloaded_copies",
     "token_age_days",
 ]

{gmcli-0.1.0 → gmcli-0.1.2}/src/gmcli/cli.py

@@ -19,7 +19,7 @@ from .commands import listing, modify, read, send
 from .commands import ui_cmd
 from .config import Config
 from .context import AppContext
-from .errors import GmcliError
+from .errors import GmcliError, UsageError
 
 app = typer.Typer(
     name="gmail",
@@ -45,6 +45,7 @@ app.add_typer(draft_cmd.app, name="draft")
 app.add_typer(attachments_cmd.app, name="attachments")
 app.add_typer(cache_cmd.app, name="cache")
 
+auth_cmd.register(app)
 listing.register(app)
 read.register(app)
 modify.register(app)
@@ -105,6 +106,50 @@ def _version_callback(value: bool) -> None:
         raise typer.Exit()
 
 
+def _account_callback(value: str | None) -> str | None:
+    """Reject an ``--account`` value that cannot be an address.
+
+    ``gmail --account -A`` is the shape that motivates this: the parser hands
+    the option whatever token comes next, so a mistyped flag became the
+    mailbox name and the mistake surfaced much later — as a missing-credential
+    error naming ``-A``, or not at all on a command that never opens the
+    account. An option callback runs outside the wrappers installed below, so
+    it maps itself onto the documented usage exit code.
+    """
+    if value is None:
+        return None
+    if "@" not in value:
+        exc = UsageError(
+            f"--account expects an email address, not {value!r}.",
+            hint="`gmail auth list` shows the accounts you are logged in to.",
+        )
+        _report(exc)
+        raise typer.Exit(code=exc.exit_code)
+    return value
+
+
+def _no_command(ctx: typer.Context, json_mode: bool) -> None:
+    """Handle global options given with no command to run.
+
+    ``gmail --json`` used to stop at a bare "Missing command.", which names
+    the problem and nothing else. Bare ``gmail`` already answers it by
+    printing the help, so do the same here — the flags are the front half of a
+    command the user has not finished typing. Under ``--json`` the help would
+    land on the pipe, so that case gets the error on stderr instead.
+    """
+    if json_mode:
+        _report(
+            UsageError(
+                "No command given.",
+                hint="Run `gmail --help` to see the commands.",
+            )
+        )
+    else:
+        # Typer renders the help itself and returns an empty string.
+        ctx.get_help()
+    raise typer.Exit(code=2)
+
+
 def _upgrade_callback(value: bool) -> None:
     """``gmail --upgrade``: fetch the current release and install it.
 
@@ -151,7 +196,7 @@ def _announce_update(ctx: typer.Context) -> None:
     update.start_check(app_ctx.config)
 
 
-@app.callback()
+@app.callback(invoke_without_command=True)
 def main_callback(
     ctx: typer.Context,
     account: str = typer.Option(
@@ -160,6 +205,7 @@ def main_callback(
         "-A",
         help="Act on this account instead of the default.",
         metavar="EMAIL",
+        callback=_account_callback,
     ),
     json_output: bool = typer.Option(
         False,
@@ -189,6 +235,9 @@ def main_callback(
     ),
 ) -> None:
     """Manage Gmail from the terminal."""
+    if ctx.invoked_subcommand is None:
+        _no_command(ctx, json_output)
+
     config = Config.load()
     ctx.obj = AppContext(
         account_override=account,

{gmcli-0.1.0 → gmcli-0.1.2}/src/gmcli/commands/auth.py

@@ -1,4 +1,10 @@
-"""``gmail auth …`` — login, logout, account switching, and diagnostics."""
+"""``gmail auth …`` — login, logout, account switching, and diagnostics.
+
+``gmail login`` and ``gmail logout`` are the same two commands attached to the
+root app as well, by :func:`register`: getting in and out is the pair of verbs
+a user reaches for before they know the group exists, and it costs nothing to
+answer where they look for it.
+"""
 
 from __future__ import annotations
 
@@ -11,6 +17,8 @@ from ..auth.flow import (
     PUBLISHING_STATUS_HINT,
     SCOPES,
     TESTING_TOKEN_LIFETIME_DAYS,
+    install_client_secret,
+    install_notes,
     load_credentials,
     login,
     logout,
@@ -54,6 +62,12 @@ def login_cmd(
         help="Fix the loopback redirect port (useful over an SSH tunnel). "
         "0 picks a free one.",
     ),
+    keep_download: bool = typer.Option(
+        False,
+        "--keep-download",
+        help="Leave the credentials file where it is. By default a client "
+        "found in ~/Downloads or ~/Desktop is moved, not copied.",
+    ),
 ) -> None:
     """Authorize an account through your browser."""
     app_ctx: AppContext = ctx.obj
@@ -63,9 +77,15 @@ def login_cmd(
     # like a crash rather than a missing prerequisite.
     resolve_client(credentials, config=app_ctx.config)
 
+    # Install here rather than inside `login`, so the file is safe before the
+    # browser opens and this command has something to report about it.
+    installed = None
+    if credentials is not None:
+        installed = install_client_secret(credentials, keep_source=keep_download)
+
     out.info("Opening your browser to authorize gmcli…")
     out.info(f"[dim]Requesting scope: {SCOPES[0]}[/dim]")
-    email, store, client = login(credentials=credentials, port=port)
+    email, store, client = login(port=port)
 
     if app_ctx.json_mode:
         out.json(
@@ -80,6 +100,9 @@ def login_cmd(
 
     out.success(f"Authorized as [bold]{email}[/bold]")
     out.info(f"[dim]Credentials stored in {store.description}[/dim]")
+    if installed is not None:
+        for level, message in install_notes(installed, client.client_id):
+            (out.warn if level == "warn" else out.info)(message)
 
     if not app_ctx.config.default_account:
         app_ctx.config.default_account = email
@@ -400,6 +423,25 @@ def _clock_skew_seconds() -> float | None:
         return None
 
 
+def register(root: typer.Typer) -> None:
+    """Attach ``gmail login`` / ``gmail logout`` to the root app.
+
+    The same callbacks, not copies, so the two spellings can never drift in
+    flags or behaviour — each registration carries its own error-handling
+    wrapper, which is all ``cli.py`` needs.
+    """
+    root.command(
+        "login",
+        help="Authorize an account through your browser. "
+        "Same as [bold]gmail auth login[/bold].",
+    )(login_cmd)
+    root.command(
+        "logout",
+        help="Remove stored credentials from this machine. "
+        "Same as [bold]gmail auth logout[/bold].",
+    )(logout_cmd)
+
+
 # Registered here rather than in cli.py so the wizard travels with the group it
 # belongs to. setup.py imports nothing from this module, so there is no cycle.
 from .setup import register as _register_setup  # noqa: E402

{gmcli-0.1.0 → gmcli-0.1.2}/src/gmcli/commands/setup.py

@@ -25,16 +25,19 @@ from pathlib import Path
 import typer
 
 from ..auth.client_config import load_client_file
-from ..auth.flow import install_client_secret, login
-from ..config import client_secret_path
+from ..auth.flow import install_client_secret, install_notes, login
+from ..config import DOWNLOAD_DIRS as BROWSER_DOWNLOAD_DIRS
+from ..config import client_secret_path, is_in_download_dir
 from ..context import AppContext
 from ..errors import AuthError, UsageError
 from ..output import Renderer
 
 CONSOLE = "https://console.cloud.google.com"
 
-# Where browsers land a downloaded client, newest first wins.
-DOWNLOAD_DIRS = ("~/Downloads", "~/Desktop", ".")
+# Where browsers land a downloaded client, newest first wins. The current
+# directory is searched but is not one of ``config.DOWNLOAD_DIRS``: a file
+# someone ran the command next to is not in transit, so it is never moved.
+DOWNLOAD_DIRS = (*BROWSER_DOWNLOAD_DIRS, ".")
 DOWNLOAD_GLOBS = ("client_secret*.json", "client_secret*.JSON")
 # A file touched within this window is almost certainly the one just downloaded.
 FRESH_SECONDS = 1800
@@ -129,6 +132,12 @@ def _collect_client_file(out: Renderer) -> Path:
         if candidates:
             best = candidates[0]
             out.info(f"\n  Found [green]{best}[/green]")
+            if is_in_download_dir(best):
+                out.info(
+                    "  [dim]It will be moved into gmcli's data directory, not "
+                    "copied — an OAuth client should not be left in a download "
+                    "folder. Re-run with --keep-download to leave it.[/dim]"
+                )
             if typer.confirm("  Use this file?", default=True):
                 return best
 
@@ -179,6 +188,12 @@ def register(auth_app: typer.Typer) -> None:
         force: bool = typer.Option(
             False, "--force", "-f", help="Replace an already-installed client."
         ),
+        keep_download: bool = typer.Option(
+            False,
+            "--keep-download",
+            help="Leave the downloaded client JSON in place. By default it is "
+            "moved out of ~/Downloads rather than copied.",
+        ),
     ) -> None:
         """Set up Google sign-in, step by step.
 
@@ -191,8 +206,9 @@ def register(auth_app: typer.Typer) -> None:
 
         # The fast path: a file was handed to us, so no walkthrough is needed.
         if credentials is not None:
-            install_client_secret(credentials)
+            installed = install_client_secret(credentials, keep_source=keep_download)
             out.success(f"Installed OAuth client from {credentials}")
+            _report_install(out, installed)
             _finish_with_login(app_ctx, no_browser=no_browser)
             return
 
@@ -226,9 +242,10 @@ def register(auth_app: typer.Typer) -> None:
         _step_create_client(out, project, total, no_browser)
 
         path = _collect_client_file(out)
-        install_client_secret(path)
+        installed = install_client_secret(path, keep_source=keep_download)
         client = load_client_file(client_secret_path())
         out.success(f"OAuth client installed ({client.client_id[:24]}…)")
+        _report_install(out, installed, client_id=client.client_id)
 
         _finish_with_login(app_ctx, no_browser=no_browser)
 
@@ -237,6 +254,18 @@ def register(auth_app: typer.Typer) -> None:
     auth_app.registered_commands.insert(0, auth_app.registered_commands.pop())
 
 
+def _report_install(out: Renderer, installed, client_id: str | None = None) -> None:
+    """Say what became of the file the client came from.
+
+    The user handed a path to a file they can see; if gmcli deleted it, that
+    has to be stated rather than discovered.
+    """
+    if client_id is None:
+        client_id = load_client_file(client_secret_path()).client_id
+    for level, message in install_notes(installed, client_id):
+        (out.warn if level == "warn" else out.info)(message)
+
+
 def _intro(out: Renderer) -> None:
     out.info(
         "\n[bold]Setting up Google sign-in for gmcli[/bold]\n\n"

{gmcli-0.1.0 → gmcli-0.1.2}/src/gmcli/config.py

@@ -30,6 +30,31 @@ SECRET_MODE = 0o600
 SECRET_DIR_MODE = 0o700
 
 
+# Where a browser lands a file. These are transit, not storage: nothing in
+# them is where the user meant to keep it, and a directory every download in
+# the world passes through is the wrong home for an OAuth client. Anything
+# gmcli installs from here it takes *out* of here — see
+# ``auth/flow.py:install_client_secret``. The current directory is
+# deliberately absent: setup looks there for a downloaded client, but a file
+# someone chose to run the command next to is not in transit.
+DOWNLOAD_DIRS = ("~/Downloads", "~/Desktop")
+
+
+def is_in_download_dir(path: Path) -> bool:
+    """Whether ``path`` sits directly in a browser's download directory."""
+    try:
+        parent = path.expanduser().resolve().parent
+    except OSError:  # pragma: no cover - unresolvable path
+        return False
+    for name in DOWNLOAD_DIRS:
+        try:
+            if parent == Path(name).expanduser().resolve():
+                return True
+        except OSError:  # pragma: no cover - unresolvable path
+            continue
+    return False
+
+
 def config_dir() -> Path:
     return Path(platformdirs.user_config_dir(APP_NAME))
 

{gmcli-0.1.0 → gmcli-0.1.2}/src/gmcli/ui/app.py

@@ -427,8 +427,18 @@ class MailApp:
         if outcome == "cancel":
             self.state.note("Cancelled")
             return
-        if handler is not None:
+        if handler is None:
+            return
+        try:
             handler(editor.text.strip())
+        except GmcliError as exc:
+            # Same contract as ``busy()``: a prompt handler runs on the key
+            # that submitted it, so anything escaping here would take the
+            # session down over one mistyped line.
+            detail = f"{exc.message} {exc.hint or ''}".strip()
+            self.state.note(detail, render.THEME["error"])
+        except Exception as exc:  # noqa: BLE001 — a UI must not die on one bad line
+            self.state.note(f"{type(exc).__name__}: {exc}", render.THEME["error"])
 
     def confirm(self, question: str, action: Callable[[], None]) -> None:
         """Ask for a y/n on the status line before doing something."""
@@ -1011,6 +1021,57 @@ class MailApp:
                 self.state.note(exc.message, render.THEME["warn"])
         return body
 
+    def _ask_recipients(
+        self,
+        label: str,
+        then: Callable[[list[str]], None],
+        *,
+        initial: str = "",
+        empty_note: str,
+        retry: bool = False,
+    ) -> None:
+        """Prompt for addresses, and ask again if what came back is not one.
+
+        A typo in a footer prompt is the most ordinary thing a user can do, so
+        it must cost them the typo and nothing else. ``validate_addresses``
+        raises, and a prompt handler runs on the key that submitted it — so
+        letting that escape would end the session and lose the draft. The
+        complaint goes in the *label*: while a prompt is open it is what the
+        footer shows, and the status line is not on screen to read.
+        """
+
+        def handler(text: str) -> None:
+            if not text:
+                # An empty line is how you back out, and the one case that is
+                # not a typo to correct.
+                self.state.note(empty_note, render.THEME["warn"])
+                return
+            try:
+                recipients = compose.validate_addresses(
+                    compose.split_addresses([text]), field="to"
+                )
+            except GmcliError as exc:
+                self.state.note(exc.message, render.THEME["error"])
+                recipients = []
+            if not recipients:
+                # ``split_addresses`` drops some malformed input outright
+                # rather than raising — ``bob@`` parses to nothing at all —
+                # so an empty result off a non-empty line is a typo too.
+                self._ask_recipients(
+                    label,
+                    then,
+                    initial=text,
+                    empty_note=empty_note,
+                    retry=True,
+                )
+                return
+            then(recipients)
+
+        # The complaint prefixes the label rather than replacing it, and the
+        # unprefixed label is what recurses — two typos in a row must not read
+        # "not an address — not an address — to: ".
+        self.ask(f"not an address — {label}" if retry else label, handler, initial)
+
     def _send(self, message, *, thread_id: str | None, verb: str) -> None:
         summary = compose.describe(message)
 
@@ -1052,13 +1113,7 @@ class MailApp:
         if parent is None:
             return
 
-        def with_recipients(text: str) -> None:
-            recipients = compose.validate_addresses(
-                compose.split_addresses([text]), field="to"
-            )
-            if not recipients:
-                self.state.note("No recipients — nothing forwarded", render.THEME["warn"])
-                return
+        def with_recipients(recipients: list[str]) -> None:
             body = self._edit(_header_stub(recipients, [],
                                            compose.forward_subject(parent.subject)))
             with self.busy("Building forward"):
@@ -1067,17 +1122,14 @@ class MailApp:
                 )
                 self._send(message, thread_id=None, verb="Forwarded")
 
-        self.ask("forward to: ", with_recipients)
+        self._ask_recipients(
+            "forward to: ",
+            with_recipients,
+            empty_note="No recipients — nothing forwarded",
+        )
 
     def compose_new(self) -> None:
-        def with_recipients(text: str) -> None:
-            recipients = compose.validate_addresses(
-                compose.split_addresses([text]), field="to"
-            )
-            if not recipients:
-                self.state.note("No recipients — nothing sent", render.THEME["warn"])
-                return
-
+        def with_recipients(recipients: list[str]) -> None:
             def with_subject(subject: str) -> None:
                 body = self._edit(_header_stub(recipients, [], subject))
                 if not body:
@@ -1096,7 +1148,9 @@ class MailApp:
 
             self.ask("subject: ", with_subject)
 
-        self.ask("to: ", with_recipients)
+        self._ask_recipients(
+            "to: ", with_recipients, empty_note="No recipients — nothing sent"
+        )
 
 
 def _select_attachments(

{gmcli-0.1.0 → gmcli-0.1.2}/tests/conftest.py

@@ -203,4 +203,9 @@ def isolated_dirs(tmp_path, monkeypatch):
         monkeypatch.setenv(var, str(target))
     # Never let a test reach the developer's real keyring.
     monkeypatch.setenv("GMCLI_TOKEN_STORE", "file")
+    # …nor their real home. `~/Downloads` is a path gmcli both reads and
+    # *deletes from* (see `auth/flow.py:install_client_secret`), and it does
+    # not come from XDG, so redirecting HOME is the only thing between the
+    # suite and a developer's actual download folder.
+    monkeypatch.setenv("HOME", str(tmp_path))
     return tmp_path

{gmcli-0.1.0 → gmcli-0.1.2}/tests/test_client_config.py

@@ -8,7 +8,7 @@ import time
 import pytest
 
 from gmcli.auth import client_config as cc
-from gmcli.config import Config, client_secret_path
+from gmcli.config import Config, client_secret_path, is_in_download_dir
 from gmcli.errors import AuthError
 
 
@@ -233,3 +233,126 @@ def test_unrelated_files_are_not_picked_up(tmp_path, monkeypatch):
 
     monkeypatch.setattr(setup, "DOWNLOAD_DIRS", (str(downloads),))
     assert setup.find_downloaded_client() == []
+
+
+# -- a downloaded client is moved, not copied --------------------------------
+
+
+def downloaded(tmp_path, payload: dict | None = None, name: str = "client_secret_1.json"):
+    """A client JSON sitting in ``~/Downloads``, as a browser would leave it."""
+    downloads = tmp_path / "Downloads"
+    downloads.mkdir(exist_ok=True)
+    path = downloads / name
+    path.write_text(json.dumps(payload or desktop_payload()), encoding="utf-8")
+    return path
+
+
+def test_a_client_in_downloads_is_moved_out_of_it(isolated_dirs):
+    from gmcli.auth import flow
+
+    source = downloaded(isolated_dirs)
+    result = flow.install_client_secret(source)
+
+    assert result.moved is True
+    assert not source.exists()  # the browser's copy is gone
+    assert client_secret_path().exists()
+    assert cc.load_client_file(client_secret_path()).client_secret == "shh"
+
+
+def test_the_installed_copy_is_private(isolated_dirs):
+    from gmcli.auth import flow
+
+    flow.install_client_secret(downloaded(isolated_dirs))
+    assert client_secret_path().stat().st_mode & 0o777 == 0o600
+
+
+def test_a_client_kept_elsewhere_is_only_copied(isolated_dirs, tmp_path):
+    """A path someone chose is a path they meant; deleting it is a surprise."""
+    from gmcli.auth import flow
+
+    kept = tmp_path / "dotfiles" / "client.json"
+    kept.parent.mkdir()
+    kept.write_text(json.dumps(desktop_payload()), encoding="utf-8")
+
+    result = flow.install_client_secret(kept)
+    assert result.moved is False
+    assert kept.exists()
+    assert client_secret_path().exists()
+
+
+def test_keep_source_leaves_the_download_alone(isolated_dirs):
+    from gmcli.auth import flow
+
+    source = downloaded(isolated_dirs)
+    result = flow.install_client_secret(source, keep_source=True)
+    assert result.moved is False
+    assert source.exists()
+    assert client_secret_path().exists()
+
+
+def test_an_invalid_client_is_rejected_before_anything_is_deleted(isolated_dirs):
+    """Nothing is removed on a path that never installed anything."""
+    from gmcli.auth import flow
+
+    source = downloaded(isolated_dirs, {"web": {"client_id": "x"}})
+    with pytest.raises(AuthError):
+        flow.install_client_secret(source)
+    assert source.exists()
+    assert not client_secret_path().exists()
+
+
+def test_an_unremovable_download_is_reported_not_swallowed(isolated_dirs, monkeypatch):
+    """The client still installs; the point is that the user is told."""
+    from gmcli.auth import flow
+
+    source = downloaded(isolated_dirs)
+
+    def refuse(self):
+        raise OSError("Permission denied")
+
+    monkeypatch.setattr("pathlib.Path.unlink", refuse)
+    result = flow.install_client_secret(source)
+
+    assert result.moved is False
+    assert result.left_behind == "Permission denied"
+    assert client_secret_path().exists()
+    levels = [level for level, _ in flow.install_notes(result, "111-abc")]
+    assert "warn" in levels
+
+
+def test_a_second_copy_of_the_same_client_is_reported(isolated_dirs):
+    """Browsers name a re-download `… (1).json`, and one left behind is the
+    same live credential the move was meant to get rid of."""
+    from gmcli.auth import flow
+
+    twin = downloaded(isolated_dirs, name="client_secret_1 (1).json")
+    source = downloaded(isolated_dirs)
+
+    result = flow.install_client_secret(source)
+    notes = flow.install_notes(result, "111-abc.apps.googleusercontent.com")
+
+    assert twin.exists()  # reported, never deleted
+    assert any(level == "warn" and str(twin) in text for level, text in notes)
+
+
+def test_a_different_client_in_downloads_is_not_mentioned(isolated_dirs):
+    from gmcli.auth import flow
+
+    other = downloaded(
+        isolated_dirs,
+        desktop_payload("999-zzz.apps.googleusercontent.com"),
+        name="client_secret_other.json",
+    )
+    result = flow.install_client_secret(downloaded(isolated_dirs))
+    notes = flow.install_notes(result, "111-abc.apps.googleusercontent.com")
+
+    assert other.exists()
+    assert not any(str(other) in text for _, text in notes)
+
+
+def test_the_current_directory_is_not_a_download_folder(isolated_dirs, tmp_path):
+    """`.` is searched for a client but never emptied of one."""
+    from gmcli.commands import setup
+
+    assert "." in setup.DOWNLOAD_DIRS
+    assert not is_in_download_dir(tmp_path / "here" / "client_secret.json")

{gmcli-0.1.0 → gmcli-0.1.2}/tests/test_commands.py

@@ -566,6 +566,35 @@ def test_version():
     assert "gmcli" in result.output
 
 
+def test_global_options_with_no_command_show_the_help(env):
+    """A bare "Missing command." names the problem and nothing else."""
+    result = invoke("--quiet")
+    assert result.exit_code == 2
+    assert "Usage:" in result.output
+    assert "login" in result.output
+
+
+def test_no_command_under_json_keeps_stdout_empty(env):
+    """The help would land on the pipe, so the error goes to stderr instead."""
+    result = invoke("--json")
+    assert result.exit_code == 2
+    assert result.stdout == ""
+    assert "No command given" in result.output
+
+
+def test_a_mistyped_flag_is_not_taken_as_an_account(env):
+    """`--account -A` used to make "-A" the mailbox and fail much later."""
+    result = invoke("--account", "-A", "ls")
+    assert result.exit_code == 2
+    assert "email address" in result.output
+    assert not env.calls
+
+
+def test_account_still_accepts_an_address(env):
+    seed_threads(env)
+    assert invoke("--account", ACCOUNT, "ls").exit_code == 0
+
+
 def test_cache_clear(env):
     seed_threads(env)
     invoke("ls")
@@ -617,6 +646,86 @@ def fake_login(monkeypatch):
     return calls
 
 
+@pytest.fixture
+def fake_auth_login(monkeypatch):
+    """Stub the consent flow for `auth login`, as ``fake_login`` does for setup."""
+    from gmcli.auth.client_config import ClientConfig
+    from gmcli.auth.store import FileStore
+    from gmcli.commands import auth as auth_mod
+
+    calls = []
+
+    def _login(**kwargs):
+        calls.append(kwargs)
+        store = FileStore()
+        store.save(ACCOUNT, {"token": "t", "refresh_token": "r"})
+        return ACCOUNT, store, ClientConfig(
+            "999-xyz.apps.googleusercontent.com", "shh", "installed client"
+        )
+
+    monkeypatch.setattr(auth_mod, "login", _login)
+    return calls
+
+
+def test_login_moves_a_downloaded_client_out_of_downloads(
+    isolated_dirs, tmp_path, fake_auth_login
+):
+    from gmcli.config import client_secret_path
+
+    downloads = tmp_path / "Downloads"
+    downloads.mkdir()
+    path = desktop_client_file(downloads)
+
+    result = invoke("auth", "login", "--credentials", str(path))
+
+    assert result.exit_code == 0, result.output
+    assert not path.exists()
+    assert client_secret_path().exists()
+    assert "Moved" in result.output
+
+
+def test_login_can_be_told_to_leave_the_download(
+    isolated_dirs, tmp_path, fake_auth_login
+):
+    downloads = tmp_path / "Downloads"
+    downloads.mkdir()
+    path = desktop_client_file(downloads)
+
+    invoke("auth", "login", "--credentials", str(path), "--keep-download")
+    assert path.exists()
+
+
+def test_logout_is_reachable_without_the_auth_group(env):
+    from gmcli.auth.store import list_accounts
+
+    result = invoke("logout")
+    assert result.exit_code == 0, result.output
+    assert list_accounts() == []
+
+
+def test_login_is_reachable_without_the_auth_group(
+    isolated_dirs, tmp_path, fake_auth_login
+):
+    path = desktop_client_file(tmp_path)
+    result = invoke("login", "--credentials", str(path))
+
+    assert result.exit_code == 0, result.output
+    assert fake_auth_login, "the consent flow was never reached"
+    assert ACCOUNT in result.output
+
+
+def test_the_two_spellings_of_login_and_logout_cannot_drift():
+    """`gmail login` is the same command object as `gmail auth login`."""
+    import typer.main
+
+    root = typer.main.get_command(app)
+    auth_group = root.get_command(None, "auth")
+    for name in ("login", "logout"):
+        top = root.get_command(None, name)
+        grouped = auth_group.get_command(None, name)
+        assert [p.opts for p in top.params] == [p.opts for p in grouped.params]
+
+
 def test_setup_is_registered(env):
     result = invoke("auth", "setup", "--help")
     assert result.exit_code == 0
@@ -647,6 +756,41 @@ def test_setup_installs_the_client_for_later_logins(
     assert resolve_client().client_id == "999-xyz.apps.googleusercontent.com"
 
 
+def test_setup_moves_a_downloaded_client_out_of_downloads(
+    isolated_dirs, tmp_path, fake_login
+):
+    """The whole point: after setup, no OAuth client is left in ~/Downloads."""
+    from gmcli.config import client_secret_path
+
+    downloads = tmp_path / "Downloads"
+    downloads.mkdir()
+    path = desktop_client_file(downloads)
+
+    result = invoke("auth", "setup", "--credentials", str(path))
+
+    assert result.exit_code == 0, result.output
+    assert not path.exists()
+    assert client_secret_path().exists()
+    assert "Moved" in result.output
+
+
+def test_setup_can_be_told_to_leave_the_download(isolated_dirs, tmp_path, fake_login):
+    downloads = tmp_path / "Downloads"
+    downloads.mkdir()
+    path = desktop_client_file(downloads)
+
+    invoke("auth", "setup", "--credentials", str(path), "--keep-download")
+    assert path.exists()
+
+
+def test_setup_does_not_delete_a_client_kept_elsewhere(
+    isolated_dirs, tmp_path, fake_login
+):
+    path = desktop_client_file(tmp_path)
+    invoke("auth", "setup", "--credentials", str(path))
+    assert path.exists()
+
+
 def test_setup_sets_the_default_account(isolated_dirs, tmp_path, fake_login):
     from gmcli.config import Config
 

{gmcli-0.1.0 → gmcli-0.1.2}/tests/test_ui.py

@@ -1526,3 +1526,77 @@ def test_the_reader_surface_reaches_the_right_hand_edge(ctx):
     press(ui, "enter")
     for line in render.reader(ui.state, 100, 25):
         assert str(render.exact(line, 100).style) == render.THEME["page"]
+
+
+# -- composing ----------------------------------------------------------------
+
+
+def test_a_mistyped_address_asks_again_instead_of_ending_the_session(ctx):
+    """The most ordinary mistake there is must cost the typo and nothing else."""
+    ui = build(ctx, [])
+    press(ui, "c")
+    type_in(ui, "snehangshubhuin2018")
+    assert ui.state.quit is False
+    assert ui.state.prompt is not None  # still asking, not gone
+    assert "not an address" in ui.state.prompt.label
+    assert "to: " in ui.state.prompt.label
+
+
+def test_two_typos_in_a_row_do_not_stack_the_complaint(ctx):
+    ui = build(ctx, [])
+    press(ui, "c")
+    type_in(ui, "nonsense")
+    type_in(ui, "still nonsense")
+    assert ui.state.prompt.label == "not an address — to: "
+
+
+def test_the_rejected_text_comes_back_to_be_edited(ctx):
+    """Re-typing a whole address to fix one missing character is a punishment."""
+    ui = build(ctx, [])
+    press(ui, "c")
+    type_in(ui, "bob@")
+    assert ui.state.prompt.text == "bob@"
+    assert ui.state.prompt.cursor == len("bob@")
+
+
+def test_a_corrected_address_carries_on_to_the_subject(ctx):
+    ui = build(ctx, [])
+    press(ui, "c")
+    type_in(ui, "nonsense")
+    type_in(ui, "bob@example.com")
+    assert ui.state.prompt is not None
+    assert ui.state.prompt.label == "subject: "
+
+
+def test_an_empty_recipient_list_abandons_rather_than_re_asking(ctx):
+    """Submitting nothing is how you back out; it is not a typo to correct."""
+    ui = build(ctx, [])
+    press(ui, "c")
+    type_in(ui, "")
+    assert ui.state.prompt is None
+    assert ui.state.status_style == render.THEME["warn"]
+    assert ui.state.quit is False
+
+
+def test_forwarding_to_a_bad_address_also_asks_again(ctx):
+    ui = build(ctx, [])
+    press(ui, "enter", "f")
+    type_in(ui, "not-an-address")
+    assert ui.state.quit is False
+    assert "forward to: " in ui.state.prompt.label
+
+
+def test_a_prompt_handler_that_raises_lands_on_the_status_line(ctx):
+    """The same contract as ``busy()``, for the keys that submit a prompt."""
+    from gmcli.errors import UsageError
+
+    ui = build(ctx, [])
+
+    def explode(_text: str) -> None:
+        raise UsageError("nope", hint="try that again")
+
+    ui.ask("thing: ", explode)
+    press(ui, "x", "enter")
+    assert ui.state.quit is False
+    assert ui.state.status_style == render.THEME["error"]
+    assert "nope" in ui.state.status