fluxhive-cli 0.1.0__py3-none-any.whl

fluxhive_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: fluxhive-cli
+Version: 0.1.0
+Summary: FluxHive control-plane command line client
+Author: FluxHive Team
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# @fluxhive/cli
+
+Node-installable launcher and Python implementation for the FluxHive control-plane CLI.
+
+The CLI talks to Control Server HTTP APIs and does not implement scheduling or agent runtime logic locally.
+
+The package exposes two equivalent commands:
+
+```bash
+fluxhive
+fluxhivectl
+```
+
+## npm Install
+
+```bash
+npm install -g @fluxhive/cli
+```
+
+## PyPI Install
+
+```bash
+pipx install fluxhive-cli
+```
+
+The compatibility package `fluxhivectl` also installs the same CLI:
+
+```bash
+pipx install fluxhivectl
+```
+
+Or with pip:
+
+```bash
+python -m pip install fluxhive-cli
+```
+
+Python 3.10 or newer must be available on `PATH`. You can also point the launcher at a specific Python executable:
+
+```bash
+FLUXHIVE_PYTHON=/path/to/python fluxhive --version
+```
+
+On Windows PowerShell:
+
+```powershell
+$env:FLUXHIVE_PYTHON = "C:\Python312\python.exe"
+fluxhive --version
+```
+
+## Development Install
+
+```bash
+python -m pip install -e .
+npm test
+```
+
+## Quick Start
+
+```bash
+fluxhive config base_url http://127.0.0.1:8001
+fluxhive auth login --username <username>
+
+fluxhive jobs list
+fluxhive agents list
+fluxhive runs list --limit 20
+```
+
+You can also use environment variables:
+
+```bash
+FLUXHIVE_CONTROL_URL=http://127.0.0.1:8001
+FLUXHIVE_ACCESS_TOKEN=<access-token>
+FLUXHIVE_REFRESH_TOKEN=<refresh-token>
+```
+
+## Command Groups
+
+- `auth`: login, refresh tokens, inspect current user, clear local tokens
+- `config`: read and write local CLI configuration
+- `jobs`: create, list, inspect, publish, run, cancel, clone, and delete jobs
+- `runs`: list run attempts, inspect run attempts, print stored run logs
+- `agents`: list agents, inspect GPUs, inspect queues, rename agents
+- `nodes`: alias for `agents`

fluxhive_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+fluxhive_cli-0.1.0.dist-info/licenses/LICENSE,sha256=G4fUe0QUMUfZ0ZBWfVO3H9Kae2mmIBce8ehGZshxvQU,841
+fluxhivectl/__init__.py,sha256=ZVs5hyMqqWVCrQAWR86Ns5ubYhf14Tt34sXV8BHV7DI,106
+fluxhivectl/client.py,sha256=1WQmaPJnzyNjnpaYHutC0BYaNWQsZZP4y1z9BcPICGs,6758
+fluxhivectl/config.py,sha256=22QMAk8j8m5DIyMqdHDtMK3eW-62Z4KtdkfeGptHlVE,4795
+fluxhivectl/context.py,sha256=WS233XkgpHAhHgq6p6fBofilrS3BFHcZ2Fma-loqDAY,322
+fluxhivectl/formatting.py,sha256=e88NQ83kRdfF8qCV3QgXl6u5JhS3tWHKP-qER6crrpI,2491
+fluxhivectl/main.py,sha256=7PhcOG1o3-cqVdbrmRbxAU9yCacAHoAewrFpcuCZGo0,1497
+fluxhivectl/commands/__init__.py,sha256=rC3uKIRvBpMsIWa6hRNT3MBaOeTV2rerlg84wm2AZQQ,439
+fluxhivectl/commands/agents.py,sha256=yNwjeIBPWlFyGZSO63XjMr4NSVMRBe_zgt944W80cw0,6991
+fluxhivectl/commands/auth.py,sha256=iGL7zU-WYD329J0VBKP1jEr4XsyLDma5pU4AGOpvTF0,4819
+fluxhivectl/commands/config.py,sha256=5wSOzx0JB9LxKUAXpoQb-6lqMCaxZ9tQ-kClZwM-IX4,2233
+fluxhivectl/commands/jobs.py,sha256=0fYRzcTMCBwzZwA0YqO8VA-lHSGL_-3BMuf9zQ_UtBg,9439
+fluxhivectl/commands/runs.py,sha256=lQPIgAsJZlScENk8MGTB5T20ltCVKdqvedPEmrJDpvg,4332
+fluxhive_cli-0.1.0.dist-info/METADATA,sha256=crEudevOsia2WMIdWagVmOMh94YdzmlS9MeQZq-DQo8,2031
+fluxhive_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fluxhive_cli-0.1.0.dist-info/entry_points.txt,sha256=E00ABn38gY7gAD5sE2oQTQrgrbPosZQXeZXJ7XGJCYI,87
+fluxhive_cli-0.1.0.dist-info/top_level.txt,sha256=dcUVggBwcyGYE39YCTUuBS3uqwjBvxmLVifPbhL9Grs,12
+fluxhive_cli-0.1.0.dist-info/RECORD,,

fluxhive_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fluxhive_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+fluxhive = fluxhivectl.main:main
+fluxhivectl = fluxhivectl.main:main

fluxhive_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,23 @@
+FluxHive License
+
+Copyright (c) 2025 FluxHive
+
+This repository contains multiple components with different licenses:
+
+1. Agent Component (app-agent/)
+   Licensed under the FluxHive Agent Non-Commercial Copyleft License v1.0.
+   - Open source: You may view, modify, and distribute the source code
+   - Non-commercial: Commercial use is prohibited (separate commercial license required)
+   - Copyleft: Modifications and derivative works must remain open source
+   See app-agent/LICENSE for full details.
+
+2. Control Server (app-control/)
+   Proprietary and confidential.
+   Unauthorized copying or distribution is strictly prohibited.
+
+3. Web Client (app-web/)
+   Proprietary and confidential.
+   Unauthorized copying or distribution is strictly prohibited.
+
+For commercial licensing or enterprise support, please contact:
+[dramwig@gmail.com]

fluxhive_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fluxhivectl

fluxhivectl/__init__.py

@@ -0,0 +1,5 @@
+"""FluxHive control-plane CLI package."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"

fluxhivectl/client.py

@@ -0,0 +1,175 @@
+"""HTTP client for FluxHive Control Server."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import replace
+from typing import Any
+
+from . import __version__
+from .config import CLIConfig, save_values
+
+
+class ApiError(RuntimeError):
+    def __init__(self, message: str, *, status: int | None = None, code: str | None = None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+
+    def __str__(self) -> str:
+        parts = []
+        if self.status is not None:
+            parts.append(str(self.status))
+        if self.code:
+            parts.append(self.code)
+        if parts:
+            return f"[{', '.join(parts)}] {super().__str__()}"
+        return super().__str__()
+
+
+class ApiClient:
+    def __init__(self, config: CLIConfig, *, timeout: float = 30.0):
+        self.config = config
+        self.timeout = timeout
+
+    def get(self, path: str, *, query: dict[str, Any] | None = None, auth: bool = True) -> Any:
+        return self.request("GET", path, query=query, auth=auth)
+
+    def post(
+        self,
+        path: str,
+        *,
+        body: dict[str, Any] | None = None,
+        query: dict[str, Any] | None = None,
+        auth: bool = True,
+    ) -> Any:
+        return self.request("POST", path, body=body, query=query, auth=auth)
+
+    def put(self, path: str, *, body: dict[str, Any] | None = None, auth: bool = True) -> Any:
+        return self.request("PUT", path, body=body, auth=auth)
+
+    def patch(self, path: str, *, body: dict[str, Any] | None = None, auth: bool = True) -> Any:
+        return self.request("PATCH", path, body=body, auth=auth)
+
+    def delete(self, path: str, *, auth: bool = True) -> Any:
+        return self.request("DELETE", path, auth=auth)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: dict[str, Any] | None = None,
+        query: dict[str, Any] | None = None,
+        auth: bool = True,
+        _retried_after_refresh: bool = False,
+    ) -> Any:
+        url = self._build_url(path, query=query)
+        payload = json.dumps(body).encode("utf-8") if body is not None else None
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": f"fluxhivectl/{__version__}",
+        }
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+        if auth and self.config.access_token:
+            headers["Authorization"] = f"Bearer {self.config.access_token}"
+
+        request = urllib.request.Request(url, data=payload, headers=headers, method=method.upper())
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                response_body = response.read()
+                return self._parse_response(response.status, response_body)
+        except urllib.error.HTTPError as exc:
+            response_body = exc.read()
+            if (
+                exc.code == 401
+                and auth
+                and self.config.refresh_token
+                and not _retried_after_refresh
+            ):
+                self._refresh_token()
+                return self.request(
+                    method,
+                    path,
+                    body=body,
+                    query=query,
+                    auth=auth,
+                    _retried_after_refresh=True,
+                )
+            self._raise_api_error(exc.code, response_body)
+        except urllib.error.URLError as exc:
+            raise ApiError(f"Failed to connect to Control Server: {exc.reason}") from exc
+
+    def _build_url(self, path: str, *, query: dict[str, Any] | None = None) -> str:
+        if path.startswith("http://") or path.startswith("https://"):
+            url = path
+        else:
+            url = f"{self.config.api_base_url}/{path.lstrip('/')}"
+        if query:
+            clean_query = {key: value for key, value in query.items() if value is not None}
+            if clean_query:
+                url = f"{url}?{urllib.parse.urlencode(clean_query, doseq=True)}"
+        return url
+
+    def _refresh_token(self) -> None:
+        data = self.request(
+            "POST",
+            "/auth/refresh",
+            body={"refresh_token": self.config.refresh_token},
+            auth=False,
+        )
+        access_token = data.get("access_token")
+        refresh_token = data.get("refresh_token")
+        if not access_token or not refresh_token:
+            raise ApiError("Refresh response did not include tokens", status=401)
+        save_values({"access_token": access_token, "refresh_token": refresh_token})
+        self.config = replace(
+            self.config,
+            access_token=access_token,
+            refresh_token=refresh_token,
+        )
+
+    def _parse_response(self, status: int, response_body: bytes) -> Any:
+        if not response_body:
+            return None
+        try:
+            payload = json.loads(response_body.decode("utf-8"))
+        except json.JSONDecodeError as exc:
+            raise ApiError("Control Server returned invalid JSON", status=status) from exc
+
+        if isinstance(payload, dict) and "success" in payload and "data" in payload:
+            if not payload.get("success"):
+                error = payload.get("error") or {}
+                meta = payload.get("meta") or {}
+                message = error.get("message") or meta.get("message") or "Request failed"
+                code = error.get("code") or meta.get("code")
+                raise ApiError(message, status=status, code=code)
+            return payload.get("data")
+        return payload
+
+    def _raise_api_error(self, status: int, response_body: bytes) -> None:
+        if not response_body:
+            raise ApiError("Request failed", status=status)
+        try:
+            payload = json.loads(response_body.decode("utf-8"))
+        except json.JSONDecodeError as exc:
+            raise ApiError(response_body.decode("utf-8", errors="replace"), status=status) from exc
+
+        if isinstance(payload, dict):
+            error = payload.get("error") or {}
+            meta = payload.get("meta") or {}
+            detail = payload.get("detail")
+            message = (
+                error.get("message")
+                or meta.get("message")
+                or (detail if isinstance(detail, str) else None)
+                or "Request failed"
+            )
+            code = error.get("code") or meta.get("code")
+            raise ApiError(message, status=status, code=code)
+
+        raise ApiError("Request failed", status=status)

fluxhivectl/commands/__init__.py

@@ -0,0 +1,16 @@
+"""Command group registration."""
+
+from __future__ import annotations
+
+import argparse
+
+from . import agents, auth, config, jobs, runs
+
+
+def register_commands(subparsers: argparse._SubParsersAction) -> None:
+    config.register(subparsers)
+    auth.register(subparsers)
+    jobs.register(subparsers)
+    runs.register(subparsers)
+    agents.register(subparsers, name="agents")
+    agents.register(subparsers, name="nodes")

fluxhivectl/commands/agents.py

@@ -0,0 +1,191 @@
+"""Agent and node management commands."""
+
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+from ..context import Context
+from ..formatting import compact_id, print_json, print_kv, print_table
+
+
+def register(subparsers: argparse._SubParsersAction, *, name: str) -> None:
+    help_text = "Manage agents through Control Server" if name == "agents" else "Alias for agents"
+    parser = subparsers.add_parser(name, help=help_text)
+    agent_subparsers = parser.add_subparsers(dest=f"{name}_command", required=True)
+
+    list_parser = agent_subparsers.add_parser("list", help="List agents")
+    list_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    list_parser.set_defaults(func=list_agents)
+
+    gpus_parser = agent_subparsers.add_parser("gpus", help="List GPUs globally or for one agent")
+    gpus_parser.add_argument("agent_id", nargs="?")
+    gpus_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    gpus_parser.set_defaults(func=list_gpus)
+
+    queue_parser = agent_subparsers.add_parser("queue", help="Get an agent queue snapshot")
+    queue_parser.add_argument("agent_id")
+    queue_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    queue_parser.set_defaults(func=get_queue)
+
+    jobs_parser = agent_subparsers.add_parser("jobs", help="List jobs currently known by an agent")
+    jobs_parser.add_argument("agent_id")
+    jobs_parser.add_argument("--status", help="Comma-separated status filter, e.g. queued,running")
+    jobs_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    jobs_parser.set_defaults(func=list_agent_jobs)
+
+    rename_parser = agent_subparsers.add_parser("rename", help="Update an agent nickname")
+    rename_parser.add_argument("agent_id")
+    rename_parser.add_argument("nickname")
+    rename_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    rename_parser.set_defaults(func=rename_agent)
+
+    interval_parser = agent_subparsers.add_parser("set-gpu-interval", help="Set GPU monitor interval")
+    interval_parser.add_argument("agent_id")
+    interval_parser.add_argument("interval", type=float)
+    interval_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    interval_parser.set_defaults(func=set_gpu_interval)
+
+    delete_parser = agent_subparsers.add_parser("delete", help="Remove an agent from current user")
+    delete_parser.add_argument("agent_id")
+    delete_parser.add_argument("-y", "--yes", action="store_true", help="Do not prompt for confirmation")
+    delete_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    delete_parser.set_defaults(func=delete_agent)
+
+
+def list_agents(args: argparse.Namespace, ctx: Context) -> int:
+    data = ctx.client().get("/agents")
+    if args.json:
+        print_json(data)
+        return 0
+    agents = data.get("agents", [])
+    print_table(
+        agents,
+        [
+            ("ID", lambda row: compact_id(row.get("agent_id"))),
+            ("NAME", lambda row: row.get("nickname") or row.get("agent_id")),
+            ("ONLINE", "is_online"),
+            ("ROLE", "role"),
+            ("GPU", "has_gpu_info"),
+            ("CPU%", "cpu_percent"),
+            ("MEM%", "memory_percent"),
+            ("LAST SEEN", "last_seen_at"),
+        ],
+    )
+    total = data.get("total")
+    if total is not None:
+        print(f"\nTotal: {total}")
+    return 0
+
+
+def list_gpus(args: argparse.Namespace, ctx: Context) -> int:
+    if args.agent_id:
+        data = ctx.client().get(f"/agents/{args.agent_id}/gpus")
+        rows = data.get("gpus", [])
+    else:
+        data = ctx.client().get("/agents/gpus")
+        rows = [
+            {
+                "agent_id": item.get("agent_id"),
+                "agent_nickname": item.get("agent_nickname"),
+                **(item.get("gpu") or {}),
+            }
+            for item in data.get("gpus", [])
+        ]
+
+    if args.json:
+        print_json(data)
+        return 0
+
+    columns: list[tuple[str, Any]] = []
+    if not args.agent_id:
+        columns.append(("AGENT", lambda row: row.get("agent_nickname") or compact_id(row.get("agent_id"))))
+    columns.extend(
+        [
+            ("IDX", "index"),
+            ("NAME", "name"),
+            ("UTIL%", "utilization"),
+            ("MEM USED", "memory_used"),
+            ("MEM TOTAL", "memory_total"),
+            ("TEMP", "temperature"),
+            ("POWER", "power_draw"),
+        ]
+    )
+    print_table(rows, columns)
+    return 0
+
+
+def get_queue(args: argparse.Namespace, ctx: Context) -> int:
+    data = ctx.client().get(f"/agents/{args.agent_id}/queue")
+    if args.json:
+        print_json(data)
+        return 0
+    entries = data.get("entries", [])
+    print(f"Timestamp: {data.get('timestamp') or '-'}")
+    print_table(
+        entries,
+        [
+            ("TASK", lambda row: compact_id(row.get("task_id") or row.get("id"))),
+            ("STATUS", "status"),
+            ("PRIORITY", "priority"),
+            ("CREATED", "created_at"),
+        ],
+    )
+    return 0
+
+
+def list_agent_jobs(args: argparse.Namespace, ctx: Context) -> int:
+    data = ctx.client().get(
+        f"/agents/{args.agent_id}/jobs",
+        query={"status": args.status},
+    )
+    if args.json:
+        print_json(data)
+        return 0
+    jobs = data.get("jobs", [])
+    print(f"Timestamp: {data.get('timestamp') or '-'}")
+    print_table(
+        jobs,
+        [
+            ("ID", lambda row: compact_id(row.get("task_id") or row.get("job_id") or row.get("id"))),
+            ("STATUS", "status"),
+            ("COMMAND", lambda row: row.get("command") or row.get("cmd") or row.get("name")),
+        ],
+    )
+    return 0
+
+
+def rename_agent(args: argparse.Namespace, ctx: Context) -> int:
+    data = ctx.client().patch(
+        f"/agents/{args.agent_id}/nickname",
+        body={"nickname": args.nickname},
+    )
+    _print_action_or_json(args, data)
+    return 0
+
+
+def set_gpu_interval(args: argparse.Namespace, ctx: Context) -> int:
+    data = ctx.client().post(
+        f"/agents/{args.agent_id}/gpu-monitor-interval",
+        body={"interval": args.interval},
+    )
+    _print_action_or_json(args, data)
+    return 0
+
+
+def delete_agent(args: argparse.Namespace, ctx: Context) -> int:
+    if not args.yes:
+        confirmation = input(f"Delete agent {args.agent_id}? Type 'yes' to continue: ")
+        if confirmation != "yes":
+            print("Aborted.")
+            return 1
+    data = ctx.client().delete(f"/agents/{args.agent_id}")
+    _print_action_or_json(args, data)
+    return 0
+
+
+def _print_action_or_json(args: argparse.Namespace, data: dict[str, Any]) -> None:
+    if args.json:
+        print_json(data)
+    else:
+        print_kv(data)

fluxhivectl/commands/auth.py

@@ -0,0 +1,134 @@
+"""Authentication commands."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+from dataclasses import replace
+
+from ..client import ApiClient
+from ..config import load_config, save_values, unset_values
+from ..context import Context
+from ..formatting import print_json, print_kv
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    parser = subparsers.add_parser("auth", help="Authenticate with Control Server")
+    auth_subparsers = parser.add_subparsers(dest="auth_command", required=True)
+
+    login_parser = auth_subparsers.add_parser("login", help="Log in and store tokens")
+    login_parser.add_argument("-u", "--username", help="Username")
+    login_parser.add_argument("-p", "--password", help="Password")
+    login_parser.add_argument("--base-url", help="Control Server base URL")
+    login_parser.add_argument("--endpoint-name", help="Endpoint name recorded by Control Server")
+    login_parser.add_argument("--language", default="en", help="Language for auth context")
+    login_parser.add_argument("--timezone", default="UTC", help="Timezone for auth context")
+    login_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    login_parser.set_defaults(func=login)
+
+    refresh_parser = auth_subparsers.add_parser("refresh", help="Refresh stored access token")
+    refresh_parser.set_defaults(func=refresh)
+
+    me_parser = auth_subparsers.add_parser("me", help="Show current user")
+    me_parser.add_argument("--json", action="store_true", help="Print raw response JSON")
+    me_parser.set_defaults(func=me)
+
+    logout_parser = auth_subparsers.add_parser("logout", help="Clear locally stored tokens")
+    logout_parser.set_defaults(func=logout)
+
+
+def login(args: argparse.Namespace, ctx: Context) -> int:
+    username = args.username or input("Username: ").strip()
+    password = args.password or getpass.getpass("Password: ")
+
+    base_config = load_config(base_url=args.base_url)
+    endpoint_name = args.endpoint_name or base_config.endpoint_name
+    config = replace(base_config, endpoint_name=endpoint_name)
+    client = ApiClient(config)
+
+    data = client.post(
+        "/auth/login",
+        body={
+            "username": username,
+            "password": password,
+            "endpoint_id": config.endpoint_id,
+            "endpoint_name": config.endpoint_name,
+            "language": args.language,
+            "timezone": args.timezone,
+        },
+        auth=False,
+    )
+
+    if data.get("requires_2fa"):
+        print("Login requires 2FA. CLI 2FA completion is not implemented yet.")
+        return 1
+    if not data.get("access_token") or not data.get("refresh_token"):
+        print("Login response did not include access and refresh tokens.")
+        return 1
+
+    values = {
+        "base_url": config.base_url,
+        "access_token": data.get("access_token"),
+        "refresh_token": data.get("refresh_token"),
+        "endpoint_id": config.endpoint_id,
+        "endpoint_name": config.endpoint_name,
+        "user": data.get("user"),
+    }
+    save_values(values)
+
+    if args.json:
+        print_json(data)
+    else:
+        user = data.get("user") or {}
+        print("Login succeeded.")
+        print_kv(
+            {
+                "user": user.get("username") or user.get("id") or username,
+                "base_url": config.base_url,
+                "endpoint_id": config.endpoint_id,
+            }
+        )
+    return 0
+
+
+def refresh(args: argparse.Namespace, ctx: Context) -> int:
+    if not ctx.config.refresh_token:
+        print("No refresh token configured. Run `fluxhivectl auth login` first.")
+        return 1
+    data = ctx.client().post(
+        "/auth/refresh",
+        body={"refresh_token": ctx.config.refresh_token},
+        auth=False,
+    )
+    save_values(
+        {
+            "access_token": data.get("access_token"),
+            "refresh_token": data.get("refresh_token"),
+        }
+    )
+    print("Token refreshed.")
+    return 0
+
+
+def me(args: argparse.Namespace, ctx: Context) -> int:
+    data = ctx.client().get("/auth/me")
+    if args.json:
+        print_json(data)
+    else:
+        print_kv(
+            {
+                "id": data.get("id"),
+                "username": data.get("username"),
+                "display_name": data.get("display_name"),
+                "active": data.get("is_active"),
+                "verified_email": data.get("has_verified_email"),
+                "verified_phone": data.get("has_verified_phone"),
+            }
+        )
+    return 0
+
+
+def logout(args: argparse.Namespace, ctx: Context) -> int:
+    unset_values(["access_token", "refresh_token", "user"])
+    print("Local tokens cleared.")
+    return 0