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

{uno_cli-1.0.0 → uno_cli-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uno-cli
-Version: 1.0.0
+Version: 1.0.1
 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

{uno_cli-1.0.0 → uno_cli-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uno-cli"
-version = "1.0.0"
+version = "1.0.1"
 description = "Uno CLI — Agent tool gateway by ClawdChat. Access 2000+ real-world tools from the command line."
 readme = "README.md"
 requires-python = ">=3.8"

{uno_cli-1.0.0 → uno_cli-1.0.1}/tests/test_auth.py

@@ -120,7 +120,15 @@ class TestLoginWithKey:
 
         monkeypatch.setattr(cli, "UnoAPI", _FakeAPI)
         result = cli.AuthManager().login_with_key("uno_key_abc")
-        assert result == {"success": True, "name": "Alice", "email": "a@e.com"}
+        assert result["success"] is True
+        assert result["name"] == "Alice"
+        assert result["email"] == "a@e.com"
+        assert result["credential_stored_at"] == cli.CRED_FILE
+        assert result["credential_file_mode"] == "0600"
+        # Critical: the raw API key must never appear in the login response
+        # (it is persisted to the credentials file below, but never echoed).
+        import json as _json
+        assert "uno_key_abc" not in _json.dumps(result)
         with open(cli.CRED_FILE) as f:
             data = json.load(f)
         assert data[0]["api_key"] == "uno_key_abc"

uno_cli-1.0.1/tests/test_token_masking.py

@@ -0,0 +1,148 @@
+"""Security-posture tests — stdout must NEVER contain a full API token.
+
+Any raw token would let an attacker who can read the terminal, shell history,
+or an agent's stdout buffer hijack the user's account. The CLI funnels every
+response through ``_strip_secrets`` in ``_out`` so the invariant holds even
+if a future contributor forgets to mask manually.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+
+import pytest
+
+from uno_cli import cli
+
+
+RAW_TOKEN = "uno_abcdefghijklmnopqrstuvwxyz0123456789WXYZ"
+
+
+# ── _mask_token ────────────────────────────────────────────────────
+
+
+class TestMaskToken:
+    def test_long_token_shows_prefix_and_suffix_only(self):
+        out = cli._mask_token(RAW_TOKEN)
+        assert out.startswith(RAW_TOKEN[:8])
+        assert out.endswith(RAW_TOKEN[-4:])
+        assert "..." in out
+        assert RAW_TOKEN not in out
+
+    def test_short_value_becomes_triple_asterisk(self):
+        assert cli._mask_token("short") == "***"
+
+    def test_none_stays_none(self):
+        assert cli._mask_token(None) is None
+
+    def test_non_string_values_unchanged(self):
+        assert cli._mask_token(42) == 42
+        assert cli._mask_token(["list"]) == ["list"]
+
+
+# ── _strip_secrets ─────────────────────────────────────────────────
+
+
+class TestStripSecrets:
+    def test_top_level_api_key_field_is_masked(self):
+        out = cli._strip_secrets({"api_key": RAW_TOKEN, "name": "alice"})
+        assert out["api_key"] != RAW_TOKEN
+        assert RAW_TOKEN not in json.dumps(out)
+        assert out["name"] == "alice"
+
+    @pytest.mark.parametrize(
+        "field",
+        [
+            "api_key",
+            "apiKey",
+            "API_KEY",
+            "access_token",
+            "refresh_token",
+            "secret",
+            "client_secret",
+            "password",
+            "token",
+        ],
+    )
+    def test_known_secret_field_names_are_all_masked(self, field):
+        out = cli._strip_secrets({field: RAW_TOKEN})
+        assert RAW_TOKEN not in json.dumps(out), f"{field} not masked"
+
+    def test_nested_dict_secret_is_masked(self):
+        out = cli._strip_secrets({"data": {"api_key": RAW_TOKEN, "email": "a@b.c"}})
+        assert RAW_TOKEN not in json.dumps(out)
+        assert out["data"]["email"] == "a@b.c"
+
+    def test_list_of_dicts_is_masked(self):
+        items = [
+            {"name": "k1", "api_key": RAW_TOKEN},
+            {"name": "k2", "api_key": RAW_TOKEN + "_2"},
+        ]
+        out = cli._strip_secrets({"keys": items})
+        assert RAW_TOKEN not in json.dumps(out)
+        assert out["keys"][0]["name"] == "k1"
+
+    def test_non_secret_lookalike_field_untouched(self):
+        out = cli._strip_secrets({"description": "the api_key field is secret"})
+        assert out["description"] == "the api_key field is secret"
+
+    def test_key_id_is_not_a_secret(self):
+        out = cli._strip_secrets({"key_id": "kid_abc", "description": "x"})
+        assert out["key_id"] == "kid_abc"
+
+
+# ── _out chokepoint ────────────────────────────────────────────────
+
+
+class TestOutChokepoint:
+    def test_out_masks_api_key_before_printing(self, capsys):
+        cli._out({"success": True, "api_key": RAW_TOKEN})
+        captured = capsys.readouterr()
+        assert RAW_TOKEN not in captured.out
+        payload = json.loads(captured.out)
+        assert payload["success"] is True
+        assert payload["api_key"] != RAW_TOKEN
+
+    def test_out_masks_nested_access_token(self, capsys):
+        cli._out({"data": {"tokens": [{"access_token": RAW_TOKEN}]}})
+        out = capsys.readouterr().out
+        assert RAW_TOKEN not in out
+
+    def test_out_preserves_non_secret_structure(self, capsys):
+        cli._out({"success": True, "data": {"name": "alice", "credits": 500}})
+        payload = json.loads(capsys.readouterr().out)
+        assert payload["data"]["name"] == "alice"
+        assert payload["data"]["credits"] == 500
+
+
+# ── Callsite regression ────────────────────────────────────────────
+
+
+class TestLoginReturnShape:
+    """The return dicts from AuthManager login paths must not carry the raw
+    token even if _out is bypassed (defense in depth). We verify by building a
+    real return payload the way ``login_device_poll`` would."""
+
+    def test_login_device_poll_success_shape_has_no_api_key(self):
+        source = (cli.__file__,)
+        import pathlib
+
+        text = pathlib.Path(source[0]).read_text(encoding="utf-8")
+        # Confirm the obvious leak patterns are gone:
+        assert '"api_key": access_token' not in text, (
+            "login_device_poll must not return the raw access_token under an "
+            "api_key field; agents should read ~/.uno/credentials.json instead."
+        )
+
+    def test_credential_stored_at_is_advertised(self):
+        """Positive marker: successful login responses include a
+        ``credential_stored_at`` field pointing at the file on disk."""
+        import pathlib
+
+        text = pathlib.Path(cli.__file__).read_text(encoding="utf-8")
+        assert text.count('"credential_stored_at": CRED_FILE') >= 3, (
+            "All login success paths (login_with_key + login_device_poll main "
+            "+ fallback) should advertise the credential file location so "
+            "callers know where the token actually lives."
+        )

uno_cli-1.0.1/uno_cli/_version.py

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

{uno_cli-1.0.0 → uno_cli-1.0.1}/uno_cli/cli.py

@@ -45,6 +45,57 @@ ALLOWED_TOOLS_ENV = "UNO_ALLOWED_TOOLS"
 CALLER_SKILL_ENV = "UNO_CALLER_SKILL"
 
 
+# ── Secret Masking (security posture: no token ever leaves via stdout) ──
+#
+# Every response written with ``_out`` is passed through ``_strip_secrets``.
+# Any dict field whose key name matches a known secret-ish name has its value
+# replaced with a short masked preview (``uno_abcd...wxyz``). The raw token
+# itself is still written to ``~/.uno/credentials.json`` (mode 0600) by
+# ``AuthManager.save_account``; CI jobs that genuinely need the raw value can
+# read the credentials file directly — the CLI does not provide a ``--show-
+# key`` escape hatch so that the code surface is trivially auditable.
+_SECRET_FIELD_NAMES = frozenset({
+    "api_key",
+    "apikey",
+    "access_token",
+    "refresh_token",
+    "secret",
+    "client_secret",
+    "password",
+    "token",
+})
+
+
+def _mask_token(value):
+    """Return a short preview of a token-like string.
+
+    ``uno_abcdefghij…wxyz`` for inputs ≥ 12 chars, else ``***``.
+    Non-string values are returned unchanged (``None``, numeric key-ids, etc.).
+    """
+    if not isinstance(value, str):
+        return value
+    if len(value) < 12:
+        return "***"
+    return f"{value[:8]}...{value[-4:]}"
+
+
+def _strip_secrets(obj):
+    """Recursively replace any secret-ish field value with a masked preview.
+
+    Applied to **every** payload written to stdout via ``_out``. This is the
+    single chokepoint so there is no code path in the CLI that can leak a raw
+    token to stdout, regardless of what the server returns.
+    """
+    if isinstance(obj, dict):
+        return {
+            k: (_mask_token(v) if isinstance(k, str) and k.lower() in _SECRET_FIELD_NAMES else _strip_secrets(v))
+            for k, v in obj.items()
+        }
+    if isinstance(obj, list):
+        return [_strip_secrets(x) for x in obj]
+    return obj
+
+
 # ── HTTP Client ────────────────────────────────────────────────────
 
 
@@ -259,7 +310,13 @@ class AuthManager:
             return {"error": "API Key invalid or user not found"}
 
         self.save_account(key, name, email, user_id)
-        return {"success": True, "name": name, "email": email}
+        return {
+            "success": True,
+            "name": name,
+            "email": email,
+            "credential_stored_at": CRED_FILE,
+            "credential_file_mode": "0600",
+        }
 
     def login_device_start(self):
         """Step 1: request device code. Returns JSON with verification URL.
@@ -332,6 +389,10 @@ class AuthManager:
                 return {"error": "No access token in response"}
 
             verify_api = UnoAPI(api_key=access_token, base_url=self.base_url)
+            # Token is persisted to the credentials file but intentionally NOT
+            # returned in the response dict. ``_out`` would mask it anyway, but
+            # keeping the raw value out of every return path means there is no
+            # source-level location where a token can leak into stdout.
             try:
                 me = verify_api.get("/v1/auth/me")
                 name = me.get("name", "")
@@ -342,11 +403,16 @@ class AuthManager:
                     "success": True,
                     "name": name,
                     "email": email,
-                    "api_key": access_token,
+                    "credential_stored_at": CRED_FILE,
+                    "credential_file_mode": "0600",
                 }
             except APIError:
                 self.save_account(access_token, "user", "", "")
-                return {"success": True, "api_key": access_token}
+                return {
+                    "success": True,
+                    "credential_stored_at": CRED_FILE,
+                    "credential_file_mode": "0600",
+                }
 
         return {"error": "Authorization timeout"}
 
@@ -449,8 +515,15 @@ def _fail(msg, **extra):
 
 
 def _out(obj):
+    """Write a JSON response to stdout, with any secret fields masked.
+
+    All CLI responses funnel through this function. ``_strip_secrets`` is the
+    single place where token-like fields are redacted before they can reach
+    the terminal, shell history, log files, or an agent's stdout buffer.
+    """
+    safe = _strip_secrets(obj)
     indent = None if getattr(_out, "compact", False) else 2
-    print(json.dumps(obj, indent=indent, ensure_ascii=False, default=str))
+    print(json.dumps(safe, indent=indent, ensure_ascii=False, default=str))
 
 
 def _get_api(args):

uno_cli-1.0.0/uno_cli/_version.py

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