uno-cli 1.0.2__tar.gz → 1.0.4__tar.gz

{uno_cli-1.0.2 → uno_cli-1.0.4}/.gitignore

@@ -20,3 +20,7 @@ data_export/
 data_export_prod/
 scripts/backup_prod*.json
 .mcp_auth/
+.cursor/
+.worktrees/
+skills/.skills_store_lock.json
+test_gpt_image2.py

{uno_cli-1.0.2 → uno_cli-1.0.4}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: uno-cli
-Version: 1.0.2
+Version: 1.0.4
 Summary: Uno CLI — Agent tool gateway by ClawdChat. Access 2000+ real-world tools from the command line.
-Project-URL: Homepage, https://clawdtools.uno
-Project-URL: Documentation, https://clawdtools.uno/docs
+Project-URL: Homepage, https://agentools.uno
+Project-URL: Documentation, https://agentools.uno/docs
 Project-URL: Repository, https://github.com/xray918/uno-mcp-cli
 Project-URL: Issues, https://github.com/xray918/uno-mcp-cli/issues
 Author-email: ClawdChat <dev@clawdchat.cn>
@@ -77,7 +77,7 @@ All commands output JSON. Add `--compact` for single-line output (fewer tokens f
 | Variable | Purpose |
 |---|---|
 | `UNO_API_KEY` | Override stored credentials (useful for CI). |
-| `UNO_API_URL` | Override API base URL (default `https://clawdtools.uno`). |
+| `UNO_API_URL` | Override API base URL (default `https://agentools.uno`; legacy host `https://clawdtools.uno` still serves `/v1` and `/mcp`). |
 | `UNO_OAUTH_SCOPE` | OAuth scope requested at `login --start` (default `mcp:*`). Single-purpose skills narrow this to `mcp:<tool>`. |
 | `UNO_ALLOWED_TOOLS` | Comma-separated glob whitelist enforced by `uno call`. Tools not matching any pattern are rejected with `tool_not_allowed`. Example: `gpt-image-2.*,time.*`. |
 | `UNO_CALLER_SKILL` | Identifier (e.g. `gpt-image2`) appended to the `User-Agent` for attribution. |

{uno_cli-1.0.2 → uno_cli-1.0.4}/README.md

@@ -46,7 +46,7 @@ All commands output JSON. Add `--compact` for single-line output (fewer tokens f
 | Variable | Purpose |
 |---|---|
 | `UNO_API_KEY` | Override stored credentials (useful for CI). |
-| `UNO_API_URL` | Override API base URL (default `https://clawdtools.uno`). |
+| `UNO_API_URL` | Override API base URL (default `https://agentools.uno`; legacy host `https://clawdtools.uno` still serves `/v1` and `/mcp`). |
 | `UNO_OAUTH_SCOPE` | OAuth scope requested at `login --start` (default `mcp:*`). Single-purpose skills narrow this to `mcp:<tool>`. |
 | `UNO_ALLOWED_TOOLS` | Comma-separated glob whitelist enforced by `uno call`. Tools not matching any pattern are rejected with `tool_not_allowed`. Example: `gpt-image-2.*,time.*`. |
 | `UNO_CALLER_SKILL` | Identifier (e.g. `gpt-image2`) appended to the `User-Agent` for attribution. |

{uno_cli-1.0.2 → uno_cli-1.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uno-cli"
-version = "1.0.2"
+version = "1.0.4"
 description = "Uno CLI — Agent tool gateway by ClawdChat. Access 2000+ real-world tools from the command line."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -35,8 +35,8 @@ classifiers = [
 dependencies = []
 
 [project.urls]
-Homepage = "https://clawdtools.uno"
-Documentation = "https://clawdtools.uno/docs"
+Homepage = "https://agentools.uno"
+Documentation = "https://agentools.uno/docs"
 Repository = "https://github.com/xray918/uno-mcp-cli"
 Issues = "https://github.com/xray918/uno-mcp-cli/issues"
 

{uno_cli-1.0.2 → uno_cli-1.0.4}/tests/test_cli.py

@@ -39,6 +39,22 @@ class TestPreprocessArgv:
 # ── Parser structure ───────────────────────────────────────────────
 
 
+class TestDefaultBase:
+    def test_default_base_is_agentools(self):
+        assert cli.DEFAULT_BASE == "https://agentools.uno"
+        assert cli.LEGACY_BASE == "https://clawdtools.uno"
+
+    def test_parser_defaults_to_agentools(self, monkeypatch):
+        monkeypatch.delenv("UNO_API_URL", raising=False)
+        args = cli.build_parser().parse_args(["whoami"])
+        assert args.base_url == "https://agentools.uno"
+
+    def test_env_overrides_default(self, monkeypatch):
+        monkeypatch.setenv("UNO_API_URL", "https://clawdtools.uno")
+        args = cli.build_parser().parse_args(["whoami"])
+        assert args.base_url == "https://clawdtools.uno"
+
+
 class TestParser:
     def test_version_flag_matches_package(self, capsys):
         parser = cli.build_parser()
@@ -55,7 +71,8 @@ class TestParser:
         )
         expected = {
             "login", "logout", "use", "whoami", "search", "tool",
-            "call", "rate", "servers", "keys", "health", "disconnect",
+            "call", "rate", "servers", "keys", "health",
+            "disconnect", "connections", "auth", "logs",
         }
         assert expected <= set(subparsers_action.choices.keys())
 
@@ -120,6 +137,124 @@ class TestErrorHints:
     def test_format_api_error_str_body(self):
         out = cli._format_api_error(500, "server exploded")
         assert out["error"] == "server exploded"
+        assert out["success"] is False
+
+    def test_format_api_error_keeps_gateway_meta(self):
+        body = {
+            "error": "tool_not_found",
+            "message": "Tool not found: x.y",
+            "meta": {
+                "request_id": "abc",
+                "credits_used": 0,
+                "charged": False,
+            },
+        }
+        out = cli._format_api_error(404, body)
+        assert out["error"] == "tool_not_found"
+        assert out["meta"]["request_id"] == "abc"
+        assert out["meta"]["charged"] is False
+
+    def test_missing_credentials_points_to_login_start(self, capsys, monkeypatch, tmp_path):
+        cred_dir = tmp_path / ".uno"
+        monkeypatch.setattr(cli, "CRED_DIR", str(cred_dir))
+        monkeypatch.setattr(cli, "CRED_FILE", str(cred_dir / "credentials.json"))
+        monkeypatch.delenv("UNO_API_KEY", raising=False)
+        args = type("Args", (), {"base_url": "https://example.invalid"})()
+        with pytest.raises(SystemExit) as ei:
+            cli._get_api(args)
+        assert ei.value.code == 1
+        payload = json.loads(capsys.readouterr().out)
+        assert payload["error"] == "Not logged in. Run: uno login --start"
+
+    def test_auth_error_hints_point_to_login_start(self):
+        for msg in ("unauthorized", "invalid credentials", "invalid api key"):
+            hint = cli._match_hint(msg)
+            assert "uno login --start" in hint
+
+    def test_auth_required_fallback_hint_is_generic_oauth(self):
+        """``_ERROR_HINTS`` keeps a generic OAuth fallback; call path overrides."""
+        hint = cli._match_hint("auth_required")
+        assert "OAuth required" in hint
+        assert "auth_url" in hint
+
+
+# ── cmd_call auth_type hint overrides ──────────────────────────────
+
+
+class _CallArgs:
+    def __init__(self, tool="demo.tool", args_json=None):
+        self.tool = tool
+        self.args = args_json
+        self.timeout = 60
+        self.base_url = "https://clawdtools.uno"
+        self.dry_run = False
+
+
+class TestCmdCallAuthHints:
+    """``cmd_call`` must override the generic auth_required hint by auth_type."""
+
+    def _run_auth_error(self, monkeypatch, capsys, payload):
+        monkeypatch.delenv("UNO_ALLOWED_TOOLS", raising=False)
+
+        class _FakeAPI:
+            def post(self, path, data, timeout=60):
+                return payload
+
+        monkeypatch.setattr(cli, "_get_api", lambda args: _FakeAPI())
+        with pytest.raises(SystemExit) as ei:
+            cli.cmd_call(_CallArgs())
+        assert ei.value.code == 1
+        return json.loads(capsys.readouterr().out)
+
+    @pytest.mark.parametrize("auth_type", ["oauth_device", "oauth_device_code", "device_code_api"])
+    def test_device_code_auth_hint(self, monkeypatch, capsys, auth_type):
+        out = self._run_auth_error(
+            monkeypatch,
+            capsys,
+            {
+                "error": "auth_required",
+                "auth_type": auth_type,
+                "auth_url": "https://example.com/device",
+                "get_key_url": "https://example.com/get-key",
+            },
+        )
+        assert out["error"] == "auth_required"
+        assert out["auth_type"] == auth_type
+        hint = out["hint"]
+        assert "Device-code" in hint
+        assert "user code" in hint
+        assert "get_key_url" in hint  # tells agent NOT to follow it
+        assert "Do not ask for a key" in hint
+        # Must not steer toward applying for / showing a key.
+        assert "Show get_key_url" not in hint
+        assert "申请" not in hint
+
+    def test_generic_oauth_auth_url_hint(self, monkeypatch, capsys):
+        out = self._run_auth_error(
+            monkeypatch,
+            capsys,
+            {
+                "error": "auth_required",
+                "auth_type": "oauth",
+                "auth_url": "https://example.com/oauth",
+            },
+        )
+        assert out["hint"] == "OAuth required. Open auth_url in a browser to authorize."
+        assert "Device-code" not in out["hint"]
+        assert "user code" not in out["hint"]
+
+    def test_api_key_auth_hint(self, monkeypatch, capsys):
+        out = self._run_auth_error(
+            monkeypatch,
+            capsys,
+            {
+                "error": "auth_required",
+                "auth_type": "api_key",
+                "get_key_url": "https://example.com/get-key",
+            },
+        )
+        assert "API key required" in out["hint"]
+        assert "Show get_key_url" in out["hint"]
 
 
 # ── JSON output shape of _out ──────────────────────────────────────

uno_cli-1.0.4/tests/test_connections_logs.py

@@ -0,0 +1,148 @@
+"""CLI unit tests for `uno logs --last 20` and `uno connections`."""
+
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+
+import pytest
+
+from uno_cli import cli
+
+
+class _FakeAPI:
+    def __init__(self, payload):
+        self.payload = payload
+        self.calls = []
+
+    def get(self, path, params=None):
+        self.calls.append((path, params))
+        return self.payload
+
+
+def _args(**extra):
+    base = {"base_url": "https://clawdtools.uno", "reconnect": None, "last": 20}
+    base.update(extra)
+    return SimpleNamespace(**base)
+
+
+class TestConnectionsCommand:
+    def test_lists_connections(self, monkeypatch, capsys):
+        payload = {
+            "connections": [
+                {
+                    "slug": "github",
+                    "name": "GitHub",
+                    "auth_type": "oauth2",
+                    "connected": False,
+                    "status": "missing",
+                    "auth_url": "https://clawdtools.uno/oauth/start/github",
+                    "platform_held": False,
+                },
+                {
+                    "slug": "brave-search",
+                    "auth_type": "none",
+                    "connected": True,
+                    "status": "active",
+                    "platform_held": True,
+                    "auth_url": None,
+                },
+            ],
+            "total": 2,
+        }
+        fake = _FakeAPI(payload)
+        monkeypatch.setattr(cli, "_get_api", lambda args: fake)
+        cli._out.compact = False
+        cli.cmd_connections(_args())
+        out = json.loads(capsys.readouterr().out)
+        assert out["success"] is True
+        assert out["data"]["total"] == 2
+        assert fake.calls == [("/v1/auth/connections", None)]
+
+    def test_reconnect_prints_auth_url(self, monkeypatch, capsys):
+        payload = {
+            "connections": [
+                {
+                    "slug": "github",
+                    "status": "expired",
+                    "connected": False,
+                    "auth_url": "https://clawdtools.uno/oauth/start/github",
+                    "platform_held": False,
+                }
+            ]
+        }
+        fake = _FakeAPI(payload)
+        monkeypatch.setattr(cli, "_get_api", lambda args: fake)
+        cli.cmd_connections(_args(reconnect="github"))
+        out = json.loads(capsys.readouterr().out)
+        assert out["data"]["auth_url"] == "https://clawdtools.uno/oauth/start/github"
+        assert "hint" in out["data"]
+
+    def test_auth_list_alias(self, monkeypatch, capsys):
+        fake = _FakeAPI({"connections": [], "total": 0})
+        monkeypatch.setattr(cli, "_get_api", lambda args: fake)
+        cli.cmd_auth(SimpleNamespace(base_url="https://x", auth_action="list", reconnect=None))
+        out = json.loads(capsys.readouterr().out)
+        assert out["success"] is True
+        assert fake.calls[0][0] == "/v1/auth/connections"
+
+
+class TestLogsCommand:
+    def test_logs_last_20_hits_history(self, monkeypatch, capsys):
+        payload = {
+            "records": [
+                {
+                    "tool": "brave-search.web_search",
+                    "latency_ms": 12,
+                    "credits": 1.0,
+                    "success": True,
+                    "error_code": None,
+                    "created_at": "2026-08-30T00:00:00",
+                    "request_params": {"q": "secret-payload"},
+                }
+            ],
+            "total": 1,
+        }
+        fake = _FakeAPI(payload)
+        monkeypatch.setattr(cli, "_get_api", lambda args: fake)
+        cli.cmd_logs(_args(last=20))
+        path, params = fake.calls[0]
+        assert path == "/v1/usage/history"
+        assert params == {"limit": 20, "days": 7}
+        out = json.loads(capsys.readouterr().out)
+        rec = out["data"]["records"][0]
+        assert rec["tool"] == "brave-search.web_search"
+        assert rec["success"] is True
+        assert "request_params" not in rec
+        assert out["data"]["days"] == 7
+
+    def test_parser_registers_logs_and_connections(self):
+        parser = cli.build_parser()
+        logs = parser.parse_args(["logs", "--last", "20"])
+        assert logs.command == "logs"
+        assert logs.last == 20
+        conn = parser.parse_args(["connections", "--reconnect", "github"])
+        assert conn.command == "connections"
+        assert conn.reconnect == "github"
+
+
+class TestSearchPrintsStats:
+    def test_search_output_includes_success_rate_and_calls_7d(self, monkeypatch, capsys):
+        payload = {
+            "tools": [
+                {
+                    "tool": "weather.get",
+                    "stats": {"success_rate": 0.95, "calls_7d": 12, "avg_ms": 80, "rating": 4.5},
+                }
+            ],
+            "total": 1,
+        }
+        fake = _FakeAPI(payload)
+        monkeypatch.setattr(cli, "_get_public_api", lambda args: fake)
+        cli.cmd_search(SimpleNamespace(
+            query="weather", limit=5, mode=None, category=None, server=None, base_url="https://x",
+        ))
+        out = json.loads(capsys.readouterr().out)
+        stats = out["data"]["tools"][0]["stats"]
+        assert stats["success_rate"] == 0.95
+        assert stats["calls_7d"] == 12

uno_cli-1.0.4/tests/test_register.py

@@ -0,0 +1,85 @@
+"""Tests for the ``uno register`` command."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from uno_cli import cli
+
+
+class TestCmdRegister:
+    def _fake_api(self, monkeypatch, return_value=None, raise_error=None):
+        captured = {}
+
+        class _FakeAPI:
+            def __init__(self, api_key="", base_url=""):
+                self.api_key = api_key
+                captured["api_key"] = api_key
+
+            def post(self, path, data, timeout=60):
+                captured["path"] = path
+                captured["data"] = data
+                if raise_error:
+                    raise raise_error
+                return return_value if return_value is not None else {"id": "u_1", "email": data["email"]}
+
+        monkeypatch.setattr(cli, "UnoAPI", _FakeAPI)
+        return captured
+
+    def test_register_posts_to_correct_endpoint(self, monkeypatch, capsys):
+        captured = self._fake_api(monkeypatch)
+        cli.main(["register", "alice@example.com", "s3cr3tP@ss"])
+
+        assert captured["path"] == "/v1/auth/register"
+        assert captured["data"]["email"] == "alice@example.com"
+        assert captured["data"]["password"] == "s3cr3tP@ss"
+
+    def test_register_sends_name_when_provided(self, monkeypatch):
+        captured = self._fake_api(monkeypatch)
+        cli.main(["register", "bob@example.com", "p@ss", "--name", "Bob"])
+        assert captured["data"]["name"] == "Bob"
+
+    def test_register_name_defaults_to_empty_string(self, monkeypatch):
+        captured = self._fake_api(monkeypatch, return_value={})
+        cli.main(["register", "carol@example.com", "p@ss"])
+        assert captured["data"]["name"] == ""
+
+    def test_register_success_output_shape(self, monkeypatch, capsys):
+        self._fake_api(monkeypatch, return_value={"id": "u_1", "email": "alice@example.com", "name": ""})
+        cli.main(["register", "alice@example.com", "p@ss"])
+        out = json.loads(capsys.readouterr().out)
+        assert out["success"] is True
+        assert "data" in out
+
+    def test_register_409_conflict_exits_nonzero(self, monkeypatch, capsys):
+        self._fake_api(monkeypatch, raise_error=cli.APIError(409, {"detail": "Email already registered"}))
+        with pytest.raises(SystemExit) as exc:
+            cli.main(["register", "dup@example.com", "p@ss"])
+
+        assert exc.value.code != 0
+        out = json.loads(capsys.readouterr().out)
+        assert "error" in out
+        assert out["status"] == 409
+
+    def test_register_uses_no_auth_header(self, monkeypatch):
+        """register 是公开接口，不需要已存储的 API key."""
+        captured = self._fake_api(monkeypatch)
+        cli.main(["register", "new@example.com", "p@ss"])
+        assert captured["api_key"] == ""
+
+    def test_register_empty_response_returns_fallback(self, monkeypatch, capsys):
+        """服务端返回空 dict 时，fallback 输出包含 email."""
+        self._fake_api(monkeypatch, return_value={})
+        cli.main(["register", "x@example.com", "p@ss"])
+        out = json.loads(capsys.readouterr().out)
+        assert out["success"] is True
+        assert out["data"]["email"] == "x@example.com"
+
+    def test_register_subcommand_in_parser(self):
+        parser = cli.build_parser()
+        subparsers_action = next(
+            a for a in parser._actions if isinstance(a, cli.argparse._SubParsersAction)
+        )
+        assert "register" in subparsers_action.choices

uno_cli-1.0.4/uno_cli/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.4"

{uno_cli-1.0.2 → uno_cli-1.0.4}/uno_cli/cli.py

@@ -23,7 +23,8 @@ import urllib.request
 
 from uno_cli._version import __version__
 
-DEFAULT_BASE = "https://clawdtools.uno"
+DEFAULT_BASE = "https://agentools.uno"
+LEGACY_BASE = "https://clawdtools.uno"
 CRED_DIR = os.path.expanduser("~/.uno")
 CRED_FILE = os.path.join(CRED_DIR, "credentials.json")
 
@@ -458,9 +459,9 @@ _ERROR_HINTS = {
     "tool_not_found": "Tool not found. Try: uno search <keyword>",
     "insufficient_credits": "Out of credits. Visit the billing page.",
     "auth_required": "OAuth required. Open the auth_url in a browser.",
-    "invalid api key": "API key expired or invalid. Run: uno login",
-    "invalid credentials": "Login required. Run: uno login",
-    "unauthorized": "Login required. Run: uno login",
+    "invalid api key": "API key expired or invalid. Run: uno login --start",
+    "invalid credentials": "Login required. Run: uno login --start",
+    "unauthorized": "Login required. Run: uno login --start",
     "rate limit": "Rate limited. Please wait and retry.",
     "not_found": "Resource not found. Check the ID/slug.",
     "not found": "Resource not found. Check the ID/slug.",
@@ -493,8 +494,19 @@ def _format_api_error(status, body):
                 msgs.append(str(err))
         detail = "; ".join(msgs) if msgs else str(detail)
 
-    result = {"error": str(detail), "status": status}
-    hint = _match_hint(str(detail))
+    result = {"success": False, "error": str(detail), "status": status}
+    if isinstance(body, dict):
+        if body.get("message") and str(body.get("message")) != result["error"]:
+            result["message"] = body["message"]
+        if body.get("meta"):
+            result["meta"] = body["meta"]
+        if body.get("error") and result["error"] != str(body.get("error")):
+            # Prefer the stable gateway code when FastAPI wrapped it.
+            code = body.get("error")
+            if isinstance(code, str) and code and " " not in code:
+                result["error"] = code
+                result["message"] = str(detail)
+    hint = _match_hint(str(result.get("error") or detail))
     if hint:
         result["hint"] = hint
     return result
@@ -505,7 +517,7 @@ def _ok(data):
 
 
 def _fail(msg, **extra):
-    out = {"error": msg}
+    out = {"success": False, "error": msg}
     hint = _match_hint(msg)
     if hint:
         out["hint"] = hint
@@ -531,7 +543,7 @@ def _get_api(args):
     auth = AuthManager(base_url=args.base_url)
     key = auth.load_key()
     if not key:
-        _fail("Not logged in. Run: uno login")
+        _fail("Not logged in. Run: uno login --start")
     return UnoAPI(api_key=key, base_url=args.base_url)
 
 
@@ -543,6 +555,23 @@ def _get_public_api(args):
 # ── Commands ───────────────────────────────────────────────────────
 
 
+def cmd_register(args):
+    email = args.email
+    password = args.password
+    name = getattr(args, "name", "") or ""
+
+    api = UnoAPI(base_url=args.base_url)
+    try:
+        result = api.post("/v1/auth/register", {"email": email, "password": password, "name": name})
+        if isinstance(result, dict) and result.get("error"):
+            _out(result)
+            sys.exit(1)
+        _ok(result if result else {"registered": True, "email": email})
+    except APIError as e:
+        _out(_format_api_error(e.status, e.body))
+        sys.exit(1)
+
+
 def cmd_login(args):
     auth = AuthManager(base_url=args.base_url)
 
@@ -632,6 +661,14 @@ def cmd_tool(args):
             _fail("Tool slug required. Usage: uno tool get <slug>")
         try:
             result = api.get(f"/v1/tools/{slug}")
+            if isinstance(result, dict) and result.get("error"):
+                out = {"success": False, "error": result["error"]}
+                if result.get("message"):
+                    out["message"] = result["message"]
+                if result.get("meta"):
+                    out["meta"] = result["meta"]
+                _out(out)
+                sys.exit(1)
             if isinstance(result, dict) and "data" in result and "error" in result:
                 result = result["data"]
             if result is None:
@@ -707,8 +744,19 @@ def cmd_call(args):
                     out[key] = result[key]
             if result.get("meta"):
                 out["meta"] = result["meta"]
+            else:
+                out["meta"] = {
+                    "credits_used": 0,
+                    "credits_from": {"free": 0, "paid": 0.0},
+                    "charged": False,
+                }
             auth_type = result.get("auth_type", "")
-            if result.get("auth_url"):
+            if auth_type in ("oauth_device", "oauth_device_code", "device_code_api"):
+                out["hint"] = (
+                    "Device-code OAuth. Open auth_url, enter the user code. "
+                    "Do not ask for a key or follow get_key_url."
+                )
+            elif result.get("auth_url"):
                 out["hint"] = "OAuth required. Open auth_url in a browser to authorize."
             elif auth_type == "api_key":
                 out["hint"] = "API key required. Show get_key_url to the user."
@@ -812,13 +860,72 @@ def cmd_health(args):
         sys.exit(1)
 
 
+def cmd_connections(args):
+    """List third-party connections; --reconnect prints auth_url."""
+    api = _get_api(args)
+    reconnect = getattr(args, "reconnect", None)
+    try:
+        result = api.get("/v1/auth/connections")
+        if reconnect:
+            items = result.get("connections") if isinstance(result, dict) else result
+            match = next((c for c in (items or []) if c.get("slug") == reconnect), None)
+            if not match:
+                _fail(f"No connection for {reconnect}")
+            out = {
+                "slug": reconnect,
+                "status": match.get("status"),
+                "connected": match.get("connected"),
+                "platform_held": match.get("platform_held", False),
+            }
+            if match.get("auth_url"):
+                out["auth_url"] = match["auth_url"]
+                out["hint"] = "Open auth_url in a browser to reconnect."
+            _ok(out)
+            return
+        _ok(result)
+    except APIError as e:
+        _out(_format_api_error(e.status, e.body))
+        sys.exit(1)
+
+
+def cmd_auth(args):
+    action = getattr(args, "auth_action", None) or "list"
+    if action == "list":
+        return cmd_connections(args)
+    _fail(f"Unknown auth action: {action}")
+
+
+def cmd_logs(args):
+    """GET /v1/usage/history?limit=N&days=7 — compact call log."""
+    api = _get_api(args)
+    last = getattr(args, "last", 20) or 20
+    try:
+        result = api.get("/v1/usage/history", params={"limit": last, "days": 7})
+        records = result.get("records") if isinstance(result, dict) else result
+        compact = []
+        for r in records or []:
+            compact.append({
+                "tool": r.get("tool"),
+                "latency_ms": r.get("latency_ms"),
+                "credits": r.get("credits"),
+                "success": r.get("success"),
+                "error_code": r.get("error_code"),
+                "created_at": r.get("created_at"),
+            })
+        total = result.get("total", len(compact)) if isinstance(result, dict) else len(compact)
+        _ok({"records": compact, "total": total, "days": 7})
+    except APIError as e:
+        _out(_format_api_error(e.status, e.body))
+        sys.exit(1)
+
+
 # ── Argparse Setup ─────────────────────────────────────────────────
 
 
 def build_parser():
     p = argparse.ArgumentParser(
         prog="uno",
-        description="Uno — Agent tool gateway CLI (2000+ real-world tools)",
+        description="Uno — Agent tool gateway CLI (live catalog via /v1/tools)",
     )
     p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
     p.add_argument("--compact", action="store_true", help="Output compact (single-line) JSON instead of formatted")
@@ -830,6 +937,11 @@ def build_parser():
 
     sub = p.add_subparsers(dest="command")
 
+    register_p = sub.add_parser("register", help="Register a new Uno account")
+    register_p.add_argument("email", help="Email address")
+    register_p.add_argument("password", help="Password")
+    register_p.add_argument("--name", default="", help="Display name (optional)")
+
     login_p = sub.add_parser("login", help="Authenticate with Uno (via ClawdChat SSO)")
     login_p.add_argument("--start", action="store_true", help="Step 1: get device code (non-blocking, for agents)")
     login_p.add_argument("--poll", metavar="DEVICE_CODE", help="Step 2: poll for authorization")
@@ -901,10 +1013,22 @@ def build_parser():
     disc_p = sub.add_parser("disconnect", help="Revoke third-party OAuth/API-key authorization")
     disc_p.add_argument("server", help="Server slug to disconnect (e.g. github, canva)")
 
+    conn_p = sub.add_parser("connections", help="List third-party connections")
+    conn_p.add_argument("--reconnect", metavar="SERVER", help="Print auth_url for a server that needs reconnect")
+
+    auth_p = sub.add_parser("auth", help="Auth helpers (list connections)")
+    auth_sub = auth_p.add_subparsers(dest="auth_action")
+    auth_list = auth_sub.add_parser("list", help="List connections (alias of uno connections)")
+    auth_list.add_argument("--reconnect", metavar="SERVER", help="Print auth_url for a server that needs reconnect")
+
+    logs_p = sub.add_parser("logs", help="Recent call logs (last 7 days)")
+    logs_p.add_argument("--last", type=int, default=20, help="Number of records (default: 20)")
+
     return p
 
 
 COMMAND_MAP = {
+    "register": cmd_register,
     "login": cmd_login,
     "logout": cmd_logout,
     "use": cmd_use,
@@ -917,6 +1041,9 @@ COMMAND_MAP = {
     "keys": cmd_keys,
     "health": cmd_health,
     "disconnect": cmd_disconnect,
+    "connections": cmd_connections,
+    "auth": cmd_auth,
+    "logs": cmd_logs,
 }
 
 

uno_cli-1.0.2/uno_cli/_version.py

@@ -1 +0,0 @@
-__version__ = "1.0.2"