ontrack-cli 0.1.0__py3-none-any.whl

ontrack_cli/__init__.py

@@ -0,0 +1,3 @@
+"""ontrack-cli package."""
+
+__version__ = "0.1.0"

ontrack_cli/auth.py

@@ -0,0 +1,200 @@
+"""Authentication helpers that mirror moodle-cli's browser-first flow."""
+
+from __future__ import annotations
+
+import glob
+import logging
+import os
+import sys
+from urllib.parse import urlparse
+
+import requests
+
+from ontrack_cli.constants import DEFAULT_TIMEOUT
+from ontrack_cli.exceptions import AuthError
+from ontrack_cli.models import CachedUser
+
+log = logging.getLogger(__name__)
+
+
+def _glob_paths(patterns: list[str]) -> list[str]:
+    """Expand filesystem glob patterns in a stable order."""
+    paths: list[str] = []
+    for pattern in patterns:
+        paths.extend(sorted(glob.glob(os.path.expanduser(pattern))))
+    return paths
+
+
+def _chromium_cookie_files(browser: str) -> list[str]:
+    """Return candidate cookie DB files for Chromium-based browsers."""
+    platform_patterns = {
+        "darwin": {
+            "Chrome": [
+                "~/Library/Application Support/Google/Chrome/Default/Cookies",
+                "~/Library/Application Support/Google/Chrome/Guest Profile/Cookies",
+                "~/Library/Application Support/Google/Chrome/Profile */Cookies",
+            ],
+            "Brave": [
+                "~/Library/Application Support/BraveSoftware/Brave-Browser/Default/Cookies",
+                "~/Library/Application Support/BraveSoftware/Brave-Browser/Guest Profile/Cookies",
+                "~/Library/Application Support/BraveSoftware/Brave-Browser/Profile */Cookies",
+            ],
+            "Edge": [
+                "~/Library/Application Support/Microsoft Edge/Default/Cookies",
+                "~/Library/Application Support/Microsoft Edge/Guest Profile/Cookies",
+                "~/Library/Application Support/Microsoft Edge/Profile */Cookies",
+            ],
+        },
+        "linux": {
+            "Chrome": [
+                "~/.config/google-chrome/Default/Cookies",
+                "~/.config/google-chrome/Profile */Cookies",
+                "~/.var/app/com.google.Chrome/config/google-chrome/Default/Cookies",
+                "~/.var/app/com.google.Chrome/config/google-chrome/Profile */Cookies",
+            ],
+            "Brave": [
+                "~/.config/BraveSoftware/Brave-Browser/Default/Cookies",
+                "~/.config/BraveSoftware/Brave-Browser/Profile */Cookies",
+                "~/.var/app/com.brave.Browser/config/BraveSoftware/Brave-Browser/Default/Cookies",
+                "~/.var/app/com.brave.Browser/config/BraveSoftware/Brave-Browser/Profile */Cookies",
+            ],
+            "Edge": [
+                "~/.config/microsoft-edge/Default/Cookies",
+                "~/.config/microsoft-edge/Profile */Cookies",
+            ],
+        },
+        "win32": {
+            "Chrome": [
+                "~/AppData/Local/Google/Chrome/User Data/Default/Cookies",
+                "~/AppData/Local/Google/Chrome/User Data/Default/Network/Cookies",
+                "~/AppData/Local/Google/Chrome/User Data/Profile */Cookies",
+                "~/AppData/Local/Google/Chrome/User Data/Profile */Network/Cookies",
+            ],
+            "Brave": [
+                "~/AppData/Local/BraveSoftware/Brave-Browser/User Data/Default/Cookies",
+                "~/AppData/Local/BraveSoftware/Brave-Browser/User Data/Default/Network/Cookies",
+                "~/AppData/Local/BraveSoftware/Brave-Browser/User Data/Profile */Cookies",
+                "~/AppData/Local/BraveSoftware/Brave-Browser/User Data/Profile */Network/Cookies",
+            ],
+            "Edge": [
+                "~/AppData/Local/Microsoft/Edge/User Data/Default/Cookies",
+                "~/AppData/Local/Microsoft/Edge/User Data/Default/Network/Cookies",
+                "~/AppData/Local/Microsoft/Edge/User Data/Profile */Cookies",
+                "~/AppData/Local/Microsoft/Edge/User Data/Profile */Network/Cookies",
+            ],
+        },
+    }
+    return _glob_paths(platform_patterns.get(sys.platform, {}).get(browser, []))
+
+
+def _iter_browser_cookie_sets(domain: str):
+    """Yield supported browser cookie jars profile by profile."""
+    try:
+        import browser_cookie3
+    except ImportError as exc:
+        raise AuthError(
+            "browser-cookie3 is not installed, so automatic browser auth is unavailable."
+        ) from exc
+
+    loaders = [
+        ("Chrome", browser_cookie3.chrome, _chromium_cookie_files("Chrome")),
+        ("Firefox", browser_cookie3.firefox, [None]),
+        ("Brave", browser_cookie3.brave, _chromium_cookie_files("Brave")),
+        ("Edge", browser_cookie3.edge, _chromium_cookie_files("Edge")),
+    ]
+
+    for name, loader, cookie_files in loaders:
+        attempts = cookie_files or [None]
+        for cookie_file in attempts:
+            try:
+                kwargs = {"domain_name": domain}
+                if cookie_file is not None:
+                    kwargs["cookie_file"] = cookie_file
+                yield name, cookie_file or "default profile", loader(**kwargs)
+            except Exception as exc:
+                log.debug("Could not read cookies from %s (%s): %s", name, cookie_file or "default profile", exc)
+
+
+def _cookie_value(cookie_jar, domain: str, name: str) -> str | None:
+    """Read a named cookie from the jar."""
+    for cookie in cookie_jar:
+        if cookie.name != name or not cookie.value:
+            continue
+        if domain in (cookie.domain or ""):
+            return cookie.value
+    return None
+
+
+def _exchange_refresh_token(base_url: str, cookie_jar, domain: str) -> tuple[str, CachedUser] | None:
+    """Exchange browser refresh_token cookie for an auth token."""
+    username = _cookie_value(cookie_jar, domain, "username")
+    refresh_token = _cookie_value(cookie_jar, domain, "refresh_token")
+    if not username or not refresh_token:
+        return None
+
+    session = requests.Session()
+    for cookie in cookie_jar:
+        if domain not in (cookie.domain or ""):
+            continue
+        session.cookies.set(cookie.name, cookie.value, domain=cookie.domain, path=cookie.path)
+
+    response = session.post(
+        f"{base_url}/api/auth/access-token",
+        json={"delete_auth_token": False},
+        timeout=DEFAULT_TIMEOUT,
+    )
+    if response.status_code >= 400:
+        log.debug("Refresh-token exchange failed with %s", response.status_code)
+        return None
+
+    try:
+        payload = response.json()
+    except ValueError:
+        return None
+
+    if not isinstance(payload, dict):
+        return None
+
+    auth_token = payload.get("auth_token") or payload.get("access_token") or payload.get("token")
+    user_data = payload.get("user") or {}
+    if not auth_token or not isinstance(user_data, dict):
+        return None
+
+    user = CachedUser(
+        id=user_data.get("id"),
+        username=user_data.get("username") or username,
+        authentication_token=auth_token,
+        first_name=user_data.get("first_name") or user_data.get("firstName"),
+        last_name=user_data.get("last_name") or user_data.get("lastName"),
+        email=user_data.get("email"),
+        nickname=user_data.get("nickname"),
+    )
+    return auth_token, user
+
+
+def _is_valid_token(base_url: str, username: str, auth_token: str) -> bool:
+    """Check whether the candidate token can access projects."""
+    response = requests.get(
+        f"{base_url}/api/projects",
+        headers={"Username": username, "Auth-Token": auth_token, "Accept": "application/json"},
+        params={"include_inactive": True},
+        timeout=DEFAULT_TIMEOUT,
+    )
+    return response.status_code == 200
+
+
+def get_browser_auth(base_url: str) -> tuple[str, str, CachedUser] | None:
+    """Try to resolve OnTrack auth from supported browsers."""
+    domain = urlparse(base_url).hostname or ""
+    for browser_name, source, cookie_jar in _iter_browser_cookie_sets(domain):
+        exchanged = _exchange_refresh_token(base_url, cookie_jar, domain)
+        if exchanged is None:
+            continue
+        auth_token, user = exchanged
+        username = user.username or _cookie_value(cookie_jar, domain, "username")
+        if not username:
+            continue
+        if _is_valid_token(base_url, username, auth_token):
+            log.debug("Using browser auth from %s (%s)", browser_name, source)
+            return username, auth_token, user
+    return None

ontrack_cli/cli.py

@@ -0,0 +1,228 @@
+"""CLI entry point."""
+
+from __future__ import annotations
+
+import sys
+
+import click
+from rich.console import Console
+
+from ontrack_cli import __version__
+from ontrack_cli.client import OnTrackClient
+from ontrack_cli.config import load_auth_config
+from ontrack_cli.exceptions import AuthError, ConfigError, OnTrackAPIError, OnTrackCLIError
+from ontrack_cli.formatter import build_task_rows, print_project_detail, print_projects, print_roles, print_task_rows
+from ontrack_cli.output import output_json, output_yaml
+
+stdout_console = Console()
+stderr_console = Console(stderr=True)
+
+
+def _emit(data: object, *, as_json: bool, as_yaml: bool, printer) -> None:
+    """Emit structured output or rich tables."""
+    if as_json:
+        output_json(data)
+    elif as_yaml:
+        output_yaml(data)
+    else:
+        printer()
+
+
+@click.group()
+@click.version_option(version=__version__)
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """Terminal-first CLI for OnTrack."""
+    ctx.ensure_object(dict)
+    ctx.obj["_auth"] = None
+    ctx.obj["_client"] = None
+
+    def get_auth():
+        if ctx.obj["_auth"] is None:
+            ctx.obj["_auth"] = load_auth_config()
+        return ctx.obj["_auth"]
+
+    def get_client() -> OnTrackClient:
+        if ctx.obj["_client"] is None:
+            ctx.obj["_client"] = OnTrackClient(get_auth())
+        return ctx.obj["_client"]
+
+    ctx.obj["get_auth"] = get_auth
+    ctx.obj["get_client"] = get_client
+
+
+@cli.group()
+def auth() -> None:
+    """Authentication helpers."""
+
+
+@auth.command("check")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML.")
+@click.pass_context
+def auth_check(ctx: click.Context, as_json: bool, as_yaml: bool) -> None:
+    """Validate current credentials."""
+    client = ctx.obj["get_client"]()
+    info = client.check_access()
+
+    _emit(
+        info,
+        as_json=as_json,
+        as_yaml=as_yaml,
+        printer=lambda: stdout_console.print(
+            "\n".join(
+                [
+                    f"Base URL: {info['base_url']}",
+                    f"Username: {info['username']}",
+                    f"Auth method: {info['auth_method'] or 'unknown'}",
+                    f"Projects: {info['projects']}",
+                    f"Unit roles: {info['unit_roles']}",
+                ]
+            )
+        ),
+    )
+
+
+@cli.command()
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML.")
+@click.pass_context
+def user(ctx: click.Context, as_json: bool, as_yaml: bool) -> None:
+    """Show the resolved signed-in user."""
+    auth = ctx.obj["get_auth"]()
+    client = ctx.obj["get_client"]()
+    info = client.check_access()
+    payload = (
+        {
+            "id": auth.cached_user.id,
+            "username": auth.cached_user.username,
+            "first_name": auth.cached_user.first_name,
+            "last_name": auth.cached_user.last_name,
+            "email": auth.cached_user.email,
+            "nickname": auth.cached_user.nickname,
+        }
+        if auth.cached_user
+        else {"username": auth.username}
+    )
+    payload["base_url"] = auth.base_url
+    payload["auth_method"] = info.get("auth_method")
+
+    _emit(
+        payload,
+        as_json=as_json,
+        as_yaml=as_yaml,
+        printer=lambda: stdout_console.print(
+            "\n".join(
+                [
+                    f"User: {payload.get('username')}",
+                    f"Name: {' '.join(part for part in [payload.get('first_name'), payload.get('last_name')] if part) or payload.get('nickname') or '-'}",
+                    f"Email: {payload.get('email') or '-'}",
+                    f"Base URL: {payload['base_url']}",
+                    f"Auth method: {payload.get('auth_method') or 'unknown'}",
+                ]
+            )
+        ),
+    )
+
+
+@cli.command()
+@click.option("--include-inactive", is_flag=True, help="Include inactive projects.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML.")
+@click.pass_context
+def projects(ctx: click.Context, include_inactive: bool, as_json: bool, as_yaml: bool) -> None:
+    """List the current user's projects."""
+    client = ctx.obj["get_client"]()
+    items = client.get_projects(include_inactive=include_inactive)
+    payload = [item.to_dict() for item in items]
+
+    _emit(payload, as_json=as_json, as_yaml=as_yaml, printer=lambda: print_projects(items))
+
+
+@cli.command()
+@click.argument("project_id", type=int)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML.")
+@click.pass_context
+def project(ctx: click.Context, project_id: int, as_json: bool, as_yaml: bool) -> None:
+    """Show a project with merged task definitions."""
+    client = ctx.obj["get_client"]()
+    item = client.get_project(project_id)
+    unit = client.get_unit(item.unit.id)
+    task_rows = build_task_rows(item, unit)
+    payload = {
+        "project": item.to_dict(),
+        "unit": unit.to_dict(),
+        "tasks": task_rows,
+    }
+
+    _emit(payload, as_json=as_json, as_yaml=as_yaml, printer=lambda: print_project_detail(item, unit))
+
+
+@cli.command()
+@click.argument("project_id", type=int)
+@click.option("--status", "statuses", multiple=True, help="Filter by raw status key.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML.")
+@click.pass_context
+def tasks(
+    ctx: click.Context,
+    project_id: int,
+    statuses: tuple[str, ...],
+    as_json: bool,
+    as_yaml: bool,
+) -> None:
+    """Show task rows for a project."""
+    client = ctx.obj["get_client"]()
+    item = client.get_project(project_id)
+    unit = client.get_unit(item.unit.id)
+    rows = build_task_rows(item, unit)
+
+    if statuses:
+        allowed = set(statuses)
+        rows = [row for row in rows if row["status"] in allowed]
+
+    _emit(rows, as_json=as_json, as_yaml=as_yaml, printer=lambda: print_task_rows(rows))
+
+
+@cli.command()
+@click.option("--all", "show_all", is_flag=True, help="Include inactive roles.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--yaml", "as_yaml", is_flag=True, help="Output as YAML.")
+@click.pass_context
+def roles(ctx: click.Context, show_all: bool, as_json: bool, as_yaml: bool) -> None:
+    """List unit roles for the current user."""
+    client = ctx.obj["get_client"]()
+    items = client.get_unit_roles(active_only=not show_all)
+    payload = [item.to_dict() for item in items]
+
+    _emit(payload, as_json=as_json, as_yaml=as_yaml, printer=lambda: print_roles(items))
+
+
+def main() -> None:
+    """CLI entry point with consistent error handling."""
+    try:
+        cli(standalone_mode=False)
+    except click.exceptions.Abort:
+        sys.exit(130)
+    except click.exceptions.Exit as exc:
+        sys.exit(exc.exit_code)
+    except click.ClickException as exc:
+        exc.show()
+        sys.exit(exc.exit_code)
+    except ConfigError as exc:
+        stderr_console.print(f"[bold red]Config error:[/] {exc}")
+        sys.exit(1)
+    except AuthError as exc:
+        stderr_console.print(f"[bold red]Auth error:[/] {exc}")
+        sys.exit(1)
+    except OnTrackAPIError as exc:
+        stderr_console.print(f"[bold red]API error:[/] {exc}")
+        sys.exit(1)
+    except OnTrackCLIError as exc:
+        stderr_console.print(f"[bold red]Error:[/] {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

ontrack_cli/client.py

@@ -0,0 +1,226 @@
+"""Minimal client for the Doubtfire API used by OnTrack."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+from ontrack_cli.constants import DEFAULT_TIMEOUT
+from ontrack_cli.exceptions import AuthError, OnTrackAPIError
+from ontrack_cli.models import (
+    AuthConfig,
+    CachedUser,
+    ProjectDetail,
+    ProjectSummary,
+    Task,
+    TaskDefinition,
+    UnitDetail,
+    UnitRole,
+    UnitSummary,
+)
+
+
+def _unit_from_payload(data: dict[str, Any]) -> UnitSummary:
+    """Map a minimal unit payload."""
+    return UnitSummary(
+        id=data["id"],
+        code=data["code"],
+        name=data["name"],
+        my_role=data.get("my_role"),
+        start_date=data.get("start_date"),
+        end_date=data.get("end_date"),
+        active=data.get("active"),
+    )
+
+
+def _task_from_payload(data: dict[str, Any]) -> Task:
+    """Map a task payload."""
+    return Task(
+        id=data["id"],
+        task_definition_id=data["task_definition_id"],
+        status=data["status"],
+        due_date=data.get("due_date"),
+        submission_date=data.get("submission_date"),
+        completion_date=data.get("completion_date"),
+        extensions=data.get("extensions"),
+        times_assessed=data.get("times_assessed"),
+        grade=data.get("grade"),
+        quality_pts=data.get("quality_pts"),
+        include_in_portfolio=data.get("include_in_portfolio"),
+    )
+
+
+def _task_definition_from_payload(data: dict[str, Any]) -> TaskDefinition:
+    """Map a task definition payload."""
+    return TaskDefinition(
+        id=data["id"],
+        abbreviation=data["abbreviation"],
+        name=data["name"],
+        description=data.get("description"),
+        target_grade=data.get("target_grade"),
+        start_date=data.get("start_date"),
+        target_date=data.get("target_date"),
+        due_date=data.get("due_date"),
+        is_graded=data.get("is_graded"),
+        max_quality_pts=data.get("max_quality_pts"),
+    )
+
+
+class OnTrackClient:
+    """Small HTTP client for the OnTrack API."""
+
+    def __init__(self, auth: AuthConfig) -> None:
+        self.auth = auth
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Accept": "application/json",
+                "Username": auth.username,
+                "Auth-Token": auth.auth_token,
+            }
+        )
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json_body: dict[str, Any] | None = None,
+    ) -> Any:
+        """Perform a request and return parsed JSON."""
+        url = f"{self.auth.base_url}{path}"
+        response = self.session.request(
+            method,
+            url,
+            params=params,
+            json=json_body,
+            timeout=DEFAULT_TIMEOUT,
+        )
+
+        if response.status_code in (401, 419):
+            try:
+                payload = response.json()
+                message = payload.get("error") or payload.get("message") or response.text
+            except ValueError:
+                message = response.text or "Authentication failed."
+            raise AuthError(message.strip() or "Authentication failed.")
+
+        if response.status_code >= 400:
+            try:
+                payload = response.json()
+                message = payload.get("error") or payload.get("message") or response.text
+            except ValueError:
+                message = response.text or f"HTTP {response.status_code}"
+            raise OnTrackAPIError(message.strip() or f"HTTP {response.status_code}", response.status_code)
+
+        if response.status_code == 204 or not response.content:
+            return None
+
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise OnTrackAPIError("The API returned invalid JSON.", response.status_code) from exc
+
+    def get_auth_method(self) -> dict[str, Any]:
+        """Read the public auth method configuration."""
+        return self._request("GET", "/api/auth/method")
+
+    def get_projects(self, include_inactive: bool = False) -> list[ProjectSummary]:
+        """Fetch the current user's projects."""
+        data = self._request("GET", "/api/projects", params={"include_inactive": include_inactive})
+        if not isinstance(data, list):
+            return []
+        return [
+            ProjectSummary(
+                id=item["id"],
+                unit=_unit_from_payload(item["unit"]),
+                target_grade=item.get("target_grade"),
+                portfolio_available=item.get("portfolio_available"),
+                user_id=item.get("user_id"),
+                unit_id=item.get("unit_id"),
+            )
+            for item in data
+        ]
+
+    def get_project(self, project_id: int) -> ProjectDetail:
+        """Fetch a single project with task status data."""
+        data = self._request("GET", f"/api/projects/{project_id}")
+        if not isinstance(data, dict):
+            raise OnTrackAPIError("Project response was not an object.")
+        tasks = [_task_from_payload(item) for item in data.get("tasks", [])]
+        return ProjectDetail(
+            id=data["id"],
+            unit=_unit_from_payload(data["unit"]),
+            target_grade=data.get("target_grade"),
+            submitted_grade=data.get("submitted_grade"),
+            compile_portfolio=data.get("compile_portfolio"),
+            portfolio_available=data.get("portfolio_available"),
+            uses_draft_learning_summary=data.get("uses_draft_learning_summary"),
+            tasks=tasks,
+        )
+
+    def get_unit(self, unit_id: int) -> UnitDetail:
+        """Fetch a unit to resolve task definitions."""
+        data = self._request("GET", f"/api/units/{unit_id}")
+        if not isinstance(data, dict):
+            raise OnTrackAPIError("Unit response was not an object.")
+        summary = _unit_from_payload(data)
+        task_definitions = [_task_definition_from_payload(item) for item in data.get("task_definitions", [])]
+        return UnitDetail(
+            summary=summary,
+            description=data.get("description"),
+            task_definitions=task_definitions,
+        )
+
+    def get_unit_roles(self, active_only: bool = True) -> list[UnitRole]:
+        """Fetch teaching roles for the current user."""
+        data = self._request("GET", "/api/unit_roles", params={"active_only": active_only})
+        if not isinstance(data, list):
+            return []
+        roles: list[UnitRole] = []
+        for item in data:
+            user_data = item.get("user") or {}
+            user = CachedUser(
+                id=user_data.get("id"),
+                username=user_data.get("username"),
+                first_name=user_data.get("first_name"),
+                last_name=user_data.get("last_name"),
+                email=user_data.get("email"),
+                nickname=user_data.get("nickname"),
+            )
+            roles.append(
+                UnitRole(
+                    id=item["id"],
+                    role=item["role"],
+                    unit=_unit_from_payload(item["unit"]),
+                    user=user,
+                )
+            )
+        return roles
+
+    def check_access(self) -> dict[str, Any]:
+        """Run a light auth check across the main student and staff entry points."""
+        auth_method = self.get_auth_method()
+        projects = self.get_projects(include_inactive=True)
+        roles = self.get_unit_roles(active_only=False)
+        return {
+            "base_url": self.auth.base_url,
+            "username": self.auth.username,
+            "auth_method": auth_method.get("method"),
+            "projects": len(projects),
+            "unit_roles": len(roles),
+            "cached_user": (
+                {
+                    "id": self.auth.cached_user.id,
+                    "username": self.auth.cached_user.username,
+                    "first_name": self.auth.cached_user.first_name,
+                    "last_name": self.auth.cached_user.last_name,
+                    "email": self.auth.cached_user.email,
+                    "nickname": self.auth.cached_user.nickname,
+                }
+                if self.auth.cached_user
+                else None
+            ),
+        }