codna 0.1.26__tar.gz → 0.1.27__tar.gz

{codna-0.1.26 → codna-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.1.26
+Version: 0.1.27
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.1.26 → codna-0.1.27}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.1.26"
+__version__ = "0.1.27"

{codna-0.1.26 → codna-0.1.27}/codna/agent-core/run-server.bundle.mjs

@@ -110643,7 +110643,7 @@ var init_bowser = __esm(() => {
 
 // vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/home/runner/work/codna/codna/cli/codna-0.1.26/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/home/runner/work/codna/codna/cli/codna-0.1.27/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var retry2 = require_retry2();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();

{codna-0.1.26 → codna-0.1.27}/codna/keystore.py

@@ -6,17 +6,20 @@ card (Supabase-authed, encrypted server-side): same "add your key" idea, storage
 model call runs. Here the call runs locally, so the key lives in the OS secure store (macOS Keychain,
 Windows Credential Manager, Linux Secret Service) via ``keyring`` — not a plaintext ``.env``.
 
-Resolution (see ``cli._runtime_keys`` + ``runtime.config``): an explicit env var always wins, then the
-keychain, then a legacy ``keys.txt``. The value is write-only from the CLI (``codna key set`` reads it
-via a no-echo prompt / stdin, never argv) and is never printed back.
-
-Every ``keyring`` touch is lazy + defensive: on a headless box with no backend, reads degrade to
-"absent" (the engine falls back to env) and writes raise :class:`KeystoreError` with an actionable hint
-— the fix hot path is never crashed by a missing keychain.
+Resolution (see ``cli._runtime_keys`` + ``runtime.config``): an explicit env var always wins, then
+Codna-indexed keychain entries, then a legacy source-checkout ``keys.txt``. The value is write-only
+from the CLI (``codna key set`` reads it via a no-echo prompt / stdin, never argv) and is never
+printed back.
+
+Runtime discovery reads a local non-secret key-name index first. If Codna has never stored key names
+on this device, discovery does not probe the OS keychain just to find absence. Explicit writes/removes
+still surface :class:`KeystoreError` with an actionable hint.
 """
 from __future__ import annotations
 
+import json
 import os
+from pathlib import Path
 
 from .runtime.config import ConfigValue
 
@@ -24,6 +27,7 @@ SERVICE = "codna"
 # Index entry: keyring backends can't enumerate stored items, so we keep our own name index under a
 # reserved username. (No secret lives in the index — only key NAMES.)
 _INDEX_USERNAME = "__codna_key_index__"
+_LOCAL_INDEX_NAME = "keychain-index.json"
 
 # Provider/LLM keys the local engine forwards to the fixing agent (mirror of
 # runtime.local_stack.PROVIDER_CHILD_ENV_KEYS) + the Codna engine key. Only these may be stored.
@@ -105,23 +109,93 @@ def available() -> bool:
         return False
 
 
+def _state_root() -> Path:
+    override = os.environ.get("CODNA_RUNTIME_ROOT")
+    if override:
+        return Path(override).expanduser()
+    return Path.home() / ".codna"
+
+
+def _local_index_path() -> Path:
+    return _state_root() / "keys" / _LOCAL_INDEX_NAME
+
+
+def _normalize_index_names(names: list[str]) -> list[str]:
+    return sorted({name for name in names if name in MANAGED_KEYS})
+
+
+def _read_local_index() -> list[str] | None:
+    path = _local_index_path()
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return None
+    except Exception:  # noqa: BLE001 - malformed local metadata must not trigger keychain probes
+        return []
+    names = payload.get("keys") if isinstance(payload, dict) else None
+    if not isinstance(names, list):
+        return []
+    return _normalize_index_names([str(name) for name in names])
+
+
+def _write_local_index(names: list[str]) -> None:
+    path = _local_index_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    payload = {"schema_version": 1, "keys": _normalize_index_names(names)}
+    with tmp.open("w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=2, sort_keys=True)
+        handle.write("\n")
+        handle.flush()
+        os.fsync(handle.fileno())
+    os.replace(tmp, path)
+    try:
+        dir_fd = os.open(str(path.parent), os.O_RDONLY)
+    except OSError:
+        return
+    try:
+        os.fsync(dir_fd)
+    finally:
+        os.close(dir_fd)
+
+
+def _read_keychain_index() -> list[str]:
+    kr = _keyring()
+    raw = kr.get_password(SERVICE, _INDEX_USERNAME)
+    # str() defends against a non-conformant backend returning a non-string (keyring's contract is
+    # Optional[str], but `codna key list/set/rm` must not traceback on a misbehaving third-party store).
+    names = [n.strip() for n in str(raw or "").split(",") if n.strip()]
+    return _normalize_index_names(names)
+
+
+def _write_keychain_index(names: list[str]) -> None:
+    kr = _keyring()
+    kr.set_password(SERVICE, _INDEX_USERNAME, ",".join(_normalize_index_names(names)))
+
+
 def _read_index() -> list[str]:
+    local = _read_local_index()
+    if local is not None:
+        return local
+    # No local non-secret index means Codna has not explicitly stored key names on this device.
+    # Do not probe the OS keychain just to discover absence; that causes repeated prompts.
+    return []
+
+
+def _read_index_for_explicit_write() -> list[str]:
+    local = _read_local_index()
+    if local is not None:
+        return local
     try:
-        kr = _keyring()
-        raw = kr.get_password(SERVICE, _INDEX_USERNAME)
-        # str() defends against a non-conformant backend returning a non-string (keyring's contract is
-        # Optional[str], but `codna key list/set/rm` must not traceback on a misbehaving third-party store).
-        names = [n.strip() for n in str(raw or "").split(",") if n.strip()]
+        return _read_keychain_index()
     except Exception:  # noqa: BLE001
         return []
-    # Only surface names we still manage (defends against a hand-edited/legacy index).
-    return [n for n in names if n in MANAGED_KEYS]
 
 
 def _write_index(names: list[str]) -> None:
-    kr = _keyring()
-    unique = sorted({n for n in names if n in MANAGED_KEYS})
-    kr.set_password(SERVICE, _INDEX_USERNAME, ",".join(unique))
+    unique = _normalize_index_names(names)
+    _write_local_index(unique)
+    _write_keychain_index(unique)
 
 
 def set_key(name: str, value: str) -> str:
@@ -135,7 +209,7 @@ def set_key(name: str, value: str) -> str:
         kr.set_password(SERVICE, key, token)
     except Exception as exc:  # noqa: BLE001 - backend write failure
         raise KeystoreError(f"could not write to the OS keychain: {type(exc).__name__}") from exc
-    index = _read_index()
+    index = _read_index_for_explicit_write()
     if key not in index:
         _write_index([*index, key])
     return key

{codna-0.1.26 → codna-0.1.27}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.1.26
+Version: 0.1.27
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.1.26 → codna-0.1.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.1.26"
+version = "0.1.27"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"

{codna-0.1.26 → codna-0.1.27}/tests/test_keys_file_dev_only.py

@@ -41,6 +41,22 @@ def test_runtime_keys_ignores_keys_txt_when_installed(monkeypatch, tmp_path):
     assert cli._runtime_keys() == {}
 
 
+def test_runtime_keys_does_not_probe_keychain_without_local_index(monkeypatch, tmp_path):
+    """A clean user install must not trigger OS-level keychain prompts just to discover no keys."""
+    monkeypatch.delenv("CODNA_KEYS_FILE", raising=False)
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
+    monkeypatch.setattr(cli, "__file__", "/venv/lib/python3.12/site-packages/codna/cli.py")
+
+    from codna import keystore
+
+    def forbidden_keyring():
+        raise AssertionError("clean install runtime key discovery must not touch OS keychain")
+
+    monkeypatch.setattr(keystore, "_keyring", forbidden_keyring)
+
+    assert cli._runtime_keys() == {}
+
+
 def test_runtime_keys_reads_keys_txt_in_source_checkout(monkeypatch, tmp_path):
     monkeypatch.delenv("CODNA_KEYS_FILE", raising=False)
     repo = tmp_path / "codna-repo"

{codna-0.1.26 → codna-0.1.27}/tests/test_keystore.py

@@ -28,7 +28,8 @@ class _FakeKeyring:
 
 
 @pytest.fixture
-def kr(monkeypatch):
+def kr(monkeypatch, tmp_path):
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
     fake = _FakeKeyring()
     mod = types.SimpleNamespace(
         get_password=fake.get_password,
@@ -105,14 +106,26 @@ def test_disable_keychain_env_blocks_all_keyring_access(monkeypatch):
         keystore.set_key("anthropic", "x")
 
 
-def test_stored_key_names_does_not_read_secret_values(monkeypatch):
-    def get_password(_service: str, username: str):
-        if username == keystore._INDEX_USERNAME:
-            return "ANTHROPIC_API_KEY"
-        raise AssertionError("listing keys must not read secret values")
+def test_no_local_index_does_not_probe_keychain(monkeypatch, tmp_path):
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
 
-    mod = types.SimpleNamespace(get_password=get_password)
-    monkeypatch.setattr(keystore, "_keyring", lambda: mod)
+    def forbidden_keyring():
+        raise AssertionError("runtime key discovery must not probe an unindexed OS keychain")
+
+    monkeypatch.setattr(keystore, "_keyring", forbidden_keyring)
+
+    assert keystore.stored_key_names() == []
+    assert keystore.config_values() == {}
+
+
+def test_stored_key_names_does_not_read_secret_values(monkeypatch, tmp_path):
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
+    keystore._write_local_index(["ANTHROPIC_API_KEY"])
+
+    def forbidden_keyring():
+        raise AssertionError("listing keys must not read OS keychain secret values")
+
+    monkeypatch.setattr(keystore, "_keyring", forbidden_keyring)
 
     assert keystore.stored_key_names() == ["ANTHROPIC_API_KEY"]
 

{codna-0.1.26 → codna-0.1.27}/tests/test_wheel_smoke_script.py

@@ -77,6 +77,17 @@ def _package_metadata() -> dict[str, object]:
     }
 
 
+def test_smoke_env_disables_pip_keyring_only(monkeypatch):
+    tool = _load_script()
+    monkeypatch.delenv("CODNA_DISABLE_KEYCHAIN", raising=False)
+    monkeypatch.delenv("PIP_KEYRING_PROVIDER", raising=False)
+
+    env = tool.smoke_env({})
+
+    assert "CODNA_DISABLE_KEYCHAIN" not in env
+    assert env["PIP_KEYRING_PROVIDER"] == "disabled"
+
+
 def test_assert_pure_wheel_accepts_universal_wheel(tmp_path: Path):
     tool = _load_script()
     wheel = tmp_path / "codna-0.1.0-py3-none-any.whl"