doover-cli 0.2.0__tar.gz → 0.3.2__tar.gz

{doover_cli-0.2.0 → doover_cli-0.3.2}/.gitignore

@@ -126,4 +126,8 @@ venv.bak/
 dmypy.json
 
 # Pyre type checker
-.pyre/
+.pyre/
+
+# User testing files
+tmp/
+local/

doover_cli-0.3.2/AGENT.md

@@ -0,0 +1,8 @@
+# Agent Guidance
+
+The doover-cli maintainers also have access to and control over pydoover.
+
+Do not work around pydoover bugs in doover-cli when the correct fix belongs in
+pydoover. If a doover-cli issue is caused by generated pydoover behavior,
+request or propose the pydoover change instead of patching doover-cli to bypass
+pydoover internals such as `_execute`.

{doover_cli-0.2.0 → doover_cli-0.3.2}/PKG-INFO

@@ -1,19 +1,22 @@
 Metadata-Version: 2.4
 Name: doover-cli
-Version: 0.2.0
+Version: 0.3.2
 Summary: CLI for Doover
 License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: click-prompt>=0.6.3
-Requires-Dist: click<8.2.0
+Requires-Dist: click>=8.3.1
 Requires-Dist: docker>=7.1.0
 Requires-Dist: jsf>=0.11.2
 Requires-Dist: paramiko>=3.5.1
-Requires-Dist: prompt-toolkit==3.0.51
-Requires-Dist: pydoover>=0.4.11
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pydoover==1.0.0a3
 Requires-Dist: pytz>=2025.2
 Requires-Dist: questionary>=1.10.0
 Requires-Dist: requests>=2.32.3
-Requires-Dist: typer==0.15.1
+Requires-Dist: rich>=14.3.3
+Requires-Dist: sentry-sdk<3,>=2
+Requires-Dist: textual>=8.1.1
+Requires-Dist: typer==0.24.1
 Requires-Dist: tzlocal>=5.3.1
 Requires-Dist: xlsxwriter>=3.2.3

{doover_cli-0.2.0 → doover_cli-0.3.2}/README.md

@@ -61,11 +61,29 @@ doover login
 ```
 
 If you're using the CLI in a script or CI/CD pipeline, you can set the `DOOVER_API_TOKEN` environment variable to an API token to bypass login mechanisms.
-Similarly, you can also set the `DOOVER_API_BASE_URL` environment variable to point to a custom Doover API URL if you're using a different server.
+If you need to target a custom data API endpoint in that mode, set `DOOVER_DATA_API_BASE_URL`.
+
+Channel commands on the new API surface require an explicit target agent:
+
+```bash
+doover channel get my-channel --agent 12345
+```
+
+## Error Reporting
+
+The CLI reports exception-based command failures to Sentry by default. It avoids normal control-flow exits such as `--help`, `--version`, and user aborts, and it does not intentionally attach secrets such as API tokens as structured metadata.
+
+You can control Sentry with these environment variables:
+
+```bash
+DOOVER_SENTRY_ENABLED=0
+DOOVER_SENTRY_DSN=<dsn>
+DOOVER_SENTRY_ENVIRONMENT=<name>
+```
 
 
 # Contributing
 See [CONTRIBUTING.md](.github/CONTRIBUTING.md) for more information on how to contribute to this project.
 
 # License
-This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

{doover_cli-0.2.0 → doover_cli-0.3.2}/pyproject.toml

@@ -1,23 +1,25 @@
 [project]
 name = "doover-cli"
-version = "0.2.0"
+version = "0.3.2"
 description = "CLI for Doover"
 requires-python = ">=3.11"
 dependencies = [
-    "click<8.2.0",
+    "click>=8.3.1",
     "click-prompt>=0.6.3",
-    "prompt-toolkit==3.0.51",
+    "prompt-toolkit>=3.0.52",
     "docker>=7.1.0",
     "jsf>=0.11.2",
     "paramiko>=3.5.1",
-    "pydoover>=0.4.11",
+    "pydoover==1.0.0a3",
     "pytz>=2025.2",
     "questionary>=1.10.0",
     "requests>=2.32.3",
-    "typer==0.15.1",
+    "sentry-sdk>=2,<3",
+    "typer==0.24.1",
     "tzlocal>=5.3.1",
     "xlsxwriter>=3.2.3",
-    "prompt-toolkit==3.0.51",
+    "rich>=14.3.3",
+    "textual>=8.1.1",
 ]
 
 [build-system]
@@ -34,4 +36,7 @@ dev = [
 ]
 
 [tool.uv.sources]
-pydoover = { git = "https://github.com/getdoover/pydoover", branch = "doover-2" }
+pydoover = { git = "https://github.com/getdoover/pydoover", branch = "chore/update-control-api" }
+
+[tool.ty.environment]
+python = "./.venv"

{doover_cli-0.2.0 → doover_cli-0.3.2}/src/doover_cli/__init__.py

@@ -1,30 +1,43 @@
+from doover_cli.renderer import Renderer
 from typing import Annotated, Optional
 
+import click
 import typer
 
-from pydoover.cloud.api import ConfigManager
+from pydoover.api.auth import ConfigManager
 
-from .apps import app as apps_app
+from .apps.apps import app as apps_app
+from .apps.app_install import app as app_install_app
 from .config_schema import app as config_schema_app
+from .ui_schema import app as ui_schema_app
 from .simulator import app as simulators_app
 from .agent import app as agents_app
 from .channel import app as channels_app
 from .doover_config import app as doover_config_app
 from .dda_logs import app as dda_logs_app
-from .device_type import app as device_type_app
+from .apps.device import app as device_app
+from .apps.device_type import app as device_type_app
 from .grpc import app as grpc_app
 from .login import app as login_app
 from .report import app as reports_app
 from .tunnel import app as tunnels_app
+from .user import org_app, users_app
+from .utils import sentry as sentry_utils
 from .utils.state import state
 
 app = typer.Typer(no_args_is_help=True)
 app.add_typer(
     apps_app, name="app", help="Manage applications and their configurations."
 )
+app.add_typer(
+    app_install_app,
+    name="app-install",
+    help="Manage application installations in Doover 2.0.",
+)
 app.add_typer(
     config_schema_app, name="config-schema", help="Manage application config schemas."
 )
+app.add_typer(ui_schema_app, name="ui-schema", help="Manage application UI schemas.")
 app.add_typer(
     simulators_app, name="simulator", help="Manage simulators and their configurations."
 )
@@ -40,9 +53,12 @@ app.add_typer(reports_app, name="report", help="Generate and manage reports.")
 app.add_typer(tunnels_app, name="tunnel", help="Manage SSH tunnels for remote access.")
 app.add_typer(grpc_app, name="grpc", help="Interact with running gRPC servers.")
 app.add_typer(dda_logs_app, name="dda-logs", help="Convert DDA message logs to JSON.")
+app.add_typer(device_app, name="device", help="Manipulate devices in Doover 2.0")
 app.add_typer(
     device_type_app, name="device-type", help="Manipulate device types in Doover 2.0"
 )
+app.add_typer(org_app, name="org", help="Manage the current organisation.")
+app.add_typer(users_app, name="users", help="Manage users.")
 
 
 def version_callback(value: bool):
@@ -62,14 +78,23 @@ def load_ctx(
     json: Annotated[
         bool, typer.Option(help="Set flag to output results in json format")
     ] = False,
+    render: Annotated[
+        Renderer, typer.Option(help="Set flag to output results in json format")
+    ] = Renderer.default,
     version: Annotated[
         Optional[bool], typer.Option("--version", callback=version_callback)
     ] = None,
 ):
-    state.agent_query = None
+    state.agent_id = None
+    state.profile_name = "default"
     state.config_manager = ConfigManager("default")
+    state._session = None
     state.debug = debug
-    state.json = json
+
+    if render is not None and json:
+        raise typer.BadParameter("Cannot use --json and --renderer together.")
+
+    state.renderer_name = render
 
     # return ctx.invoke(ctx.obj, *args, **kwargs)
 
@@ -78,4 +103,20 @@ def main():
     """
     Main entry point for the Doover CLI.
     """
-    app()
+    sentry_utils.init_sentry()
+
+    try:
+        app()
+    except click.exceptions.Exit:
+        raise
+    except click.Abort:
+        raise
+    except Exception as exc:
+        sentry_utils._capture_exception(
+            exc,
+            handled=False,
+            command=sentry_utils.current_command_path(),
+        )
+        raise
+    finally:
+        sentry_utils.flush_sentry()

doover_cli-0.3.2/src/doover_cli/agent.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, Annotated, Any
+
+import typer
+from pydoover.models.control import Agent, Agents, Group
+from typer import Typer
+
+from .renderer import TreeNode
+from .renderer._base import normalize_render_data
+from .utils.api import ProfileAnnotation
+from .utils.state import state
+
+if TYPE_CHECKING:
+    from pydoover.api import ControlClient
+    from .renderer import RendererBase
+
+app = Typer(no_args_is_help=True)
+
+
+def get_state() -> tuple["ControlClient", "RendererBase"]:
+    session = state.session
+    return session.get_control_client(), state.renderer
+
+
+@app.command(name="list")
+def list_(
+    tree: Annotated[
+        bool,
+        typer.Option(
+            "--tree",
+            help="Show agents grouped into a tree instead of a table.",
+        ),
+    ] = False,
+    include_archived: Annotated[
+        bool,
+        typer.Option(
+            "--include-archived",
+            help="Include archived agents and groups.",
+        ),
+    ] = False,
+    _profile: ProfileAnnotation = None,
+):
+    """List available agents."""
+    _ = _profile
+    client, renderer = get_state()
+
+    with renderer.loading("Loading agents..."):
+        response = client.agents.retrieve(include_archived=include_archived)
+
+    if tree:
+        renderer.tree(build_agents_tree(response))
+        return
+
+    renderer.render_list(response.agents)
+
+
+def build_agents_tree(response: Agents) -> TreeNode:
+    group_entries = _flatten_groups(response.groups or [])
+    groups = [group for group, _parent_id in group_entries]
+    agents = list(response.agents or [])
+    root = TreeNode(response)
+    groups_by_id = {
+        group_id: group
+        for group in groups
+        if (group_id := _resource_id(group)) is not None
+    }
+    group_ids = set(groups_by_id)
+    group_ids_by_name = {
+        str(group_name): group_id
+        for group_id, group in groups_by_id.items()
+        if (group_name := _field_value(group, "name"))
+    }
+    groups_by_parent_id: dict[int | None, list[Group]] = defaultdict(list)
+    agents_by_group_id, agents_by_unknown_group = _group_agents(
+        agents,
+        group_ids=group_ids,
+        group_ids_by_name=group_ids_by_name,
+    )
+
+    for group, inferred_parent_id in group_entries:
+        parent_id = _resource_id(_field_value(group, "parent"))
+        if parent_id is None:
+            parent_id = inferred_parent_id
+        if parent_id not in group_ids:
+            parent_id = None
+        groups_by_parent_id[parent_id].append(group)
+
+    for siblings in groups_by_parent_id.values():
+        siblings.sort(key=_group_sort_key)
+    for grouped_agents in agents_by_group_id.values():
+        grouped_agents.sort(key=_agent_sort_key)
+    for grouped_agents in agents_by_unknown_group.values():
+        grouped_agents.sort(key=_agent_sort_key)
+
+    root.children.extend(
+        _build_group_branch(group, groups_by_parent_id, agents_by_group_id)
+        for group in groups_by_parent_id[None]
+    )
+
+    for group_name in sorted(name for name in agents_by_unknown_group if name):
+        root.children.append(
+            TreeNode(
+                Group(name=group_name),
+                children=[
+                    TreeNode(agent)
+                    for agent in agents_by_unknown_group[group_name]
+                ],
+            )
+        )
+
+    if "" in agents_by_unknown_group:
+        root.children.append(
+            TreeNode(
+                Group(name="Ungrouped"),
+                children=[
+                    TreeNode(agent) for agent in agents_by_unknown_group[""]
+                ],
+            )
+        )
+
+    if not root.children and agents:
+        root.children.extend(
+            TreeNode(agent) for agent in sorted(agents, key=_agent_sort_key)
+        )
+
+    return root
+
+
+def _flatten_groups(groups: list[Group]) -> list[tuple[Group, int | None]]:
+    flattened: list[tuple[Group, int | None]] = []
+
+    def visit(group: Group, parent_id: int | None, path: set[int]) -> None:
+        group_id = _resource_id(group)
+        flattened.append((group, parent_id))
+
+        if group_id is not None:
+            if group_id in path:
+                return
+            path = {*path, group_id}
+
+        for child in _field_value(group, "children", []) or []:
+            visit(child, group_id, path)
+
+    for group in groups:
+        visit(group, None, set())
+
+    return flattened
+
+
+def _build_group_branch(
+    group: Group,
+    groups_by_parent_id: dict[int | None, list[Group]],
+    agents_by_group_id: dict[int, list[Agent]],
+) -> TreeNode:
+    group_id = _resource_id(group)
+    children = [
+        _build_group_branch(child, groups_by_parent_id, agents_by_group_id)
+        for child in groups_by_parent_id.get(group_id, [])
+    ]
+    if group_id is not None:
+        children.extend(
+            TreeNode(agent) for agent in agents_by_group_id.get(group_id, [])
+        )
+    return TreeNode(group, children=children)
+
+
+def _group_agents(
+    agents: list[Agent],
+    *,
+    group_ids: set[int],
+    group_ids_by_name: dict[str, int],
+) -> tuple[dict[int, list[Agent]], dict[str, list[Agent]]]:
+    by_id: dict[int, list[Agent]] = defaultdict(list)
+    by_unknown_label: dict[str, list[Agent]] = defaultdict(list)
+
+    for agent in agents:
+        group_value = _field_value(agent, "group")
+        group_id = _resource_id(group_value)
+        if group_id in group_ids:
+            by_id[group_id].append(agent)
+            continue
+
+        group_label = str(group_value or "")
+        if (named_group_id := group_ids_by_name.get(group_label)) is not None:
+            by_id[named_group_id].append(agent)
+            continue
+
+        by_unknown_label[group_label].append(agent)
+
+    return by_id, by_unknown_label
+
+
+def _field_value(item: Any, key: str, default: Any = None) -> Any:
+    if isinstance(item, dict):
+        return item.get(key, default)
+
+    value = getattr(item, key, default)
+    if value is not None:
+        return value
+
+    normalized = normalize_render_data(item)
+    if isinstance(normalized, dict):
+        return normalized.get(key, default)
+    return default
+
+
+def _resource_id(value: Any) -> int | None:
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        return _coerce_int(value.get("id"))
+    return _coerce_int(getattr(value, "id", value))
+
+
+def _coerce_int(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _group_label(group: Group) -> str:
+    return str(_field_value(group, "name") or _field_value(group, "id") or "Unnamed")
+
+
+def _group_sort_key(group: Group) -> tuple[str, int]:
+    return (_group_label(group).casefold(), _resource_id(group) or 0)
+
+
+def _agent_sort_key(agent: Agent) -> tuple[str, str, int]:
+    return (
+        str(_field_value(agent, "display_name", "") or "").casefold(),
+        str(_field_value(agent, "name", "") or "").casefold(),
+        _resource_id(agent) or 0,
+    )

doover_cli-0.3.2/src/doover_cli/api/__init__.py

@@ -0,0 +1,9 @@
+from .auth import DooverCLIAuthClient
+from .errors import ControlClientUnavailableError
+from .session import DooverCLISession
+
+__all__ = [
+    "ControlClientUnavailableError",
+    "DooverCLIAuthClient",
+    "DooverCLISession",
+]

doover_cli-0.3.2/src/doover_cli/api/auth.py

@@ -0,0 +1,165 @@
+import time
+import webbrowser
+from datetime import datetime, timedelta, timezone
+from urllib.parse import urlencode
+
+import requests
+import rich
+
+from pydoover.api.auth import AuthProfile, ConfigManager, Doover2AuthClient
+
+DEFAULT_AUTH_CLIENT_ID = "08a9ae8c-0668-428b-a691-f7eaa526aca0"
+
+
+class DooverCLIAuthClient(Doover2AuthClient):
+    def __init__(
+        self,
+        *,
+        config_manager: ConfigManager | None = None,
+        profile_name: str | None = None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self._config_manager = config_manager
+        self._profile_name = profile_name
+
+    @classmethod
+    def device_login(
+        cls,
+        *,
+        staging: bool = False,
+        timeout: float = 60.0,
+        open_browser: bool = True,
+    ) -> "DooverCLIAuthClient":
+        if staging:
+            auth_server_url = "https://auth.staging.udoover.com"
+            control_base_url = "https://api.staging.udoover.com"
+            data_base_url = "https://data.staging.udoover.com/api"
+        else:
+            auth_server_url = "https://auth.doover.com"
+            control_base_url = "https://api.doover.com"
+            data_base_url = "https://data.doover.com/api"
+
+        config = requests.get(
+            f"{auth_server_url}/.well-known/openid-configuration",
+            timeout=timeout,
+        ).json()
+        endpoint = config["device_authorization_endpoint"]
+
+        device_config = requests.post(
+            endpoint,
+            params={
+                "client_id": DEFAULT_AUTH_CLIENT_ID,
+                "scope": "offline_access",
+                "metaData.device.name": "Doover CLI - Python",
+                "metaData.device.type": "other",
+            },
+            timeout=timeout,
+        ).json()
+
+        rich.print(
+            f"[green]User Code: \n\n[bold cyan]{device_config['user_code']}[/bold cyan]\n[/green]"
+        )
+
+        login_url = f"{auth_server_url}/oauth2/device?" + urlencode(
+            {
+                "user_code": device_config["user_code"],
+                "client_id": DEFAULT_AUTH_CLIENT_ID,
+            }
+        )
+        print(
+            f"Alternatively, copy this link into your browser to complete the login:\n{login_url}"
+        )
+        if open_browser:
+            webbrowser.open(login_url, new=0, autoraise=True)
+
+        for _ in range(device_config["expires_in"] // device_config["interval"]):
+            time.sleep(device_config["interval"])
+
+            resp = requests.post(
+                config["token_endpoint"],
+                params={
+                    "device_code": device_config["device_code"],
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                    "client_id": DEFAULT_AUTH_CLIENT_ID,
+                },
+                timeout=timeout,
+            )
+            if not resp.ok:
+                continue
+
+            token_data = resp.json()
+            return cls(
+                token=token_data["access_token"],
+                token_expires=datetime.now(timezone.utc)
+                + timedelta(seconds=token_data["expires_in"]),
+                control_base_url=control_base_url,
+                data_base_url=data_base_url,
+                auth_server_url=auth_server_url,
+                auth_server_client_id=DEFAULT_AUTH_CLIENT_ID,
+                refresh_token=token_data["refresh_token"],
+                refresh_token_id=token_data["refresh_token_id"],
+                timeout=timeout,
+            )
+
+        raise RuntimeError("Auth login expired. Please try again later.")
+
+    @classmethod
+    def from_profile_name(
+        cls,
+        profile_name: str,
+        *,
+        config_manager: ConfigManager | None = None,
+        timeout: float = 60.0,
+    ) -> "DooverCLIAuthClient":
+        manager = config_manager or ConfigManager(profile_name)
+        profile = manager.get(profile_name)
+        if profile is None:
+            raise RuntimeError(f"No configuration found for profile {profile_name}.")
+
+        return cls(
+            token=profile.token,
+            token_expires=profile.token_expires,
+            refresh_token=profile.refresh_token,
+            refresh_token_id=profile.refresh_token_id,
+            control_base_url=profile.control_base_url,
+            data_base_url=profile.data_base_url,
+            auth_server_url=profile.auth_server_url,
+            auth_server_client_id=profile.auth_server_client_id,
+            timeout=timeout,
+            config_manager=manager,
+            profile_name=profile_name,
+        )
+
+    def to_profile(self, profile_name: str) -> AuthProfile:
+        return AuthProfile(
+            profile=profile_name,
+            token=self.token,
+            token_expires=self.token_expires,
+            control_base_url=self.control_base_url,
+            data_base_url=self.data_base_url,
+            refresh_token=self.refresh_token,
+            refresh_token_id=self.refresh_token_id,
+            auth_server_url=self.auth_server_url,
+            auth_server_client_id=self.auth_server_client_id,
+        )
+
+    def persist_profile(
+        self,
+        profile_name: str | None = None,
+        config_manager: ConfigManager | None = None,
+    ) -> None:
+        manager = config_manager or self._config_manager
+        name = profile_name or self._profile_name
+        if manager is None or name is None:
+            return
+
+        manager.create(self.to_profile(name))
+        manager.current_profile = name
+        manager.write()
+        self._config_manager = manager
+        self._profile_name = name
+
+    def refresh_access_token(self):
+        super().refresh_access_token()
+        self.persist_profile()

doover_cli-0.3.2/src/doover_cli/api/errors.py

@@ -0,0 +1,6 @@
+class ControlClientUnavailableError(RuntimeError):
+    def __init__(self, command_name: str):
+        self.command_name = command_name
+        super().__init__(
+            "This command requires pydoover.api.control, which is not available in this release."
+        )