code-context-control 2.96.0__tar.gz → 2.101.0__tar.gz

{code_context_control-2.96.0/code_context_control.egg-info → code_context_control-2.101.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.96.0
+Version: 2.101.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.96.0 → code_context_control-2.101.0}/cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.96.0"
+__version__ = "2.101.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -7266,7 +7266,8 @@ def _access_cmd_list(args, project_path: str) -> None:
              "project": ".c3/config.json"}
     for scope in ("builtin", "global", "project"):
         sec = scopes.get(scope) or {}
-        rules = [(k, g) for k in ("deny", "read_only") for g in sec.get(k, [])]
+        rules = [(k, g) for k in ("deny", "read_only", "confirm")
+                 for g in sec.get(k, [])]
         masks = sec.get("mask") or []
         print(f"[{scope}] ({notes[scope]}) — {len(rules) + len(masks)} rule(s)")
         for kind, glob in rules:
@@ -7286,12 +7287,22 @@ def _access_cmd_list(args, project_path: str) -> None:
                 for glob in off:
                     print(f"    {'off':<10} {glob}")
                 print("    re-enable: c3 access builtin enable <glob>")
+            moded = {g: m for g, m in (sec.get("modes") or {}).items()
+                     if m not in ("default", "allow")}
+            if moded:
+                print("  MODE set by you (departs from the shipped default):")
+                for glob, m in sorted(moded.items()):
+                    print(f"    {m:<10} {glob}")
+                print("    reset: c3 access builtin mode <glob> default")
             can = [g for g in (sec.get("disableable") or [])
-                   if access_guard._norm_builtin(g) not in set(off)]
+                   if access_guard._norm_builtin(g) not in set(off)
+                   and access_guard._norm_builtin(g) not in moded]
             if can:
                 print("  disableable (currently on): "
                       + ", ".join(can))
-                print("    disable: c3 access builtin disable <glob>")
+                print("    disable: c3 access builtin disable <glob>  ·  "
+                      "granular: c3 access builtin mode <glob> "
+                      "{deny,confirm,allow}")
             if sec.get("absolute"):
                 print("  absolute (credential vault, cannot be disabled): "
                       + ", ".join(sec["absolute"]))
@@ -7318,12 +7329,17 @@ def _access_cmd_builtin(args, project_path: str) -> None:
 
     action = getattr(args, "builtin_cmd", None)
     glob = getattr(args, "glob", None)
-    if action not in ("disable", "enable") or not glob:
+    if action not in ("disable", "enable", "mode") or not glob:
         print("Usage: c3 access builtin {disable,enable} <glob>")
+        print("       c3 access builtin mode <glob> {deny,confirm,allow,default}")
         print("       disableable: "
               + ", ".join(access_guard.DISABLEABLE_BUILTINS))
         return
 
+    if action == "mode":
+        _access_cmd_builtin_mode(args, glob, project_path)
+        return
+
     disabling = action == "disable"
     if disabling and not getattr(args, "yes", False):
         print(f"About to STOP enforcing the builtin guard on: {glob}")
@@ -7359,6 +7375,63 @@ def _access_cmd_builtin(args, project_path: str) -> None:
                   "builtin is enforced anyway (config entry removed).")
 
 
+_BUILTIN_MODE_HELP = {
+    "deny": "full block — read, write and enumeration all refuse (tightens "
+            "a write-only guard)",
+    "confirm": "each governed operation pauses and files an approval request "
+               "you answer from the Hub, phone, or `c3 override`",
+    "allow": "the guard stops enforcing entirely (same as disable)",
+    "default": "the shipped behaviour",
+}
+
+
+def _access_cmd_builtin_mode(args, glob: str, project_path: str) -> None:
+    """`c3 access builtin mode <glob> <mode>` — granular builtin control.
+
+    `deny` and `default` never prompt (tightening / reset). `confirm` and
+    `allow` weaken the guard, so they get the same typed-glob beat of
+    friction as `builtin disable`, unless --yes.
+    """
+    from services import access_guard
+
+    mode = getattr(args, "mode", None)
+    if mode in ("confirm", "allow") and not getattr(args, "yes", False):
+        widening = ("STOP enforcing" if mode == "allow"
+                    else "PAUSE (not block) and ask you to approve")
+        print(f"About to make the builtin guard on {glob} {widening}.")
+        if mode == "allow":
+            print("  While off, any agent with C3 tools can touch those paths.")
+        else:
+            print("  Each hit files an Override Request; one tap approves one "
+                  "single-use retry.")
+        if glob.endswith("settings*.json") or ".claude" in glob:
+            print("  This guards the file that configures the agent itself — "
+                  "hooks, permissions, model.")
+        reply = input("Type the glob again to confirm: ").strip()
+        if reply != glob:
+            print("[abort] Not confirmed; nothing changed.")
+            return
+
+    try:
+        result = access_guard.set_builtin_mode(glob, mode)
+    except ValueError as exc:
+        print(f"[error] {exc}")
+        return
+
+    _access_audit(f"builtin_mode_{result['mode']}", result["glob"],
+                  "builtin", "global", project_path)
+    if not result["changed"]:
+        print(f"[=] {result['glob']} — already {result['mode']}")
+        return
+    print(f"[OK] Builtin '{result['glob']}' mode = {result['mode']} "
+          f"(global scope): {_BUILTIN_MODE_HELP[result['mode']]}.")
+    if result["mode"] != "default":
+        print(f"     Reset with: c3 access builtin mode {result['glob']} default")
+    if not result["attested"]:
+        print("     [warn] keyring attestation could not be cleared; the "
+              "default is enforced anyway (config entry removed).")
+
+
 def _access_cmd_add(args, project_path: str) -> None:
     from services import access_guard
 

{code_context_control-2.96.0 → code_context_control-2.101.0}/cli/commands/parser.py

@@ -751,15 +751,19 @@ def build_parser(version: str, parse_cli_ide_arg):
 
     ac_add = access_subs.add_parser("add", help="Add a rule to the project (or --global) scope")
     ac_add.add_argument("glob", help="POSIX glob (** crosses directories), e.g. 'secrets/**' or '*.pem'")
-    ac_add.add_argument("--kind", choices=["deny", "read_only"], required=True,
-                        help="deny = no read/write/enumerate; read_only = no write")
+    ac_add.add_argument("--kind", choices=["deny", "read_only", "confirm"],
+                        required=True,
+                        help="deny = no read/write/enumerate; read_only = no "
+                             "write; confirm = writes pause for your approval "
+                             "(reads unaffected)")
     ac_add.add_argument("--global", dest="use_global", action="store_true",
                         help="Store in the global scope (~/.c3) so every C3 project enforces it")
     ac_add.add_argument("--path", dest="project_path", default=".", help="Project directory (default: current)")
 
     ac_remove = access_subs.add_parser("remove", help="Remove a rule from the project (or --global) scope")
     ac_remove.add_argument("glob", help="The stored glob to remove (case-insensitive match)")
-    ac_remove.add_argument("--kind", choices=["deny", "read_only"], required=True,
+    ac_remove.add_argument("--kind", choices=["deny", "read_only", "confirm"],
+                           required=True,
                            help="Which rule list the glob lives in")
     ac_remove.add_argument("--global", dest="use_global", action="store_true",
                            help="Remove from the global scope (~/.c3)")
@@ -805,6 +809,21 @@ def build_parser(version: str, parse_cli_ide_arg):
             _p.add_argument("--yes", action="store_true",
                             help="Skip the typed confirmation (scripts/CI)")
 
+    # Granular per-builtin mode (docs/confirm-guard.md §7): deny tightens a
+    # write-deny to a full deny, confirm turns the block into a pause that
+    # auto-files an approval request, allow switches it off (same two-key
+    # construction as disable), default restores the shipped behaviour.
+    bm = builtin_subs.add_parser(
+        "mode", help="Set a built-in guard to deny | confirm | allow | default")
+    bm.add_argument("glob", help="One of: **/.env*, **/.c3/**, **/.claude/settings*.json, **/.git/**")
+    bm.add_argument("mode", choices=["deny", "confirm", "allow", "default"],
+                    help="deny = full block (tighten); confirm = pause for your "
+                         "approval; allow = off (two-key); default = shipped behaviour")
+    bm.add_argument("--path", dest="project_path", default=".",
+                    help="Project directory used for the audit log (default: current)")
+    bm.add_argument("--yes", action="store_true",
+                    help="Skip the typed confirmation (scripts/CI)")
+
     # ── Mask Guard (v2.63.0, docs/mask-guard.md) ────────────────────────
     # Masking exposes a path but transforms what the agent sees. Rules are
     # human-only, like the rest of Access Guard.

{code_context_control-2.96.0 → code_context_control-2.101.0}/cli/hook_access_guard.py

@@ -221,6 +221,25 @@ def _override_allows(base: str, denial, *, tool: str, op: str, path: str,
         return None  # fail closed: no grant, ordinary denial
 
 
+def _confirm_request(base: str, denial, *, tool: str, op: str, path: str,
+                     session_id: str) -> tuple:
+    """Auto-file an Override Request for a ``confirm`` denial (S8).
+
+    ``(request_id, note)`` — one of them is always ''. Lazy import, never
+    raises: a broken request store degrades to S8's "could not be filed"
+    tail, and the hold stands either way (docs/confirm-guard.md §3).
+    """
+    try:
+        from services import override_requests as orq  # noqa: PLC0415 — lazy
+        row, reason = orq.auto_file(base, denial=denial, tool=tool, op=op,
+                                    path=path, session_id=session_id)
+        if row:
+            return str(row.get("id") or ""), ""
+        return "", reason
+    except Exception as exc:
+        return "", f"request store unavailable ({exc})"
+
+
 def _target(tool_input: dict) -> str:
     return str(
         tool_input.get("file_path")
@@ -348,6 +367,14 @@ def run(payload: dict, project_path: Path | None = None) -> dict | None:
             if granted:
                 return {"additionalContext": granted}
             _record(denial, tool, op, fp, base, session_id)
+            if denial.kind == "confirm":
+                # A confirm hold files its own request (grants were consulted
+                # above, so an approved retry lands in the granted branch).
+                rid, note = _confirm_request(base, denial, tool=tool, op=op,
+                                             path=fp, session_id=session_id)
+                return _deny(ag.refusal(denial, fp, op, surface="hook",
+                                        tool=tool, request_id=rid,
+                                        request_note=note))
             return _deny(ag.refusal(denial, fp, op, surface="hook", tool=tool))
         return None
 

{code_context_control-2.96.0 → code_context_control-2.101.0}/cli/hub_server.py

@@ -338,6 +338,7 @@ _HUB_JS_FILES = [
     "hub_ui/components/hub_cred_audit.js",
     "hub_ui/components/hub_tokens.js",
     "hub_ui/components/hub_locks.js",
+    "hub_ui/components/hub_access.js",
     "hub_ui/components/hub_enforcement.js",
     "hub_ui/components/hub_ci.js",
     "hub_ui/components/drill_subprojects.js",
@@ -3088,6 +3089,212 @@ def api_projects_config_put():
     return jsonify({"saved": True, "section": section, "config": merged})
 
 
+# ── Override approvals (hub) — docs/override-requests.md P5 desktop parity ──
+# The desktop half of the request→grant pipeline. Everything here reads or
+# decides REQUESTS; grants are only ever minted inside override_requests.decide,
+# and the typed-confirmation checks in the route exist for the client's
+# benefit — decide() enforces them again regardless of what this route
+# believes (same two-places-compute-one-enforces rule as the mobile route).
+
+_OVERRIDE_ROW_FIELDS = (
+    "id", "project_path", "session_id", "created_at", "expires_at", "status",
+    "layer", "rule", "rule_class", "scope", "tool", "op", "path", "refusal",
+    "justification", "resolved_at", "decided_by", "decision_note",
+)
+
+
+def _hub_override_row(row: dict) -> dict:
+    """One request row for the wire. Allowlisted, never the raw dict.
+
+    ``path_key`` stays server-side (grant-matching identity; the UI gets the
+    human-readable ``path``). ``justification`` IS shipped — the UI renders it
+    quoted under the untrusted-input label, never as markup.
+    """
+    out = {k: row.get(k) for k in _OVERRIDE_ROW_FIELDS}
+    for extra in ("grant_id", "grant_mode", "muted"):
+        if row.get(extra) is not None:
+            out[extra] = row.get(extra)
+    return out
+
+
+def _hub_override_audit(action: str, row: dict, *, confirmed: bool = False,
+                        detail_extra: dict | None = None) -> None:
+    """Identifiers and rule globs only — NEVER the justification (untrusted
+    agent text; the activity feed ships verbatim to every client). Mirrors
+    the mobile route's audit shape with via='hub'. Failure-safe."""
+    detail = {"kind": "override", "action": action,
+              "request_id": row.get("id", ""),
+              "session_id": row.get("session_id", ""),
+              "rule": row.get("rule", ""),
+              "rule_class": row.get("rule_class", ""),
+              "tool": row.get("tool", ""), "op": row.get("op", ""),
+              "via": "hub", "confirmed": bool(confirmed)}
+    detail.update(detail_extra or {})
+    project = row.get("project_path") or ""
+    if not project:
+        return
+    try:
+        ActivityLog(str(project)).log("access_action", dict(detail))
+    except Exception:
+        pass
+    try:
+        from services.edit_ledger import EditLedger
+        EditLedger(str(project)).log_edit(
+            file=f"override://{row.get('id', '')}",
+            change_type=f"override_{action}",
+            summary=(f"{action} override {row.get('id', '')} "
+                     f"({row.get('rule', '')}) via Hub"),
+            tags=["override", action], detail=dict(detail))
+    except Exception:
+        pass
+
+
+@app.route("/api/hub/overrides", methods=["GET"])
+def api_hub_overrides():
+    """Pending + recently-decided requests across every project, newest first.
+
+    The hub is this machine's own surface, so unlike the mobile gateway it
+    does not filter rows to a token's project registry — the store is one file
+    across every project on the box and the hub answers for all of them.
+    Each row carries what the card needs to decide without a second fetch:
+    whether the layer is still escalatable and which typed challenge (if any)
+    an approval demands.
+    """
+    from services import override_policy as opol
+    from services import override_requests as orq
+    project_path = ""
+    raw_project = (request.args.get("path") or "").strip()
+    if raw_project:
+        try:
+            project_path = str(_resolve_project_path(raw_project))
+        except ValueError as e:
+            return jsonify({"error": str(e)}), 404
+    status = (request.args.get("status") or "").strip().lower()
+    try:
+        limit = int(request.args.get("limit") or 50)
+    except (TypeError, ValueError):
+        limit = 50
+    limit = max(1, min(limit, 200))
+    try:
+        rows = orq.list_requests(project_path=project_path, status=status,
+                                 limit=limit)
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+
+    out, policies = [], {}
+    for row in rows:
+        proj = str(row.get("project_path") or ".")
+        if proj not in policies:
+            try:
+                policies[proj] = opol.resolve(proj)
+            except Exception:
+                policies[proj] = None
+        policy = policies[proj]
+        rule_class = str(row.get("rule_class") or "")
+        typed = rule_class in opol.TYPED_CONFIRM_LAYERS
+        entry = _hub_override_row(row)
+        entry["needs_typed_confirm"] = typed
+        entry["confirm_with"] = row.get("rule") if typed else ""
+        entry["escalatable"] = bool(policy.escalatable(rule_class)) \
+            if policy is not None else False
+        entry["allow_session_grants"] = bool(policy.allow_session_grants) \
+            if policy is not None else False
+        entry["project_name"] = Path(proj).name
+        out.append(entry)
+    return jsonify({"requests": out, "count": len(out),
+                    "project": project_path, "status": status,
+                    "limit": limit})
+
+
+@app.route("/api/hub/overrides/<request_id>", methods=["POST"])
+def api_hub_override_decide(request_id):
+    """Approve (minting a grant) or deny one request. decided_by='desktop'.
+
+    Body: {decision, confirm?, mode?, note?, mute?, ttl_s?, uses?}.
+    409 for a request that lapsed while the page was showing it — the card
+    refreshes to the real status instead of silently minting a grant.
+    """
+    from services import override_policy as opol
+    from services import override_requests as orq
+    data = request.get_json(silent=True) or {}
+    decision = str(data.get("decision") or "").strip().lower()
+    if decision not in (orq.DECISION_APPROVE, orq.DECISION_DENY):
+        return jsonify({"error": "decision must be 'approve' or 'deny'"}), 400
+    mode = str(data.get("mode") or orq.MODE_ONCE).strip().lower()
+    if mode not in orq.MODES:
+        return jsonify({"error": f"mode must be one of: "
+                                 f"{', '.join(orq.MODES)}"}), 400
+
+    row = orq.get(str(request_id))
+    if row is None:
+        return jsonify({"error": "unknown request"}), 404
+    if row.get("status") != orq.STATUS_PENDING:
+        return jsonify({"error": f"request is {row.get('status')}, not pending",
+                        "request": _hub_override_row(row)}), 409
+
+    rule_class = str(row.get("rule_class") or "")
+    confirm = data.get("confirm")
+    if (decision == orq.DECISION_APPROVE
+            and rule_class in opol.TYPED_CONFIRM_LAYERS
+            and confirm != row.get("rule")):
+        return jsonify({
+            "error": f"approving an {rule_class} request needs the rule "
+                     "glob retyped by hand",
+            "needs_confirmation": True,
+            "confirm_with": row.get("rule"),
+        }), 400
+
+    try:
+        ttl_s = int(data["ttl_s"]) if data.get("ttl_s") is not None else None
+        uses = int(data["uses"]) if data.get("uses") is not None else None
+    except (TypeError, ValueError):
+        return jsonify({"error": "ttl_s and uses must be integers"}), 400
+
+    try:
+        result = orq.decide(
+            str(request_id), decision, uses=uses, ttl_s=ttl_s,
+            note=str(data.get("note") or ""), decided_by="desktop",
+            confirm=confirm, mode=mode, mute=bool(data.get("mute")))
+    except orq.OverrideError as exc:
+        _hub_override_audit(f"{decision}_refused", row)
+        return jsonify({"error": str(exc)}), 400
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+
+    _hub_override_audit(decision, result,
+                        confirmed=rule_class in opol.TYPED_CONFIRM_LAYERS,
+                        detail_extra={"mode": mode,
+                                      "grant_id": result.get("grant_id", "")})
+    return jsonify({"request": _hub_override_row(result),
+                    "decision": decision})
+
+
+@app.route("/api/hub/access", methods=["GET"])
+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.
+    """
+    from services import access_guard
+    from services import override_policy as opol
+    raw = (request.args.get("path") or "").strip()
+    if not raw:
+        return jsonify({"error": "path is required"}), 400
+    try:
+        resolved = _resolve_project_path(raw)
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 404
+    try:
+        rules = access_guard.list_rules(str(resolved))
+        policy = opol.resolve(str(resolved)).as_dict()
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+    return jsonify({"path": str(resolved), "rules": rules,
+                    "policy": policy})
+
+
 # ── 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.96.0 → code_context_control-2.101.0}/cli/hub_ui/app.js

@@ -44,7 +44,7 @@ function App() {
       if (cfg.projects_view === 'grid') setView('grid');
       if (cfg.sidebar_collapsed != null) setSidebarCollapsed(!!cfg.sidebar_collapsed);
       if (cfg.sidebar_group) setFilter(cfg.sidebar_group);
-      if (['board', 'ci', 'creds', 'locks', 'enforce'].includes(cfg.main_view)) setMainView(cfg.main_view);
+      if (['board', 'ci', 'creds', 'tokens', 'locks', 'access', 'enforce'].includes(cfg.main_view)) setMainView(cfg.main_view);
     } catch { }
     try { const v = await api.get('/api/version'); setVersion(v.c3_version || ''); } catch { }
   }, []);
@@ -120,6 +120,8 @@ function App() {
             <HubTokens projects={projects} onOpenDrill={openDrill} />
           ) : mainView === 'locks' ? (
             <HubLocks projects={projects} onOpenDrill={openDrill} />
+          ) : mainView === 'access' ? (
+            <HubAccess projects={projects} />
           ) : mainView === 'enforce' ? (
             <HubEnforcement projects={projects} onOpenDrill={openDrill} />
           ) : (