tlnt-cli 1.5.1__py3-none-any.whl

tlnt/cli/commands/login.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import os
+from enum import StrEnum
+from importlib import metadata
+from typing import Annotated
+
+import typer
+
+from tlnt import DISTRIBUTION
+from tlnt.browser.login import (
+    DEFAULT_CDP_ENDPOINT,
+    LOGIN_TIMEOUT_SECONDS,
+    Credentials,
+    cdp_endpoint,
+)
+from tlnt.browser.scripted import LABELS
+from tlnt.cli import prompts
+from tlnt.cli.output import banner, deadline_bar, emit
+from tlnt.cli.options import JsonOption, TableOption, VerboseOption
+from tlnt.core import config
+from tlnt.core.clients.mekari import constants as mekari_constants
+from tlnt.core.clients.mekari.constants import DASHBOARD_TALENTA_URL
+from tlnt.core.models import Result
+from tlnt.core.services.login import login as login_action
+from tlnt.core.services.status import status as status_action
+
+
+class Browser(StrEnum):
+    chrome = "chrome"
+    cdp = "cdp"
+    ego = "ego"
+    yab = "yab"
+
+
+def _resolve_backend(
+    browser: Browser | None,
+    cdp: str | None,
+) -> tuple[Browser, str | None]:
+    """Pick the sign-in browser and, for cdp, its normalized endpoint."""
+    if cdp and browser not in (None, Browser.cdp):
+        raise typer.BadParameter(
+            "--cdp only works with --browser cdp", param_hint="--cdp"
+        )
+    endpoint = cdp or config.get_setting("TALENTA_CDP", "cdp")
+    backend = browser or (Browser.cdp if endpoint else Browser.chrome)
+    if backend is not Browser.cdp:
+        return backend, None
+    try:
+        return backend, cdp_endpoint(endpoint or DEFAULT_CDP_ENDPOINT)
+    except ValueError as error:
+        raise typer.BadParameter(str(error), param_hint="--cdp") from error
+
+
+def _sign_in_texts(
+    backend: Browser, signing_in: bool = False, headless: bool = False
+) -> tuple[str, str]:
+    """Banner note and stderr message; ego and Yab open no window to sign in."""
+    if backend in (Browser.ego, Browser.yab):
+        label = LABELS[backend.value]
+        return (
+            f"Sign in to Talenta in {label} within five minutes.",
+            f"Checking {label} for a Talenta sign-in. If you are not signed "
+            f"in, open {DASHBOARD_TALENTA_URL} there and sign in. Login must "
+            "complete within five minutes.",
+        )
+    if signing_in and headless:
+        return (
+            "No browser window opens; tlnt signs in for you.",
+            "Signing in without a browser window. Login must complete within "
+            "five minutes.",
+        )
+    if signing_in:
+        return (
+            "A browser window will open and tlnt signs in for you.",
+            "Opening web browser and signing in with the email you gave. "
+            "Login must complete within five minutes.",
+        )
+    return (
+        "A browser window will open; sign in within five minutes.",
+        "Opening web browser. Sign in to your Talenta account in the opened "
+        "window. Login must complete within five minutes.",
+    )
+
+
+def _credentials(email: str) -> Credentials | Result:
+    """The password comes from TALENTA_PASSWORD, else a hidden prompt on a terminal."""
+    password = os.environ.get("TALENTA_PASSWORD")
+    if not password:
+        if not prompts.stdin_is_tty():
+            return Result(
+                False,
+                "interactive_unavailable",
+                "A password prompt needs an interactive terminal; run tlnt login "
+                "in a terminal, or set TALENTA_PASSWORD for unattended sign-in",
+            )
+        password = typer.prompt("Password", hide_input=True, err=True)
+    return Credentials(email, password)
+
+
+def login(
+    json_output: JsonOption = False,
+    table: TableOption = False,
+    store_password: Annotated[
+        bool,
+        typer.Option("--store-password", hidden=True),
+    ] = False,
+    browser: Annotated[
+        Browser | None,
+        typer.Option(
+            "--browser",
+            help="Browser to sign in with: chrome (default; installed "
+            "Chrome/Edge), cdp (a running browser), or ego / yab "
+            "(experimental).",
+        ),
+    ] = None,
+    cdp: Annotated[
+        str | None,
+        typer.Option(
+            "--cdp",
+            metavar="ENDPOINT",
+            help="DevTools endpoint of a running browser: a port, host:port or "
+            'URL. Falls back to TALENTA_CDP, then "cdp" in config.json. '
+            "Implies --browser cdp.",
+        ),
+    ] = None,
+    email: Annotated[
+        str | None,
+        typer.Option(
+            "--email",
+            metavar="EMAIL",
+            envvar="TALENTA_EMAIL",
+            help="Sign in with this Mekari email. The password comes from a "
+            "hidden prompt, or TALENTA_PASSWORD when there is no terminal.",
+        ),
+    ] = None,
+    headless: Annotated[
+        bool,
+        typer.Option(
+            "--headless",
+            help="Run Chrome without a window (needs --email; for hosts with no "
+            "display). Cannot pass a captcha or a code.",
+        ),
+    ] = False,
+    verbose: VerboseOption = False,
+) -> None:
+    """Reuse valid session or sign in through your browser."""
+    backend, endpoint = _resolve_backend(browser, cdp)
+    email = (email or "").strip() or None
+    if email and backend in (Browser.ego, Browser.yab):
+        raise typer.BadParameter(
+            "--email only works with --browser chrome or cdp", param_hint="--email"
+        )
+    if headless and backend is not Browser.chrome:
+        raise typer.BadParameter(
+            "--headless only works with --browser chrome", param_hint="--headless"
+        )
+    if headless and not email:
+        raise typer.BadParameter("--headless needs --email", param_hint="--headless")
+    if store_password:
+        typer.echo(
+            "--store-password is deprecated and does nothing; "
+            "it will be removed in 2.0.",
+            err=True,
+        )
+    current = status_action()
+    if current.ok:
+        expiry_known = isinstance(current.data, dict) and bool(
+            current.data.get("token_expires_at")
+        )
+        if expiry_known or os.environ.get("TALENTA_BEARER"):
+            emit(Result(True, "login_succeeded", "Already logged in"), json_output)
+            return
+        # Sessions saved before expiry tracking cannot prove their token works.
+        typer.echo(
+            "The saved session has no recorded token expiry; "
+            "signing in again to refresh it.",
+            err=True,
+        )
+    if not current.ok and current.code not in {
+        "session_missing",
+        "session_invalid",
+        "mobile_token_missing",
+        "mobile_token_expired",
+    }:
+        emit(current, json_output)
+        return
+    if not mekari_constants.client_id():
+        emit(
+            Result(
+                False,
+                "client_id_missing",
+                "TALENTA_CLIENT_ID is not set. Provide the Talenta mobile "
+                "OAuth client id via the TALENTA_CLIENT_ID environment variable "
+                f'or add "client_id" to {config.get_config_path()}.',
+            ),
+            json_output,
+        )
+        return
+    credentials = _credentials(email) if email else None
+    if isinstance(credentials, Result):
+        emit(credentials, json_output)
+        return
+    note, message = _sign_in_texts(
+        backend, signing_in=credentials is not None, headless=headless
+    )
+    banner(
+        f"tlnt v{metadata.version(DISTRIBUTION)}",
+        "Unofficial CLI for Mekari Talenta — use at your own risk.",
+        note,
+        enabled=not json_output,
+    )
+    typer.echo(message, err=True)
+    with deadline_bar(
+        "Waiting for you to sign in",
+        LOGIN_TIMEOUT_SECONDS,
+        enabled=not (json_output or verbose),
+    ):
+        result = login_action(
+            backend=backend.value,
+            **({"cdp": endpoint} if endpoint else {}),
+            **({"credentials": credentials} if credentials else {}),
+            **({"headless": True} if headless else {}),
+        )
+    emit(result, json_output)

tlnt/cli/commands/logout.py

@@ -0,0 +1,12 @@
+from tlnt.cli.output import run
+from tlnt.cli.options import JsonOption, TableOption, VerboseOption
+from tlnt.core.services.logout import logout as logout_action
+
+
+def logout(
+    json_output: JsonOption = False,
+    table: TableOption = False,
+    verbose: VerboseOption = False,
+) -> None:
+    """Log out of Talenta and remove the saved session."""
+    run("Signing out...", logout_action, json_output, verbose)

tlnt/cli/commands/mcp.py

@@ -0,0 +1,8 @@
+from tlnt.cli.options import VerboseOption
+
+
+def mcp(verbose: VerboseOption = False) -> None:
+    """Run the read-only MCP server over stdio."""
+    from tlnt.mcp.main import run_server
+
+    run_server()

tlnt/cli/commands/notifications.py

@@ -0,0 +1,102 @@
+from collections.abc import Callable
+from typing import Annotated
+
+import typer
+
+from tlnt.cli.output import run
+from tlnt.cli.options import AvatarsOption, JsonOption, TableOption, VerboseOption
+from tlnt.core.models import Result
+from tlnt.core.services.notifications import (
+    notification_attendance_list as notification_attendance_list_action,
+    notification_count as notification_count_action,
+    notification_detail as notification_detail_action,
+    notification_list as notification_list_action,
+    notification_timeoff_list as notification_timeoff_list_action,
+)
+
+
+def notification_count(
+    json_output: JsonOption = False,
+    table: TableOption = False,
+    verbose: VerboseOption = False,
+) -> None:
+    """Read Talenta notification counts."""
+    run("Loading notification counts...", notification_count_action, json_output, verbose)
+
+
+def _inbox_list_command(
+    action: Callable[..., Result], label: str, doc: str
+) -> Callable[..., None]:
+    """One inbox list; the three commands differ only in the inbox they read."""
+
+    def command(
+        page: Annotated[
+            int,
+            typer.Option("--page", help="Notification page number."),
+        ] = 1,
+        query: Annotated[
+            str,
+            typer.Option("--query", help="Notification search query."),
+        ] = "",
+        status: Annotated[
+            int,
+            typer.Option("--status", help="Talenta notification status filter."),
+        ] = 3,
+        json_output: JsonOption = False,
+        table: TableOption = False,
+        avatars: AvatarsOption = False,
+        verbose: VerboseOption = False,
+    ) -> None:
+        if page < 1:
+            raise typer.BadParameter("page must be at least 1")
+        run(
+            label,
+            lambda: action(page, query, status),
+            json_output,
+            verbose,
+            avatars=avatars,
+        )
+
+    command.__doc__ = doc
+    return command
+
+
+# Each action is a lambda, so the service is looked up per call and tests can
+# patch it.
+notification_list = _inbox_list_command(
+    lambda *filters: notification_list_action(*filters),
+    "Loading notifications...",
+    "Read Talenta inbox notifications.",
+)
+notification_attendance_list = _inbox_list_command(
+    lambda *filters: notification_attendance_list_action(*filters),
+    "Loading attendance notifications...",
+    "Read Talenta attendance notifications.",
+)
+notification_timeoff_list = _inbox_list_command(
+    lambda *filters: notification_timeoff_list_action(*filters),
+    "Loading time-off notifications...",
+    "Read Talenta time-off notifications.",
+)
+
+
+def notification_detail(
+    inbox_id: Annotated[
+        int,
+        typer.Argument(help="Talenta inbox ID."),
+    ],
+    json_output: JsonOption = False,
+    table: TableOption = False,
+    avatars: AvatarsOption = False,
+    verbose: VerboseOption = False,
+) -> None:
+    """Read one Talenta inbox notification detail."""
+    if inbox_id < 1:
+        raise typer.BadParameter("inbox_id must be at least 1")
+    run(
+        "Loading notification...",
+        lambda: notification_detail_action(inbox_id),
+        json_output,
+        verbose,
+        avatars=avatars,
+    )

tlnt/cli/commands/profile.py

@@ -0,0 +1,13 @@
+from tlnt.cli.output import run
+from tlnt.cli.options import AvatarsOption, JsonOption, TableOption, VerboseOption
+from tlnt.core.services.profile import profile as profile_action
+
+
+def profile(
+    json_output: JsonOption = False,
+    table: TableOption = False,
+    avatars: AvatarsOption = False,
+    verbose: VerboseOption = False,
+) -> None:
+    """Read employment information with the saved mobile token."""
+    run("Loading profile...", profile_action, json_output, verbose, avatars=avatars)

tlnt/cli/commands/setup.py

@@ -0,0 +1,12 @@
+from tlnt.cli.output import run
+from tlnt.cli.options import JsonOption, TableOption, VerboseOption
+from tlnt.core.services.setup import setup as setup_action
+
+
+def setup(
+    json_output: JsonOption = False,
+    table: TableOption = False,
+    verbose: VerboseOption = False,
+) -> None:
+    """Create config.json, or add new keys to it and drop old ones."""
+    run("Writing config...", setup_action, json_output, verbose)

tlnt/cli/commands/status.py

@@ -0,0 +1,12 @@
+from tlnt.cli.output import run
+from tlnt.cli.options import JsonOption, TableOption, VerboseOption
+from tlnt.core.services.status import status as status_action
+
+
+def status(
+    json_output: JsonOption = False,
+    table: TableOption = False,
+    verbose: VerboseOption = False,
+) -> None:
+    """Check the saved Talenta session and mobile token."""
+    run("Checking session...", status_action, json_output, verbose)