code-context-control 2.141.0__tar.gz → 2.142.0__tar.gz

{code_context_control-2.141.0 → code_context_control-2.142.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.141.0
+Version: 2.142.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.141.0 → code_context_control-2.142.0}/cli/c3.py

@@ -91,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.141.0"
+__version__ = "2.142.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"

{code_context_control-2.141.0 → code_context_control-2.142.0}/cli/hub_server.py

@@ -3658,8 +3658,10 @@ def api_hub_access():
     """Effective Access Guard rules + override policy for one project.
 
     Read-only companion to the approvals list: the per-project mode matrix
-    the tab renders under the pending cards. Rule MUTATION stays on the
-    per-project server and the CLI — this route never writes.
+    the tab renders under the pending cards. This route never writes; rule
+    mutation from the Hub is ``/api/hub/access/rule`` (add) and
+    ``/api/hub/access/rule/remove`` (v2.142.0), besides the per-project
+    server and the CLI.
     """
     from services import access_guard
     from services import override_policy as opol
@@ -3679,6 +3681,180 @@ def api_hub_access():
                     "policy": policy})
 
 
+# ── Access Guard by file type, across projects (v2.142.0) ─────────────────
+# The desktop surface for path rules. The phone's /api/mobile/access/rule
+# cannot carry a bulk edit — 12 security calls a minute and no global scope,
+# both on purpose for a device that leaves the building — and the per-project
+# server only runs while its project's UI is open. So the Hub, loopback and
+# human-only, gains the same two verbs with the same asymmetry: adding a rule
+# tightens and is one call; removing a deny rule, or ANY global-scope rule,
+# needs the glob retyped. Every write is audited on the target (a global
+# write in ~/.c3, since it has no single target project).
+
+def _hub_access_audit(action: str, glob: str, kind: str, scope: str,
+                      project) -> None:
+    """Globs only — never file content. Failure-safe. Mirrors the phone's
+    ``_access_audit`` with ``via='hub'``."""
+    detail = {"kind": "access", "action": action, "glob": glob,
+              "rule_kind": kind, "scope": scope, "via": "hub"}
+    if project is not None:
+        try:
+            from services.activity_log import ActivityLog as _AL
+            _AL(str(project)).log("access_action", dict(detail))
+        except Exception:
+            pass
+        try:
+            from services.edit_ledger import EditLedger
+            EditLedger(str(project)).log_edit(
+                file=f"access://{glob}", change_type=f"access_{action}",
+                summary=f"{action} {kind} rule {glob} ({scope}) via the Hub",
+                tags=["access", action], detail=dict(detail))
+        except Exception:
+            pass
+    if scope == "global":
+        try:
+            from services import credential_store as cred_store
+            from services.activity_log import ActivityLog as _AL
+            home = cred_store.global_base()
+            if home is not None:
+                _AL(str(home)).log("access_action", dict(detail))
+        except Exception:
+            pass
+
+
+def _hub_access_target(data: dict):
+    """``(scope, project_path_or_None, error_response_or_None)``."""
+    scope = str(data.get("scope") or "project").strip().lower()
+    if scope not in ("project", "global"):
+        return scope, None, (jsonify(
+            {"error": "scope must be 'project' or 'global'"}), 400)
+    if scope == "global":
+        return scope, None, None
+    raw = str(data.get("path") or "").strip()
+    if not raw:
+        return scope, None, (jsonify(
+            {"error": "path is required for project scope"}), 400)
+    try:
+        resolved = _resolve_project_path(raw)
+    except ValueError as e:
+        return scope, None, (jsonify({"error": str(e)}), 404)
+    # set_rule would create .c3/config.json in any directory it is handed;
+    # a rule in a folder C3 does not manage protects nothing and says it does.
+    if not (Path(resolved) / ".c3").is_dir():
+        return scope, None, (jsonify(
+            {"error": "not initialized for C3", "needs_init": True}), 409)
+    return scope, str(resolved), None
+
+
+@app.route("/api/hub/access/overview", methods=["GET"])
+def api_hub_access_overview():
+    """Every registered project's own path rules, plus global and builtin.
+
+    Per-row isolation like the enforcement and policy overviews: a project we
+    could not read reports ``error`` rather than an empty rule list — "no
+    rules" is a claim about a repo, and we would be making it blind. A corrupt
+    scope is reported as corrupt: it evaluates deny-all until repaired by
+    hand, which is the opposite of what an empty list would suggest.
+    Builtin rules are read once, from the global realm; a project-scope
+    builtin mode (set with the CLI) is not reflected per row.
+    """
+    empty = {"deny": [], "read_only": [], "confirm": [], "mask": 0,
+             "corrupt": False}
+    rows = []
+    for p in _pm().list_projects():
+        ppath = str(p.get("path") or "")
+        row = {"name": p.get("name") or Path(ppath).name, "path": ppath,
+               "initialized": True, "error": None, "rules": dict(empty)}
+        try:
+            if not (Path(ppath) / ".c3").is_dir():
+                row["initialized"] = False
+            else:
+                row["rules"] = access_guard.scope_rules("project", ppath)
+        except Exception as e:
+            row["error"] = str(e)
+        rows.append(row)
+
+    try:
+        global_rules = {**access_guard.scope_rules("global"), "error": None}
+    except Exception as e:
+        global_rules = {**empty, "error": str(e)}
+    try:
+        home = access_guard._global_base()
+        b = access_guard.list_rules(str(home) if home else ".")["builtin"]
+        builtin = {"deny": list(b.get("deny") or []),
+                   "read_only": list(b.get("read_only") or []),
+                   "confirm": list(b.get("confirm") or []), "error": None}
+    except Exception as e:
+        builtin = {"deny": [], "read_only": [], "confirm": [], "error": str(e)}
+
+    return jsonify({
+        "projects": rows,
+        "global": global_rules,
+        "builtin": builtin,
+        # Strictest last. "allow" is the absence of a rule, not a kind.
+        "kinds": ["confirm", "read_only", "deny"],
+        "coverage_note": access_guard.COVERAGE_MATRIX,
+    })
+
+
+@app.route("/api/hub/access/rule", methods=["POST"])
+def api_hub_access_rule_add():
+    """Add one deny / read_only / confirm rule. Tightening — no confirmation.
+
+    Body: ``{path?, scope?, glob, kind}``. ``added: false`` when an equivalent
+    glob is already there (a 200, not an error: the caller asked for the
+    state it is in).
+    """
+    data = request.get_json(silent=True) or {}
+    scope, project, err = _hub_access_target(data)
+    if err:
+        return err
+    glob = str(data.get("glob") or "")
+    kind = str(data.get("kind") or "").strip()
+    try:
+        result = access_guard.set_rule(glob, kind, scope, project or ".")
+    except ValueError as exc:
+        return jsonify({"error": str(exc)}), 400
+    if result["added"]:
+        _hub_access_audit("add", result["glob"], kind, scope, project)
+    return jsonify({"rule": result})
+
+
+@app.route("/api/hub/access/rule/remove", methods=["POST"])
+def api_hub_access_rule_remove():
+    """Remove one rule. Loosening.
+
+    Body: ``{path?, scope?, glob, kind, confirm?}``. A ``deny`` rule, and any
+    rule in the GLOBAL scope (it governs every project on the machine), needs
+    ``confirm`` equal to the glob — the CLI's "type the glob again". A
+    read_only or confirm rule in one project does not: it downgrades writes
+    to writable-or-ask, not to fully visible. POST rather than DELETE so the
+    body survives every client.
+    """
+    data = request.get_json(silent=True) or {}
+    scope, project, err = _hub_access_target(data)
+    if err:
+        return err
+    glob = str(data.get("glob") or "")
+    kind = str(data.get("kind") or "").strip()
+    canon = access_guard._norm_glob(glob)
+    if kind == "deny" or scope == "global":
+        if access_guard._norm_glob(data.get("confirm")) != canon or not canon:
+            return jsonify({
+                "error": ("removing a deny rule weakens protection"
+                          if kind == "deny" else
+                          "removing a global rule weakens every project"),
+                "needs_confirmation": True, "confirm_with": canon,
+            }), 400
+    try:
+        result = access_guard.remove_rule(glob, kind, scope, project or ".")
+    except ValueError as exc:
+        return jsonify({"error": str(exc)}), 400
+    if result["removed"]:
+        _hub_access_audit("remove", result["glob"], kind, scope, project)
+    return jsonify(result)
+
+
 # ── Project management: tasks / milestones / notes (v2.45.0) ──────────────
 # Direct TaskStore per request (reload-per-op store — no runtime build needed
 # for mutations); every write audited to the target project's activity log.

{code_context_control-2.141.0 → code_context_control-2.142.0}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.141.0
+Version: 2.142.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.141.0 → code_context_control-2.142.0}/code_context_control.egg-info/SOURCES.txt

@@ -409,6 +409,7 @@ tests/test_hook_session_end.py
 tests/test_hook_smoke.py
 tests/test_hook_state.py
 tests/test_hook_utf8_stdio.py
+tests/test_hub_access_routes.py
 tests/test_hub_credentials_route.py
 tests/test_hub_credentials_routes_write.py
 tests/test_hub_enforcement_routes.py

{code_context_control-2.141.0 → code_context_control-2.142.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.141.0"
+version = "2.142.0"
 description = "Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub."
 readme = "README.md"
 requires-python = ">=3.10"

{code_context_control-2.141.0 → code_context_control-2.142.0}/services/access_guard.py

@@ -1439,6 +1439,28 @@ def list_rules(project_path: str = ".") -> dict:
     return out
 
 
+def scope_rules(scope: str, project_path: str = ".") -> dict:
+    """One scope's OWN list rules, for a cross-project screen.
+
+    ``{"deny": [...], "read_only": [...], "confirm": [...], "mask": <count>,
+    "corrupt": bool}``. Globs come back in the canonical storage form
+    (:func:`_norm_glob`), which is what :func:`set_rule` writes and what
+    :func:`remove_rule` compares against, so a caller can match a row to the
+    rule it would remove without re-deriving the spelling. A missing file is
+    an empty scope; an unreadable one is ``corrupt`` (it evaluates deny-all
+    until repaired by hand). Unlike :func:`list_rules` this touches no
+    keyring and computes no builtin modes, so it is cheap enough to run over
+    every registered project in one request.
+    """
+    cfg = _scope_config_path(scope, project_path)
+    section, corrupt = _raw_scope_section(cfg)
+    out = {k: [_norm_glob(g) for g in _str_list(section.get(k))]
+           for k in _LIST_KINDS}
+    out[_KIND_MASK] = len(_mask_list(section.get(_KIND_MASK)))
+    out["corrupt"] = corrupt
+    return out
+
+
 def _load_config_for_write(cfg: Path) -> tuple:
     """(config_dict, access_section) for read-modify-write of one scope.
 

code_context_control-2.142.0/tests/test_hub_access_routes.py

@@ -0,0 +1,230 @@
+"""Access Guard rules by file type, across projects, from the Hub (2.142.0).
+
+WHY THE HUB. The phone's /api/mobile/access/rule cannot carry a bulk edit:
+12 security calls a minute and no global scope, both deliberate for a device
+that leaves the building. The per-project server only runs while that
+project's UI is open. C3 Desk needs one loopback surface that reads every
+project's rules in one call and writes them one rule at a time.
+
+WHAT THESE PIN.
+1. The overview never reports "no rules" for a project it could not read,
+   and flags a corrupt scope (which evaluates deny-all) as corrupt.
+2. Globs come back in the canonical storage form, so a client can match a
+   row to the rule remove_rule() will compare against.
+3. Adding tightens and needs nothing. Removing a deny rule, or any global
+   rule, needs the glob retyped; removing a project read_only/confirm rule
+   does not. A refused removal leaves the file untouched.
+4. Every real write is audited on the target; a no-op is not.
+5. A folder C3 does not manage gets a 409, not a fresh .c3/config.json.
+"""
+from __future__ import annotations
+
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT))
+
+import cli.hub_server as hub_server  # noqa: E402
+from services import access_guard as ag  # noqa: E402
+
+
+class _StubPM:
+    def __init__(self, projects):
+        self._projects = projects
+
+    def list_projects(self):
+        return self._projects
+
+
+def _cfg(path: Path) -> dict:
+    return json.loads((path / ".c3" / "config.json").read_text(encoding="utf-8"))
+
+
+def _write_cfg(path: Path, data: dict) -> None:
+    (path / ".c3").mkdir(parents=True, exist_ok=True)
+    (path / ".c3" / "config.json").write_text(json.dumps(data), encoding="utf-8")
+
+
+class _Base(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        root = Path(self._tmp.name)
+        self.proj = root / "proj"
+        _write_cfg(self.proj, {"access": {"deny": ["secrets\\**"],
+                                          "read_only": ["**/*.lock"]}})
+        self.other = root / "other"
+        _write_cfg(self.other, {})
+        self.bare = root / "bare"
+        self.bare.mkdir()
+        self.home = root / "home"
+        (self.home / ".c3").mkdir(parents=True)
+        self._gbase = mock.patch.object(ag, "_global_base", return_value=self.home)
+        self._gbase.start()
+
+        hub_server.app.config["TESTING"] = True
+        self.client = hub_server.app.test_client()
+        self._pm = mock.patch.object(hub_server, "_pm", return_value=_StubPM([
+            {"name": "proj", "path": str(self.proj)},
+            {"name": "other", "path": str(self.other)},
+            {"name": "bare", "path": str(self.bare)},
+        ]))
+        self._pm.start()
+        self._resolve = mock.patch.object(
+            hub_server, "_resolve_project_path", side_effect=lambda p: Path(p))
+        self._resolve.start()
+
+    def tearDown(self):
+        self._resolve.stop()
+        self._pm.stop()
+        self._gbase.stop()
+        self._tmp.cleanup()
+
+    def post(self, url, body):
+        resp = self.client.post(url, json=body)
+        return resp.status_code, resp.get_json()
+
+
+class TestOverview(_Base):
+    def _overview(self):
+        resp = self.client.get("/api/hub/access/overview")
+        self.assertEqual(resp.status_code, 200)
+        return resp.get_json()
+
+    def _row(self, data, name):
+        return next(r for r in data["projects"] if r["name"] == name)
+
+    def test_rows_carry_each_projects_own_rules_in_storage_form(self):
+        row = self._row(self._overview(), "proj")
+        self.assertEqual(row["rules"]["deny"], ["secrets/**"])
+        self.assertEqual(row["rules"]["read_only"], ["**/*.lock"])
+        self.assertEqual(row["rules"]["confirm"], [])
+        self.assertFalse(row["rules"]["corrupt"])
+
+    def test_uninitialized_and_unreadable_rows_are_not_reported_as_no_rules(self):
+        real = ag.scope_rules
+
+        def flaky(scope, path="."):
+            if scope == "project" and Path(path) == self.other:
+                raise RuntimeError("boom")
+            return real(scope, path)
+
+        with mock.patch.object(ag, "scope_rules", side_effect=flaky):
+            data = self._overview()
+        self.assertFalse(self._row(data, "bare")["initialized"])
+        self.assertEqual(self._row(data, "other")["error"], "boom")
+        self.assertEqual(self._row(data, "proj")["rules"]["deny"], ["secrets/**"])
+
+    def test_a_corrupt_scope_is_flagged(self):
+        _write_cfg(self.other, {"access": {"allow": ["**"]}})
+        self.assertTrue(self._row(self._overview(), "other")["rules"]["corrupt"])
+
+    def test_global_and_builtin(self):
+        _write_cfg(self.home, {"access": {"confirm": ["**/*.sql"]}})
+        data = self._overview()
+        self.assertEqual(data["global"]["confirm"], ["**/*.sql"])
+        self.assertIn("**/.env*", data["builtin"]["deny"])
+        self.assertEqual(data["kinds"], ["confirm", "read_only", "deny"])
+        self.assertIn("NOT enforced", data["coverage_note"])
+
+
+class TestAdd(_Base):
+    def test_add_writes_and_audits_on_the_target(self):
+        with mock.patch("services.activity_log.ActivityLog") as log:
+            status, body = self.post("/api/hub/access/rule", {
+                "path": str(self.other), "glob": "**\\*.pem", "kind": "deny"})
+        self.assertEqual(status, 200, body)
+        self.assertEqual(body["rule"], {"glob": "**/*.pem", "kind": "deny",
+                                        "scope": "project", "added": True})
+        self.assertEqual(_cfg(self.other)["access"]["deny"], ["**/*.pem"])
+        event, payload = log.return_value.log.call_args[0]
+        self.assertEqual((event, payload["action"], payload["via"]),
+                         ("access_action", "add", "hub"))
+
+    def test_duplicate_is_a_noop_and_not_audited(self):
+        with mock.patch("services.activity_log.ActivityLog") as log:
+            status, body = self.post("/api/hub/access/rule", {
+                "path": str(self.proj), "glob": "SECRETS/**", "kind": "deny"})
+        self.assertEqual(status, 200)
+        self.assertFalse(body["rule"]["added"])
+        self.assertFalse(log.called)
+
+    def test_global_scope_needs_no_path(self):
+        status, body = self.post("/api/hub/access/rule", {
+            "scope": "global", "glob": "**/*.key", "kind": "read_only"})
+        self.assertEqual(status, 200, body)
+        self.assertEqual(_cfg(self.home)["access"]["read_only"], ["**/*.key"])
+
+    def test_refusals(self):
+        self.assertEqual(self.post("/api/hub/access/rule", {
+            "path": str(self.proj), "glob": "x/**", "kind": "allow"})[0], 400)
+        self.assertEqual(self.post("/api/hub/access/rule", {
+            "glob": "x/**", "kind": "deny"})[0], 400)
+        self.assertEqual(self.post("/api/hub/access/rule", {
+            "scope": "machine", "glob": "x/**", "kind": "deny"})[0], 400)
+        status, body = self.post("/api/hub/access/rule", {
+            "path": str(self.bare), "glob": "x/**", "kind": "deny"})
+        self.assertEqual(status, 409)
+        self.assertFalse((self.bare / ".c3").exists(), "it created .c3 anyway")
+
+
+class TestRemove(_Base):
+    URL = "/api/hub/access/rule/remove"
+
+    def test_project_read_only_removal_needs_no_confirmation(self):
+        status, body = self.post(self.URL, {
+            "path": str(self.proj), "glob": "**/*.lock", "kind": "read_only"})
+        self.assertEqual(status, 200, body)
+        self.assertTrue(body["removed"])
+        self.assertEqual(_cfg(self.proj)["access"]["read_only"], [])
+
+    def test_deny_removal_needs_the_glob_retyped(self):
+        status, body = self.post(self.URL, {
+            "path": str(self.proj), "glob": "secrets/**", "kind": "deny"})
+        self.assertEqual(status, 400)
+        self.assertEqual((body["needs_confirmation"], body["confirm_with"]),
+                         (True, "secrets/**"))
+        self.assertEqual(_cfg(self.proj)["access"]["deny"], ["secrets\\**"],
+                         "it wrote despite refusing")
+        with mock.patch("services.activity_log.ActivityLog") as log:
+            status, body = self.post(self.URL, {
+                "path": str(self.proj), "glob": "secrets/**", "kind": "deny",
+                "confirm": "secrets\\**"})
+        self.assertEqual(status, 200, body)
+        self.assertTrue(body["removed"])
+        self.assertEqual(_cfg(self.proj)["access"]["deny"], [])
+        self.assertEqual(log.return_value.log.call_args[0][1]["action"], "remove")
+
+    def test_any_global_removal_needs_the_glob_retyped(self):
+        _write_cfg(self.home, {"access": {"confirm": ["**/*.sql"]}})
+        body = {"scope": "global", "glob": "**/*.sql", "kind": "confirm"}
+        self.assertEqual(self.post(self.URL, body)[0], 400)
+        status, res = self.post(self.URL, {**body, "confirm": "**/*.sql"})
+        self.assertEqual(status, 200, res)
+        self.assertEqual(_cfg(self.home)["access"]["confirm"], [])
+
+    def test_a_corrupt_scope_is_refused_not_rewritten(self):
+        _write_cfg(self.other, {"access": {"allow": ["**"], "read_only": ["a/**"]}})
+        status, _ = self.post(self.URL, {
+            "path": str(self.other), "glob": "a/**", "kind": "read_only"})
+        self.assertEqual(status, 400)
+        self.assertEqual(_cfg(self.other)["access"]["allow"], ["**"])
+
+
+class TestRoutes(unittest.TestCase):
+    def test_each_route_resolves_to_its_own_endpoint(self):
+        adapter = hub_server.app.url_map.bind("localhost")
+        for url, method, endpoint in (
+                ("/api/hub/access/overview", "GET", "api_hub_access_overview"),
+                ("/api/hub/access/rule", "POST", "api_hub_access_rule_add"),
+                ("/api/hub/access/rule/remove", "POST",
+                 "api_hub_access_rule_remove")):
+            self.assertEqual(adapter.match(url, method=method)[0], endpoint)
+
+
+if __name__ == "__main__":
+    unittest.main()