monolynx-cli 0.1.0__py3-none-any.whl

monolynx_cli/__init__.py

@@ -0,0 +1,11 @@
+"""Pakiet monolynx-cli: instalowalny klient linii komend platformy Monolynx.
+
+Niezależny od pakietu backendu `monolynx` -- nie importuje z niego niczego (patrz
+tests/test_main.py::test_package_never_imports_backend_monolynx_package).
+"""
+
+from __future__ import annotations
+
+from monolynx_cli.version import __version__
+
+__all__ = ["__version__"]

monolynx_cli/__main__.py

@@ -0,0 +1,8 @@
+"""Umożliwia `python -m monolynx_cli`, wołając ten sam obiekt Typer co entry pointy CLI."""
+
+from __future__ import annotations
+
+from monolynx_cli.main import app
+
+if __name__ == "__main__":
+    app(prog_name="monolynx")

monolynx_cli/client.py

@@ -0,0 +1,225 @@
+"""Klient HTTP monolynx-cli: MonolynxClient, wyjątki i mapowanie błędów `/api/v2` (RFC 7807).
+
+Jeden klient dla wszystkich komend: nagłówki (Authorization Bearer, User-Agent, Accept),
+retry z backoffem, jednorazowy hook odświeżenia tokenu po 401 i tłumaczenie odpowiedzi
+błędu na wyjątki z deterministycznym `exit_code`. Globalny handler w `monolynx_cli.main`
+zamienia każdy `MonolynxError` na komunikat na stderr i kod wyjścia procesu:
+
+    1  MonolynxAPIError      błąd API (4xx poza 401/403, 429/5xx po wyczerpaniu prób)
+    3  MonolynxAuthError     401/403, nieudany refresh, brak tokenu wykryty przed wysłaniem
+    4  MonolynxNetworkError  timeout, odmowa połączenia, DNS (bez retry)
+
+Retry: maks. 4 próby. GET/DELETE ponawiane na 429 i 5xx, POST/PATCH tylko na 429 --
+ponowienie po 5xx mogłoby zdublować utworzony zasób. Czekanie idzie wyłącznie przez
+wstrzyknięte `sleep`, dzięki czemu testy nie śpią naprawdę.
+
+Token nie ma stałego prefiksu (legacy `osk_`, access token OAuth to goły `token_urlsafe`),
+więc do logów `--debug` trafia wyłącznie `config.mask_token()`.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from collections.abc import Callable
+from typing import Any
+
+import httpx
+from rich.console import Console
+
+from monolynx_cli.config import mask_token
+from monolynx_cli.version import __version__
+
+BACKOFF_DELAYS: tuple[float, ...] = (0.5, 1.0, 2.0)
+MAX_RETRY_AFTER: float = 60.0
+DEFAULT_TIMEOUT: float = 30.0
+
+_ERROR_BODY_LIMIT = 200
+_DEBUG_BODY_LIMIT = 500
+_RETRY_AFTER_SECONDS = re.compile(r"\d+(?:\.\d+)?")
+_NO_TOKEN_HINT = "Zaloguj się: monolynx auth login"
+
+
+class MonolynxError(Exception):
+    exit_code: int = 1
+
+
+class MonolynxAPIError(MonolynxError):
+    exit_code = 1
+
+    def __init__(self, status: int | None, title: str, detail: str | None = None, type_: str = "about:blank") -> None:
+        head = f"{status} {title}" if status is not None else title
+        super().__init__(f"{head}: {detail}" if detail else head)
+        self.status = status
+        self.title = title
+        self.detail = detail
+        self.type_ = type_
+
+
+class MonolynxAuthError(MonolynxAPIError):
+    exit_code = 3
+
+
+class MonolynxNetworkError(MonolynxError):
+    exit_code = 4
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+def _parse_retry_after(value: str | None) -> float | None:
+    # Data HTTP, wartość ujemna i nienumeryczna celowo wracają do zwykłego backoffu.
+    if value is None:
+        return None
+    text = value.strip()
+    if not _RETRY_AFTER_SECONDS.fullmatch(text):
+        return None
+    return min(float(text), MAX_RETRY_AFTER)
+
+
+def _build_error(response: httpx.Response) -> MonolynxAPIError:
+    status = response.status_code
+    body = response.text.strip()
+    title = response.reason_phrase or "Błąd HTTP"
+    detail: str | None = body[:_ERROR_BODY_LIMIT] or None
+    type_ = "about:blank"
+
+    content_type = response.headers.get("content-type", "").split(";")[0].strip().lower()
+    if content_type == "application/problem+json":
+        try:
+            payload = response.json()
+        except ValueError:
+            payload = None
+        if isinstance(payload, dict):
+            problem_title = payload.get("title")
+            problem_detail = payload.get("detail")
+            problem_type = payload.get("type")
+            title = problem_title if isinstance(problem_title, str) and problem_title else title
+            detail = problem_detail if isinstance(problem_detail, str) and problem_detail else None
+            type_ = problem_type if isinstance(problem_type, str) and problem_type else type_
+
+    error_class = MonolynxAuthError if status in (401, 403) else MonolynxAPIError
+    return error_class(status, title, detail, type_)
+
+
+class MonolynxClient:
+    def __init__(
+        self,
+        endpoint: str,
+        token: str | None,
+        *,
+        timeout: float = DEFAULT_TIMEOUT,
+        debug: bool = False,
+        refresh: Callable[[], str | None] | None = None,
+        transport: httpx.BaseTransport | None = None,
+        sleep: Callable[[float], None] = time.sleep,
+    ) -> None:
+        self._token = token
+        self._debug = debug
+        self._refresh = refresh
+        self._sleep = sleep
+        try:
+            self._client = httpx.Client(
+                base_url=endpoint,
+                timeout=timeout,
+                transport=transport,
+                headers={"User-Agent": f"monolynx-cli/{__version__}", "Accept": "application/json"},
+            )
+        except httpx.InvalidURL as exc:
+            raise MonolynxNetworkError(f"Nieprawidłowy adres API: {endpoint} ({exc})") from exc
+
+    def __enter__(self) -> MonolynxClient:
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._client.close()
+
+    def get(self, path: str, *, params: dict[str, Any] | None = None) -> Any:
+        return self._request("GET", path, params=params)
+
+    def delete(self, path: str, *, params: dict[str, Any] | None = None) -> Any:
+        return self._request("DELETE", path, params=params)
+
+    def post(self, path: str, *, json: Any = None, params: dict[str, Any] | None = None) -> Any:
+        return self._request("POST", path, json=json, params=params)
+
+    def patch(self, path: str, *, json: Any = None, params: dict[str, Any] | None = None) -> Any:
+        return self._request("PATCH", path, json=json, params=params)
+
+    def _request(self, method: str, path: str, *, json: Any = None, params: dict[str, Any] | None = None) -> Any:
+        if not self._token:
+            raise MonolynxAuthError(None, "Brak tokenu", _NO_TOKEN_HINT)
+
+        retry_5xx = method in ("GET", "DELETE")
+        refreshed = False
+        retries = 0
+        while True:
+            response = self._send(method, path, json, params)
+            status = response.status_code
+
+            if status == 401 and self._refresh is not None and not refreshed:
+                refreshed = True
+                new_token = self._refresh()
+                if new_token is None:
+                    raise _build_error(response)
+                self._token = new_token
+                continue
+
+            if status < 400:
+                return self._parse_success(response)
+
+            if retries < len(BACKOFF_DELAYS) and (status == 429 or (retry_5xx and status >= 500)):
+                delay = BACKOFF_DELAYS[retries]
+                if status == 429:
+                    retry_after = _parse_retry_after(response.headers.get("retry-after"))
+                    if retry_after is not None:
+                        delay = retry_after
+                self._sleep(delay)
+                retries += 1
+                continue
+
+            raise _build_error(response)
+
+    def _send(self, method: str, path: str, json: Any, params: dict[str, Any] | None) -> httpx.Response:
+        token = self._token or ""
+        try:
+            request = self._client.build_request(method, path, json=json, params=params, headers={"Authorization": f"Bearer {token}"})
+            self._log_request(request, token)
+            response = self._client.send(request)
+        except httpx.InvalidURL as exc:
+            raise MonolynxNetworkError(f"Nieprawidłowy adres żądania: {path} ({exc})") from exc
+        except httpx.TransportError as exc:
+            raise MonolynxNetworkError(f"Błąd połączenia z {self._client.base_url} ({type(exc).__name__}): {exc}") from exc
+        self._log_response(response)
+        return response
+
+    @staticmethod
+    def _parse_success(response: httpx.Response) -> Any:
+        if response.status_code == 204 or not response.content:
+            return None
+        try:
+            return response.json()
+        except ValueError as exc:
+            body = response.text.strip()[:_ERROR_BODY_LIMIT] or None
+            raise MonolynxAPIError(response.status_code, "Nieprawidłowa odpowiedź serwera", body) from exc
+
+    def _log_request(self, request: httpx.Request, token: str) -> None:
+        if not self._debug:
+            return
+        console = Console(stderr=True, markup=False, highlight=False, emoji=False)
+        console.print(f"> {request.method} {request.url}", soft_wrap=True)
+        console.print(f"> Authorization: Bearer {mask_token(token)}", soft_wrap=True)
+        console.print(f"> User-Agent: monolynx-cli/{__version__}", soft_wrap=True)
+        console.print("> Accept: application/json", soft_wrap=True)
+
+    def _log_response(self, response: httpx.Response) -> None:
+        if not self._debug:
+            return
+        console = Console(stderr=True, markup=False, highlight=False, emoji=False)
+        console.print(f"< {response.status_code}", soft_wrap=True)
+        body = response.text.strip()[:_DEBUG_BODY_LIMIT]
+        if body:
+            console.print(body, soft_wrap=True)

monolynx_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Moduly komend monolynx-cli, kazdy z wlasnym typer.Typer() rejestrowanym w main.py."""

monolynx_cli/commands/_common.py

@@ -0,0 +1,157 @@
+"""Wspólne helpery komend: ustawienia, klient projektu, potwierdzenia, paginacja, teksty z pliku/stdin.
+
+Każda grupa komend otwiera klienta przez `new_client(ctx, settings)` (albo `open_project(ctx)`,
+które dodaje sprawdzenie tokenu i projektu i zwraca (MonolynxClient, slug)). Fabryka tworzy
+klienta przez nazwę modułową `MonolynxClient` w TYM module, którą testy podmieniają przez
+monkeypatch (`monolynx_cli.commands._common.MonolynxClient`), więc grupy nie importują klasy
+klienta do tworzenia instancji. Fabryka podpina odświeżanie tokenu OAuth: proaktywne przed
+pierwszym żądaniem (gdy access token wygasa w ciągu doby) i reaktywne po 401.
+
+Odpowiedź serwera i plik konfiguracyjny to granice systemu: `fetch_all` sprawdza kształt
+koperty każdej strony przed użyciem, a `load_settings` zamienia uszkodzoną konfigurację na
+komunikat i kod 1. Każda wartość użytkownika wstawiana do ścieżki URL przechodzi przez
+`path_segment`. Błędy lokalne (brak projektu, sprzeczne flagi, brak pliku) kończą się
+typer.Exit z komunikatem na stderr, bez żadnego żądania HTTP. Brak tokenu to
+MonolynxAuthError (kod 3), tak jak w `auth whoami`. Błędy odpowiedzi serwera propagują do
+globalnego handlera w monolynx_cli.main.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+import typer
+
+from monolynx_cli import oauth
+from monolynx_cli.client import MonolynxAPIError, MonolynxAuthError, MonolynxClient
+from monolynx_cli.config import ConfigError, Settings, resolve_settings
+from monolynx_cli.options import get_options
+
+PER_PAGE = 100
+STDIN_MARKER = "-"
+
+
+def _stdin_is_tty() -> bool:
+    # Osobna funkcja, żeby testy mogły ją podmienić: CliRunner nie ma prawdziwego TTY.
+    return sys.stdin.isatty()
+
+
+def usage_error(message: str) -> typer.Exit:
+    """Wypisz komunikat na stderr i zwróć typer.Exit(2) do rzucenia (błąd użycia)."""
+    typer.echo(message, err=True)
+    return typer.Exit(2)
+
+
+def load_settings(ctx: typer.Context, project: str | None = None) -> Settings:
+    opts = get_options(ctx)
+    try:
+        return resolve_settings({"profile": opts.profile, "project": project or opts.project})
+    except ConfigError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+
+def require_project(settings: Settings) -> str:
+    if not settings.project:
+        typer.echo("Brak projektu: podaj --project, ustaw MONOLYNX_PROJECT albo project w profilu.", err=True)
+        raise typer.Exit(2)
+    return settings.project
+
+
+def new_client(ctx: typer.Context, settings: Settings) -> MonolynxClient:
+    """Klient API z odświeżaniem tokenu OAuth; dla tokenu statycznego i MONOLYNX_TOKEN bez odświeżania."""
+    opts = get_options(ctx)
+    bearer = oauth.refresh_if_expiring(settings, timeout=opts.timeout) or settings.bearer
+    refresh = oauth.make_refresh_hook(settings, timeout=opts.timeout)
+    return MonolynxClient(settings.endpoint, bearer, timeout=opts.timeout, debug=opts.debug, refresh=refresh)
+
+
+def open_project(ctx: typer.Context) -> tuple[MonolynxClient, str]:
+    """Zwróć klienta API i slug projektu z flag globalnych, zmiennych środowiskowych i profilu."""
+    settings = load_settings(ctx)
+    if settings.bearer is None:
+        raise MonolynxAuthError(None, "Brak tokenu", "Brak zapisanego tokenu. Zaloguj się: monolynx auth login")
+    slug = require_project(settings)
+    path_segment(slug)  # odrzuca `..` zanim new_client wykona choćby odświeżenie tokenu
+    return new_client(ctx, settings), slug
+
+
+def project_path(slug: str, suffix: str = "") -> str:
+    """Ścieżka endpointu API v2 w obrębie projektu, np. project_path("mon", "/tickets")."""
+    return f"/api/v2/projects/{path_segment(slug)}{suffix}"
+
+
+def confirm_destructive(message: str, *, yes: bool) -> None:
+    if yes:
+        return
+    if not _stdin_is_tty():
+        typer.echo("Operacja wymaga potwierdzenia: dodaj --yes.", err=True)
+        raise typer.Exit(2)
+    if not typer.confirm(message, default=False):
+        typer.echo("Anulowano.", err=True)
+        raise typer.Exit(1)
+
+
+def path_segment(value: str) -> str:
+    """Zakoduj wartość użytkownika jako jeden segment ścieżki URL.
+
+    `.` i `..` (oraz pusty tekst) kodowanie zostawia bez zmian, a klient HTTP normalizuje je
+    w ścieżce, więc wyszłyby poza zamierzony zasób; to błąd użycia, bez żądania HTTP.
+    """
+    if value in ("", ".", ".."):
+        raise usage_error(f"Niedozwolony identyfikator w ścieżce: {value!r}.")
+    return quote(value, safe="")
+
+
+def read_text_option(value: str | None, file_path: Path | None, *, option: str, file_option: str | None = None) -> str | None:
+    """Rozwiąż tekst z flagi (`-` = stdin) albo z pliku; None gdy żadne nie podane.
+
+    Podanie obu źródeł naraz, brak pliku i pusty stdin to błąd użycia (exit 2).
+    """
+    if value is not None and file_path is not None:
+        raise usage_error(f"Podaj {option} albo {file_option}, nie oba naraz.")
+    if file_path is not None:
+        try:
+            return file_path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            detail = exc.strerror if isinstance(exc, OSError) else "plik nie jest poprawnym UTF-8"
+            raise usage_error(f"Nie można odczytać pliku {file_path}: {detail or exc}") from exc
+    if value == STDIN_MARKER:
+        text = sys.stdin.read()
+        if not text.strip():
+            raise usage_error(f"Pusty tekst na standardowym wejściu dla {option} -.")
+        return text
+    return value
+
+
+def without_none(data: dict[str, Any]) -> dict[str, Any]:
+    """Odrzuć klucze z wartością None; puste stringi i puste listy zostają (semantyka czyszczenia MCP)."""
+    return {key: value for key, value in data.items() if value is not None}
+
+
+def _invalid_page(detail: str) -> MonolynxAPIError:
+    return MonolynxAPIError(200, "Nieprawidłowa odpowiedź serwera", detail)
+
+
+def fetch_all(client: MonolynxClient, path: str, params: dict[str, Any] | None = None) -> list[dict[str, Any]]:
+    """Pobierz elementy ze wszystkich stron; `params` (np. filtr statusu) idą na każdą stronę."""
+    items: list[dict[str, Any]] = []
+    page = 1
+    total_pages = 1
+    while page <= total_pages:
+        payload = client.get(path, params={**(params or {}), "page": page, "per_page": PER_PAGE})
+        if not isinstance(payload, dict):
+            raise _invalid_page("Odpowiedź nie jest obiektem JSON.")
+        page_items = payload.get("items")
+        if not isinstance(page_items, list) or not all(isinstance(item, dict) for item in page_items):
+            raise _invalid_page("Pole items nie jest listą obiektów.")
+        pages = payload.get("total_pages")
+        if isinstance(pages, bool) or not isinstance(pages, int) or pages < 1:
+            raise _invalid_page("Pole total_pages nie jest liczbą całkowitą >= 1.")
+        items.extend(page_items)
+        total_pages = pages
+        page += 1
+    return items

monolynx_cli/commands/auth.py

@@ -0,0 +1,169 @@
+"""Komendy monolynx_cli.commands.auth: login/logout/whoami.
+
+Login domyślnie robi OAuth 2.1 w przeglądarce (monolynx_cli.oauth), z --token zapisuje
+token API bez przeglądarki. Po zalogowaniu i we whoami komenda bije w GET /api/v2/me
+backendu Monolynx (autoryzacja Bearer) przez monolynx_cli.client.MonolynxClient -- nazwę
+modułową `MonolynxClient` podmieniają testy przez monkeypatch; dla profilu oauth klient
+dostaje hook odświeżania tokenu po 401 (oauth.make_refresh_hook). Błędy HTTP i sieci to wyjątki klienta (MonolynxError), które
+propaguje do globalnego handlera w monolynx_cli.main (kody wyjścia 1/3/4), więc komendy
+nie mają własnych typer.Exit dla odpowiedzi serwera.
+Token nigdy nie trafia na stdout/stderr w pełnej postaci, tylko przez config.mask_token.
+Plik konfiguracyjny może być ręcznie edytowany przez człowieka, a odpowiedź serwera
+może nie być tym, czego oczekujemy (zły --endpoint, HTML zamiast JSON) -- obie granice
+są sprawdzane przed użyciem, nigdy nie kończą się nieobsłużonym wyjątkiem.
+
+Lokalna flaga `--profile` każdej komendy wygrywa z globalną `--profile` z roota
+(monolynx_cli.main), globalna wygrywa z MONOLYNX_PROFILE/MONOLYNX_PROJECT -- kolejność
+pierwszeństwa poza tym bez zmian, patrz config.resolve_settings. whoami wypisuje wynik
+przez output.emit() (konwencja modułu monolynx_cli.output), nie przez typer.echo.
+Komunikaty stanu (login, logout, brak profilu) idą na stderr przez output.echo_stderr i
+są wyciszane przez --quiet; stdout zostaje czysty dla potoków.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+import typer
+
+from monolynx_cli import oauth
+from monolynx_cli.client import MonolynxAPIError, MonolynxAuthError, MonolynxClient
+from monolynx_cli.config import (
+    DEFAULT_PROFILE,
+    LOGOUT_CLEARED_FIELDS,
+    ConfigError,
+    get_profile,
+    load_config,
+    mask_token,
+    resolve_settings,
+    save_config,
+)
+from monolynx_cli.options import GlobalOptions, get_options
+from monolynx_cli.output import echo_stderr, emit
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _fetch_email(endpoint: str, token: str, opts: GlobalOptions, refresh: Callable[[], str | None] | None = None) -> str:
+    with MonolynxClient(endpoint, token, timeout=opts.timeout, debug=opts.debug, refresh=refresh) as client:
+        payload = client.get("/api/v2/me")
+    email = payload.get("email") if isinstance(payload, dict) else None
+    if not isinstance(email, str):
+        raise MonolynxAPIError(200, "Nieprawidłowa odpowiedź serwera", "Odpowiedź nie zawiera pola email.")
+    return email
+
+
+def _save_token_profile(profile: str, endpoint: str, token: str) -> None:
+    data = load_config()
+    profiles = data.setdefault("profile", {})
+    target = dict(profiles.get(profile, {}))
+    target["endpoint"] = endpoint
+    target["auth_type"] = "token"
+    target["token"] = token
+    profiles[profile] = target
+    data.setdefault("general", {}).setdefault("active_profile", DEFAULT_PROFILE)
+    save_config(data)
+
+
+@app.command("login")
+def login(
+    ctx: typer.Context,
+    endpoint: str | None = typer.Option(None, "--endpoint", help="Adres API Monolynx."),
+    token: str | None = typer.Option(None, "--token", help="Token API zamiast logowania w przeglądarce (bez OAuth)."),
+    profile: str | None = typer.Option(None, "--profile", help="Nazwa profilu docelowego."),
+    no_browser: bool = typer.Option(False, "--no-browser", help="Nie otwieraj przeglądarki, wypisz adres autoryzacji na stderr."),
+) -> None:
+    """Zaloguj się przez OAuth w przeglądarce (albo tokenem API z --token) i zapisz sesję w profilu konfiguracji."""
+    opts = get_options(ctx)
+    try:
+        settings = resolve_settings({"endpoint": endpoint, "profile": profile or opts.profile, "project": opts.project})
+    except ConfigError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    tokens: oauth.TokenSet | None = None
+    if token is None:
+        tokens = oauth.run_login(settings.endpoint, no_browser=no_browser, timeout=opts.timeout, quiet=opts.quiet, no_color=opts.no_color)
+        email = _fetch_email(settings.endpoint, tokens.access_token, opts)
+    else:
+        email = _fetch_email(settings.endpoint, token, opts)
+
+    try:
+        if tokens is not None:
+            oauth.save_tokens(settings.profile, settings.endpoint, tokens)
+        else:
+            _save_token_profile(settings.profile, settings.endpoint, str(token))
+    except ConfigError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    echo_stderr(f"Zalogowano jako {email} (profil {settings.profile})", quiet=opts.quiet, no_color=opts.no_color)
+
+
+@app.command("logout")
+def logout(
+    ctx: typer.Context,
+    profile: str | None = typer.Option(None, "--profile", help="Nazwa profilu do wylogowania."),
+) -> None:
+    """Wyczyść zapisane sekrety (token/access_token/refresh_token/expires_at) profilu."""
+    opts = get_options(ctx)
+    try:
+        settings = resolve_settings({"profile": profile or opts.profile, "project": opts.project})
+    except ConfigError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    try:
+        data = load_config()
+    except ConfigError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    profiles = data.get("profile", {})
+    if settings.profile not in profiles:
+        echo_stderr(f"Profil {settings.profile} nie istnieje.", quiet=opts.quiet, no_color=opts.no_color)
+        return
+
+    target = dict(profiles[settings.profile])
+    for field in LOGOUT_CLEARED_FIELDS:
+        target.pop(field, None)
+    profiles[settings.profile] = target
+    save_config(data)
+
+    echo_stderr(f"Wylogowano z profilu {settings.profile}", quiet=opts.quiet, no_color=opts.no_color)
+
+
+@app.command("whoami")
+def whoami(
+    ctx: typer.Context,
+    profile: str | None = typer.Option(None, "--profile", help="Nazwa profilu do sprawdzenia."),
+) -> None:
+    """Wyświetl dane zalogowanego użytkownika."""
+    opts = get_options(ctx)
+    try:
+        settings = resolve_settings({"profile": profile or opts.profile, "project": opts.project})
+    except ConfigError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    if settings.bearer is None:
+        raise MonolynxAuthError(None, "Brak tokenu", "Brak zapisanego tokenu. Zaloguj się: monolynx auth login")
+
+    hook = oauth.make_refresh_hook(settings, timeout=opts.timeout)
+    email = _fetch_email(settings.endpoint, str(settings.bearer), opts, refresh=hook)
+
+    result: dict[str, str | None] = {"email": email, "profile": settings.profile, "auth_type": settings.auth_type}
+    if settings.auth_type != "oauth":
+        result["token"] = mask_token(str(settings.bearer))
+        emit(ctx, result)
+        return
+
+    # Po odświeżeniu w profilu leży nowy access token i nowy expires_at, a settings trzyma stary.
+    try:
+        stored = get_profile(settings.profile)
+    except ConfigError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    result["token"] = mask_token(str(stored.get("access_token") or settings.bearer))
+    result["expires_at"] = stored.get("expires_at")
+    emit(ctx, result)

monolynx_cli/commands/completion.py

@@ -0,0 +1,44 @@
+"""Komenda `monolynx completion <shell>`: wypisuje skrypt uzupełniania poleceń na stdout.
+
+Skrypt generuje `typer.completion.get_completion_script` -- ta sama funkcja, której używa
+wbudowane `--show-completion`, więc wynik jest identyczny; różnica to jawna powłoka
+zamiast autodetekcji i wybór nazwy programu. Moduł `typer.completion` jest publiczny i od
+typer 0.12 do 0.27 ma tę samą sygnaturę (keyword-only `prog_name`, `complete_var`, `shell`);
+nowsze typer wendorują Clicka, więc `click.shell_completion` nie jest dostępne i nie ma
+innej publicznej drogi. Komenda nie czyta konfiguracji ani tokenu.
+"""
+
+from __future__ import annotations
+
+import typer
+from typer.completion import get_completion_script
+
+from monolynx_cli.commands._common import usage_error
+
+SHELLS = ("bash", "zsh", "fish")
+# Skrypt jest wiązany z nazwą wywołania (zmienna _<PROG>_COMPLETE), a pakiet instaluje
+# tylko te dwie; inna nazwa (np. `python -m monolynx_cli`) dostaje skrypt dla `monolynx`.
+PROG_NAMES = ("monolynx", "mnx")
+DEFAULT_PROG_NAME = "monolynx"
+
+
+def completion(
+    ctx: typer.Context,
+    shell: str = typer.Argument(..., metavar="POWŁOKA", help="Powłoka: bash, zsh lub fish."),
+) -> None:
+    """Wypisz skrypt uzupełniania poleceń (bash, zsh, fish) na stdout.
+
+    Skrypt dotyczy nazwy, pod którą uruchomiono program:
+
+    monolynx completion zsh - skrypt dla monolynx,
+
+    mnx completion zsh - skrypt dla mnx.
+
+    Nie wymaga logowania ani konfiguracji.
+    """
+    if shell not in SHELLS:
+        raise usage_error(f"Nieznana powłoka: {shell}. Dostępne: {', '.join(SHELLS)}.")
+    prog_name = ctx.find_root().info_name
+    if prog_name not in PROG_NAMES:
+        prog_name = DEFAULT_PROG_NAME
+    typer.echo(get_completion_script(prog_name=prog_name, complete_var=f"_{prog_name.upper()}_COMPLETE", shell=shell))