keystone-cli 0.2.1__tar.gz → 0.2.2__tar.gz

{keystone_cli-0.2.1 → keystone_cli-0.2.2}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: keystone-cli
-Version: 0.2.1
+Version: 0.2.2
 Summary: Keystone pro-code agent CLI — build, test, deploy and operate agents on the Keystone platform.
 Requires-Python: >=3.12
 Requires-Dist: keystone-agent-sdk<0.14,>=0.13.3
 Requires-Dist: keystone-request-context<0.4,>=0.3
 Requires-Dist: typer<1,>=0.12
 Requires-Dist: httpx<1,>=0.27
+Requires-Dist: truststore<1,>=0.10
 Provides-Extra: dev
 Requires-Dist: pytest<9,>=8; extra == "dev"
 Requires-Dist: pytest-cov<7,>=6; extra == "dev"

{keystone_cli-0.2.1 → keystone_cli-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "keystone-cli"
-version = "0.2.1"
+version = "0.2.2"
 description = "Keystone pro-code agent CLI — build, test, deploy and operate agents on the Keystone platform."
 requires-python = ">=3.12"
 dependencies = [
@@ -18,6 +18,9 @@ dependencies = [
     "typer>=0.12,<1",
     # `login` (device-flow → Keycloak) + `deploy` (bundle upload → agent-hub via Kong). FDP-3170/3169.
     "httpx>=0.27,<1",
+    # FDP-6328 — verify TLS through the OS trust store (keystone_cli/_tls.py), so a corporate CA in
+    # the macOS Keychain / Windows store works without SSL_CERT_FILE. Pure Python, no dependencies.
+    "truststore>=0.10,<1",
 ]
 
 [project.optional-dependencies]
@@ -45,7 +48,7 @@ where = ["src"]
 keystone_cli = ["templates/*/*.tmpl", "templates/*/pkg/*.tmpl", "skills/*/SKILL.md"]
 
 [tool.ruff]
-target-version = "0.2.1"
+target-version = "0.2.2"
 line-length = 120
 
 [tool.ruff.lint]

{keystone_cli-0.2.1 → keystone_cli-0.2.2}/src/keystone_cli/__main__.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import typer
 
 from keystone_cli._stdio import make_stdio_unicode_safe
+from keystone_cli._tls import use_system_trust_store
 from keystone_cli._version import version_line
 from keystone_cli.commands.agent import agent_app
 from keystone_cli.commands.dev import dev
@@ -45,6 +46,9 @@ def _main(
     ),
 ) -> None:
     """Keystone pro-code agent CLI."""
+    # FDP-6328 — here, not at import: every command passes through this callback before it opens
+    # a connection, while merely importing the app (tests do) leaves the process's `ssl` alone.
+    use_system_trust_store()
 
 
 @app.command(name="version")

keystone_cli-0.2.2/src/keystone_cli/_tls.py

@@ -0,0 +1,40 @@
+"""Verify TLS against the operating system's trust store (FDP-6328).
+
+httpx verifies servers against ``certifi``'s bundled CA list, never the OS store. On a network
+that inspects TLS — TCB's, where a corporate proxy re-signs every HTTPS connection with the
+bank's own CA — that CA is installed in the OS store (macOS Keychain, Windows certificate
+store), so browsers work, but certifi does not know it. Every CLI command then failed with
+``CERTIFICATE_VERIFY_FAILED`` until the user exported ``SSL_CERT_FILE=<corp bundle>`` on each
+call — which REPLACES certifi rather than adding to it, so hosts outside the proxy broke instead.
+
+``truststore`` makes Python's ``ssl`` verify through the OS (Security.framework on macOS,
+CryptoAPI on Windows, OpenSSL with the system paths on Linux) — the approach pip takes for the
+same reason. ``SSL_CERT_FILE`` keeps working on top: httpx hands it to ``load_verify_locations``,
+which truststore adds as extra trust anchors (checked with a local CA and httpx 0.28.1: OS-trusted
+and SSL_CERT_FILE-trusted servers both verify).
+
+``KEYSTONE_SYSTEM_TRUST=0`` turns it off (certifi only, the old behaviour), for the day the OS
+store itself is the problem.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+
+import truststore
+
+ENV_SYSTEM_TRUST = "KEYSTONE_SYSTEM_TRUST"
+_OFF = {"0", "false", "no", "off"}
+
+
+def use_system_trust_store(env: Mapping[str, str] | None = None) -> bool:
+    """Make every TLS connection this process opens verify through the OS trust store.
+
+    Call once, before any HTTP client exists (an ``httpx.Client`` builds its SSL context when it
+    is created). Returns whether it is on. Idempotent: truststore ignores a second injection."""
+    env = os.environ if env is None else env
+    if (env.get(ENV_SYSTEM_TRUST) or "").strip().lower() in _OFF:
+        return False
+    truststore.inject_into_ssl()
+    return True

{keystone_cli-0.2.1 → keystone_cli-0.2.2}/src/keystone_cli.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: keystone-cli
-Version: 0.2.1
+Version: 0.2.2
 Summary: Keystone pro-code agent CLI — build, test, deploy and operate agents on the Keystone platform.
 Requires-Python: >=3.12
 Requires-Dist: keystone-agent-sdk<0.14,>=0.13.3
 Requires-Dist: keystone-request-context<0.4,>=0.3
 Requires-Dist: typer<1,>=0.12
 Requires-Dist: httpx<1,>=0.27
+Requires-Dist: truststore<1,>=0.10
 Provides-Extra: dev
 Requires-Dist: pytest<9,>=8; extra == "dev"
 Requires-Dist: pytest-cov<7,>=6; extra == "dev"

{keystone_cli-0.2.1 → keystone_cli-0.2.2}/src/keystone_cli.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ src/keystone_cli/__init__.py
 src/keystone_cli/__main__.py
 src/keystone_cli/_build_env.py
 src/keystone_cli/_stdio.py
+src/keystone_cli/_tls.py
 src/keystone_cli/_version.py
 src/keystone_cli/agent_logs.py
 src/keystone_cli/agent_skills.py
@@ -145,6 +146,7 @@ tests/test_skills.py
 tests/test_status.py
 tests/test_stdio.py
 tests/test_threads.py
+tests/test_tls.py
 tests/test_tool_credentials.py
 tests/test_traces.py
 tests/test_version.py

{keystone_cli-0.2.1 → keystone_cli-0.2.2}/src/keystone_cli.egg-info/requires.txt

@@ -2,6 +2,7 @@ keystone-agent-sdk<0.14,>=0.13.3
 keystone-request-context<0.4,>=0.3
 typer<1,>=0.12
 httpx<1,>=0.27
+truststore<1,>=0.10
 
 [dev]
 pytest<9,>=8

keystone_cli-0.2.2/tests/test_tls.py

@@ -0,0 +1,125 @@
+"""FDP-6328 — TLS verifies through the OS trust store, so a corporate CA works without SSL_CERT_FILE."""
+
+from __future__ import annotations
+
+import http.server
+import shutil
+import ssl
+import subprocess
+import threading
+from collections.abc import Iterator
+from pathlib import Path
+
+import httpx
+import pytest
+import truststore
+from typer.testing import CliRunner
+
+from keystone_cli import _tls
+from keystone_cli.__main__ import app
+
+runner = CliRunner()
+
+
+def _record_injections(monkeypatch) -> list[bool]:
+    calls: list[bool] = []
+    monkeypatch.setattr(_tls.truststore, "inject_into_ssl", lambda: calls.append(True))
+    return calls
+
+
+def test_on_by_default(monkeypatch) -> None:
+    calls = _record_injections(monkeypatch)
+    assert _tls.use_system_trust_store(env={}) is True
+    assert calls == [True]
+
+
+@pytest.mark.parametrize("value", ["0", "false", "No", " off "])
+def test_opt_out_keeps_certifi(monkeypatch, value) -> None:
+    calls = _record_injections(monkeypatch)
+    assert _tls.use_system_trust_store(env={"KEYSTONE_SYSTEM_TRUST": value}) is False
+    assert calls == []
+
+
+def test_every_command_turns_it_on(monkeypatch) -> None:
+    seen: list[bool] = []
+    monkeypatch.setattr("keystone_cli.__main__.use_system_trust_store", lambda: seen.append(True) or True)
+    result = runner.invoke(app, ["version"])
+    assert result.exit_code == 0, result.output
+    assert seen == [True]
+
+
+# ── end to end: a server signed by a "corporate" CA, as a TLS-inspecting proxy presents ──
+
+
+def _openssl(*args: str, cwd: Path) -> None:
+    subprocess.run(["openssl", *args], cwd=cwd, check=True, capture_output=True)  # noqa: S603, S607
+
+
+@pytest.fixture
+def corp_server(tmp_path: Path) -> Iterator[tuple[str, Path]]:
+    if shutil.which("openssl") is None:
+        pytest.skip("openssl binary not available")
+    _openssl("req", "-x509", "-newkey", "rsa:2048", "-nodes", "-keyout", "ca.key", "-out", "ca.pem",
+             "-days", "2", "-subj", "/CN=Test Corp CA", cwd=tmp_path)  # fmt: skip
+    _openssl("req", "-newkey", "rsa:2048", "-nodes", "-keyout", "srv.key", "-out", "srv.csr",
+             "-subj", "/CN=localhost", cwd=tmp_path)  # fmt: skip
+    # macOS (Security.framework) refuses a server cert without serverAuth usage.
+    (tmp_path / "ext.cnf").write_text(
+        "subjectAltName=DNS:localhost,IP:127.0.0.1\nextendedKeyUsage=serverAuth\n"
+        "keyUsage=digitalSignature,keyEncipherment\nbasicConstraints=CA:FALSE\n",
+        encoding="utf-8",
+    )
+    _openssl("x509", "-req", "-in", "srv.csr", "-CA", "ca.pem", "-CAkey", "ca.key", "-CAcreateserial",
+             "-out", "srv.pem", "-days", "2", "-extfile", "ext.cnf", cwd=tmp_path)  # fmt: skip
+
+    server = http.server.HTTPServer(("127.0.0.1", 0), http.server.BaseHTTPRequestHandler)
+    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+    ctx.load_cert_chain(tmp_path / "srv.pem", tmp_path / "srv.key")
+    server.socket = ctx.wrap_socket(server.socket, server_side=True)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    try:
+        yield f"https://localhost:{server.server_address[1]}/", tmp_path / "ca.pem"
+    finally:
+        server.shutdown()
+
+
+@pytest.fixture
+def system_trust(monkeypatch) -> Iterator[None]:
+    monkeypatch.delenv("KEYSTONE_SYSTEM_TRUST", raising=False)
+    assert _tls.use_system_trust_store() is True
+    try:
+        yield
+    finally:
+        truststore.extract_from_ssl()  # undo the process-wide patch for the rest of the suite
+
+
+def _verifies(url: str) -> bool:
+    try:
+        with httpx.Client(timeout=10) as client:
+            client.get(url)  # any HTTP status is fine — only the handshake matters
+    except httpx.ConnectError as exc:
+        assert "certif" in str(exc).lower() or "trust" in str(exc).lower(), exc
+        return False
+    return True
+
+
+def test_httpx_verifies_through_the_os_store_once_on(system_trust) -> None:
+    # httpx (0.27/0.28) builds its context with ssl.create_default_context(); after the injection
+    # that is truststore's, i.e. verification goes through Keychain / the Windows store.
+    assert isinstance(ssl.create_default_context(), truststore.SSLContext)
+    with httpx.Client() as client:
+        transport = client._transport  # noqa: SLF001 — the only place httpx keeps the context
+        assert isinstance(transport._pool._ssl_context, truststore.SSLContext)  # noqa: SLF001
+
+
+def test_an_unknown_corporate_ca_is_still_rejected(corp_server, system_trust, monkeypatch) -> None:
+    url, _ca = corp_server
+    monkeypatch.delenv("SSL_CERT_FILE", raising=False)
+    assert _verifies(url) is False  # the OS store is used, verification is NOT switched off
+
+
+def test_ssl_cert_file_still_adds_a_ca_on_top_of_the_os_store(corp_server, system_trust, monkeypatch) -> None:
+    # Users who already export SSL_CERT_FILE (the 0.2.1 workaround) must not break on upgrade.
+    url, ca = corp_server
+    monkeypatch.setenv("SSL_CERT_FILE", str(ca))
+    assert _verifies(url) is True