uno-cli 1.0.1__tar.gz → 1.0.3__tar.gz

{uno_cli-1.0.1 → uno_cli-1.0.3}/.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.1 → uno_cli-1.0.3}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: uno-cli
-Version: 1.0.1
+Version: 1.0.3
 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.1 → uno_cli-1.0.3}/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.1 → uno_cli-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uno-cli"
-version = "1.0.1"
+version = "1.0.3"
 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.1 → uno_cli-1.0.3}/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())
 
@@ -121,6 +138,23 @@ class TestErrorHints:
         out = cli._format_api_error(500, "server exploded")
         assert out["error"] == "server exploded"
 
+    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
+
 
 # ── JSON output shape of _out ──────────────────────────────────────
 

uno_cli-1.0.3/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.3/tests/test_dry_run.py

@@ -0,0 +1,138 @@
+"""--dry-run preview tests.
+
+``uno call --dry-run <tool>`` is the primary user-confirmation surface: it
+formats the planned invocation (tool + arguments) as JSON without reading any
+credential, opening any socket, or spending any credit. These tests are the
+safety net that guarantees the dry-run remains strictly local.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+import pytest
+
+from uno_cli import cli
+
+
+# ── Shared fake API that explodes if ever called ───────────────────
+
+
+class _PanicAPI:
+    """Any method on this class raises — a dry-run must never hit it."""
+
+    def __init__(self, *a, **kw):
+        raise AssertionError(
+            "dry-run called the network client; it must not touch the network"
+        )
+
+
+# ── Parser surface ─────────────────────────────────────────────────
+
+
+class TestDryRunFlag:
+    def test_dry_run_flag_defaults_to_false(self):
+        parser = cli.build_parser()
+        args = parser.parse_args(["call", "weather.get", "--args", "{}"])
+        assert args.dry_run is False
+
+    def test_dry_run_flag_parsed_when_present(self):
+        parser = cli.build_parser()
+        args = parser.parse_args(["call", "--dry-run", "weather.get", "--args", "{}"])
+        assert args.dry_run is True
+
+    def test_dry_run_flag_trailing_position_also_works(self):
+        parser = cli.build_parser()
+        args = parser.parse_args(["call", "weather.get", "--args", "{}", "--dry-run"])
+        assert args.dry_run is True
+
+
+# ── cmd_call dry-run path ──────────────────────────────────────────
+
+
+class TestDryRunCall:
+    def _run_dry_run(self, monkeypatch, capsys, *, tool, args_json):
+        """Invoke cmd_call in dry-run mode; any network attempt explodes."""
+        # If _get_api / UnoAPI ever gets called, the test fails loudly.
+        monkeypatch.setattr(cli, "_get_api", lambda a: _PanicAPI())
+        monkeypatch.setattr(cli, "UnoAPI", _PanicAPI)
+
+        ns = argparse.Namespace(
+            tool=tool,
+            args=args_json,
+            timeout=60,
+            dry_run=True,
+            base_url="https://clawdtools.uno",
+        )
+        cli.cmd_call(ns)
+        return json.loads(capsys.readouterr().out)
+
+    def test_dry_run_returns_preview_without_network(self, monkeypatch, capsys):
+        out = self._run_dry_run(
+            monkeypatch,
+            capsys,
+            tool="weather-free.weather_now",
+            args_json='{"city": "Beijing"}',
+        )
+        assert out["success"] is True
+        assert out["dry_run"] is True
+        assert out["preview"]["tool"] == "weather-free.weather_now"
+        assert out["preview"]["arguments"] == {"city": "Beijing"}
+        assert out["preview"]["timeout_seconds"] == 60
+        assert "No network request" in out["note"]
+
+    def test_dry_run_with_empty_args_returns_empty_dict(self, monkeypatch, capsys):
+        out = self._run_dry_run(
+            monkeypatch, capsys, tool="time.get_current_time", args_json=None
+        )
+        assert out["preview"]["arguments"] == {}
+
+    def test_dry_run_without_credentials_still_works(self, monkeypatch, capsys):
+        """Dry-run must not call _get_api, so even unauthenticated users can
+        preview an invocation."""
+
+        def _panic(*a, **kw):
+            raise AssertionError("dry-run read credentials; it must not.")
+
+        monkeypatch.setattr(cli.AuthManager, "load_key", _panic)
+        self._run_dry_run(
+            monkeypatch,
+            capsys,
+            tool="weather-free.weather_now",
+            args_json='{"city": "Tokyo"}',
+        )
+
+    def test_dry_run_respects_scope_guard(self, monkeypatch, capsys):
+        """Dry-run should still be blocked by UNO_ALLOWED_TOOLS — a skill
+        scoped to gpt-image-2 should not be able to preview a call to github
+        even in dry-run mode."""
+        monkeypatch.setenv("UNO_ALLOWED_TOOLS", "gpt-image-2.*")
+        monkeypatch.setattr(cli, "_get_api", lambda a: _PanicAPI())
+
+        ns = argparse.Namespace(
+            tool="github.create_issue",
+            args='{"title": "x"}',
+            timeout=60,
+            dry_run=True,
+            base_url="https://clawdtools.uno",
+        )
+        with pytest.raises(SystemExit) as excinfo:
+            cli.cmd_call(ns)
+        assert excinfo.value.code == 1
+        out = json.loads(capsys.readouterr().out)
+        assert out["error"] == "tool_not_allowed"
+
+    def test_dry_run_preview_does_not_leak_secrets(self, monkeypatch, capsys):
+        """If the user passes an api_key-looking arg, the normal output
+        stripper should still redact it on the way out."""
+        out = self._run_dry_run(
+            monkeypatch,
+            capsys,
+            tool="some-tool.run",
+            args_json='{"api_key": "uno_should_be_masked_longlonglong"}',
+        )
+        # _out passes everything through _strip_secrets; the api_key field
+        # inside preview.arguments is a legitimate tool arg, but the masker
+        # errs on the side of caution by key-name.
+        assert "uno_should_be_masked_longlonglong" not in json.dumps(out)

uno_cli-1.0.3/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.3/uno_cli/_version.py

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

{uno_cli-1.0.1 → uno_cli-1.0.3}/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.",
@@ -531,7 +532,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 +544,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)
 
@@ -655,11 +673,10 @@ def cmd_call(args):
             allowed=allowed_patterns,
             hint=(
                 "This skill is scoped to a subset of Uno tools. "
-                "Install uno-cli separately to access the full 2000+ tool catalog."
+                "Install uno-cli separately to access the full tool catalog."
             ),
         )
 
-    api = _get_api(args)
     arguments = {}
     raw_args = getattr(args, "args", None)
     if raw_args:
@@ -674,6 +691,30 @@ def cmd_call(args):
             _fail(f"Invalid JSON in --args: {e}")
 
     timeout = getattr(args, "timeout", 60) or 60
+
+    # Dry-run preview: format the planned invocation without authenticating,
+    # issuing any network request, or spending credits. This is the primary
+    # "user confirmation" surface — an agent is expected to dry-run a call,
+    # show the JSON to the human, and only re-run without --dry-run after
+    # explicit approval. Read-only and credentials-free by construction.
+    if getattr(args, "dry_run", False):
+        _out({
+            "success": True,
+            "dry_run": True,
+            "preview": {
+                "tool": tool_slug,
+                "arguments": arguments,
+                "timeout_seconds": timeout,
+            },
+            "note": (
+                "No network request was made, no credentials were read, and "
+                "no credits were spent. Re-run without --dry-run to actually "
+                "invoke the tool."
+            ),
+        })
+        return
+
+    api = _get_api(args)
     try:
         result = api.post("/v1/call", {"tool": tool_slug, "arguments": arguments}, timeout=timeout)
         if result.get("error"):
@@ -789,13 +830,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")
@@ -807,6 +907,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")
@@ -839,6 +944,7 @@ def build_parser():
             "Examples:\n"
             "  uno call time.get_current_time --args '{\"timezone\":\"Asia/Shanghai\"}'\n"
             "  uno call weather-cn.weatherArea --args '{\"area\":\"Beijing\"}'\n"
+            "  uno call --dry-run weather-cn.weatherArea --args '{\"area\":\"Beijing\"}'\n"
             "  uno call twelve-data.quote --args '{\"symbol\":\"AAPL\"}' --timeout 30\n\n"
             "Scope enforcement (for single-purpose skills):\n"
             "  UNO_ALLOWED_TOOLS='gpt-image-2.*,time.*'   # comma-separated glob whitelist"
@@ -847,6 +953,11 @@ def build_parser():
     )
     call_p.add_argument("tool", help="Tool slug (e.g. weather-cn.weatherArea)")
     call_p.add_argument("--args", help='JSON arguments (e.g. \'{"city":"Beijing"}\')')
+    call_p.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview the planned invocation without issuing any network request or spending credits.",
+    )
     call_p.add_argument("--timeout", type=int, default=60, help="Request timeout in seconds (default: 60)")
 
     rate_p = sub.add_parser("rate", help="Rate a tool (0-5)")
@@ -872,10 +983,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,
@@ -888,6 +1011,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.1/uno_cli/_version.py

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