code-context-control 2.63.2__tar.gz → 2.64.0__tar.gz

{code_context_control-2.63.2 → code_context_control-2.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.63.2
+Version: 2.64.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.63.2 → code_context_control-2.64.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.63.2"
+__version__ = "2.64.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -4046,14 +4046,22 @@ def cmd_pipe(args):
 
 
 from services.claude_md import C3_COMPACT_WORKFLOW as _SHARED_C3_COMPACT_WORKFLOW
+from services.claude_md import VSCODE_SESSION_INIT as _VSCODE_SESSION_INIT
+from services.claude_md import adapt_workflow_for_ide as _adapt_workflow_for_ide
 
 _C3_COMPACT_WORKFLOW = _SHARED_C3_COMPACT_WORKFLOW
 
 _CLAUDE_MD_CONTENT = _C3_COMPACT_WORKFLOW
 
-_COPILOT_INSTRUCTIONS_CONTENT = _C3_COMPACT_WORKFLOW
+# Copilot and Codex run without PreToolUse hooks and without /clear, so both
+# docs get the hookless restatement of the mandate (see PROFILES in core/ide.py).
+_C3_HOOKLESS_WORKFLOW = _adapt_workflow_for_ide(
+    _C3_COMPACT_WORKFLOW, supports_hooks=False, supports_clear=False
+)
+
+_COPILOT_INSTRUCTIONS_CONTENT = _VSCODE_SESSION_INIT + "\n\n" + _C3_HOOKLESS_WORKFLOW
 
-_AGENTS_MD_CONTENT = _C3_COMPACT_WORKFLOW + """
+_AGENTS_MD_CONTENT = _C3_HOOKLESS_WORKFLOW + """
 
 ## IDE Configuration (Codex)
 This project uses project-scoped MCP servers. Ensure your `.codex/config.toml` includes:
@@ -5989,6 +5997,10 @@ def _access_cmd_list(args, project_path: str) -> None:
         if sec.get("corrupt"):
             print("  [warn] access section invalid — scope fails closed "
                   "(deny-all); fix config.json 'access' by hand")
+        if scope == "builtin":
+            print("  spelling rules (deny by how a path is written, no glob):")
+            for name, why in access_guard.SYNTHETIC_RULES:
+                print(f"    {name:<18} {why}")
     print()
     from services import mask_activation
     summary = mask_activation.summary_line(project_path)
@@ -6404,6 +6416,66 @@ def _jira_cmd_set_default(args, project_path: str) -> None:
     print(f"[OK] Default Jira project: {args.project}")
 
 
+def _oracle_open(args):
+    """Mint a single-use sign-in URL for a running Oracle dashboard (#31).
+
+    Plain ``GET /`` no longer issues the session cookie, so a dashboard opened
+    by hand is read-only until a bootstrap code is redeemed. Reading the
+    owner-only key file is what proves we are the same OS user as the server.
+    """
+    import json as _json
+    import urllib.error
+    import urllib.request
+    import webbrowser
+
+    from oracle.config import ORACLE_DIR, load_config
+    from oracle.services import local_session
+
+    cfg = load_config()
+    host = cfg.get("bind_host", "127.0.0.1")
+    disp_host = "127.0.0.1" if host in ("0.0.0.0", "") else host
+    port = getattr(args, "port", None) or cfg.get("port", 3331)
+    base = f"http://{disp_host}:{port}"
+
+    key = local_session.read_bootstrap_key(ORACLE_DIR)
+    if not key:
+        print(f"[oracle:open] no bootstrap key at "
+              f"{ORACLE_DIR / local_session.BOOTSTRAP_KEY_FILENAME}")
+        print("  The key is written when the server starts. Is Oracle running?")
+        print("  Start it with: c3 oracle serve")
+        return
+
+    req = urllib.request.Request(
+        f"{base}/api/session/bootstrap",
+        data=_json.dumps({"key": key}).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            payload = _json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        detail = e.read().decode("utf-8", "replace")[:200]
+        print(f"[oracle:open] server refused the request ({e.code}): {detail}")
+        if e.code == 401:
+            print("  The key on disk is stale — restart the server to rewrite it.")
+        return
+    except OSError as e:
+        print(f"[oracle:open] could not reach {base}: {e}")
+        print("  Start it with: c3 oracle serve")
+        return
+
+    url = payload.get("url", "")
+    if not url:
+        print("[oracle:open] server returned no URL")
+        return
+    ttl = payload.get("expires_in", local_session.CODE_TTL_SECONDS)
+    print(f"[oracle:open] single-use sign-in link (valid {ttl}s, one use):")
+    print(f"  {url}")
+    if not getattr(args, "no_browser", False):
+        webbrowser.open(url)
+
+
 def cmd_oracle(args):
     """Oracle dashboard server + Discovery API key management."""
     sub = getattr(args, "oracle_cmd", None)
@@ -6414,8 +6486,12 @@ def cmd_oracle(args):
         run_oracle(port=getattr(args, "port", None),
                    open_browser=not getattr(args, "no_browser", False))
         return
+    if sub == "open":
+        _oracle_open(args)
+        return
     if sub != "api":
-        print("Usage: c3 oracle {serve,api} — serve: launch the dashboard; "
+        print("Usage: c3 oracle {serve,open,api} — serve: launch the dashboard; "
+              "open: sign in to a running dashboard; "
               "api {info,key,rotate,clear}: manage the Discovery key")
         return
 

{code_context_control-2.63.2 → code_context_control-2.64.0}/cli/commands/parser.py

@@ -540,6 +540,14 @@ def build_parser(version: str, parse_cli_ide_arg):
                           help="Server port (default: config 'port', 3331)")
     or_serve.add_argument("--no-browser", action="store_true",
                           help="Don't open the browser")
+    or_open = or_subs.add_parser(
+        "open",
+        help="Sign in to a running dashboard via a single-use URL",
+    )
+    or_open.add_argument("--port", type=int, default=None,
+                         help="Server port (default: config 'port', 3331)")
+    or_open.add_argument("--no-browser", action="store_true",
+                         help="Print the URL without opening a browser")
     or_api = or_subs.add_parser(
         "api",
         help="Show connection info / manage the Discovery API key",

{code_context_control-2.63.2 → code_context_control-2.64.0}/cli/hook_access_guard.py

@@ -31,6 +31,23 @@ _SHELL_TOOLS = {"Bash"}  # normalize_tool_name folds run_shell_command in
 _TOKEN_SPLIT = re.compile(r"\s+")
 _MAX_TOKENS = 200
 
+# A colon in a shell token overwhelmingly means "URL scheme" or "IPv6", not
+# "NTFS alternate data stream". The ADS check stays strict for real path
+# arguments (_WRITE_TOOLS/_READ_TOOLS); here it only produced false denies on
+# commit messages, curl, and gh (#50).
+_SCHEME_RE = re.compile(r"^[a-z][a-z0-9+.\-]*://", re.IGNORECASE)
+# IPv6 literal or CIDR: >=2 colons, hex groups only, optional [] and /prefix.
+# 'C:/x/f.txt:stream' has one colon and non-hex parts, so it never matches.
+_IPV6_RE = re.compile(
+    r"^\[?[0-9a-f]{0,4}(?::[0-9a-f]{0,4}){2,}\]?(?:/\d{1,3})?$",
+    re.IGNORECASE,
+)
+
+
+def _is_network_token(tok: str) -> bool:
+    """True for URLs and IPv6 literals/CIDRs — never for an ADS spelling."""
+    return bool(_SCHEME_RE.match(tok) or _IPV6_RE.match(tok))
+
 
 def _deny(reason: str) -> dict:
     return {
@@ -57,6 +74,10 @@ def _scan_shell(cmd: str, base: str):
     Confident = the token resolves to an EXISTING path that a ``deny`` rule
     covers (existence-gating keeps regex/pattern arguments like '\\.env'
     from false-denying), or the evaluator flags the spelling itself.
+
+    URLs and IPv6 literals are skipped outright: they trip the ADS spelling
+    check, which is exempt from existence-gating, so a token naming nothing
+    on disk would otherwise hard-deny (#50).
     """
     for raw in _TOKEN_SPLIT.split(cmd)[:_MAX_TOKENS]:
         tok = raw.strip("\"'`;,()")
@@ -64,6 +85,8 @@ def _scan_shell(cmd: str, base: str):
             continue
         if "/" not in tok and "\\" not in tok and not tok.startswith("."):
             continue
+        if _is_network_token(tok):
+            continue
         if re.match(r"^/[a-z]/", tok):  # MSYS /c/foo → C:/foo
             tok = f"{tok[1]}:{tok[2:]}"
         denial = ag.check(tok, "read", base)

{code_context_control-2.63.2 → code_context_control-2.64.0}/cli/hub_server.py

@@ -379,12 +379,6 @@ def index():
     return Response(_hub_html_cache, mimetype="text/html")
 
 
-@app.route("/legacy")
-def index_legacy():
-    """Frozen pre-2.44 hub UI — escape hatch for one release, then removed."""
-    return send_from_directory(str(Path(__file__).parent), "hub.html")
-
-
 @app.route("/guide/")
 @app.route("/guide/<path:filename>")
 def serve_guide(filename="index.html"):

{code_context_control-2.63.2 → code_context_control-2.64.0}/cli/hub_ui/components/settings_modal.js

@@ -187,12 +187,6 @@ function SettingsModal({ onClose, onChanged }) {
         </div>
       )}
 
-      <div style={{ marginTop: 18, paddingTop: 12, borderTop: `1px solid ${T.border}` }}>
-        <a href="/legacy" style={{ fontSize: 11, color: T.textMuted, textDecoration: 'none' }}>
-          Legacy UI (pre-2.44)
-        </a>
-      </div>
-
       {confirmAction === 'stop' && (
         <ConfirmDialog title="Stop Hub"
           message="The page will become unreachable until the hub is restarted (c3 hub)."

{code_context_control-2.63.2 → code_context_control-2.64.0}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.63.2
+Version: 2.64.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.63.2 → code_context_control-2.64.0}/code_context_control.egg-info/SOURCES.txt

@@ -21,7 +21,6 @@ cli/hook_prompt_recall.py
 cli/hook_read.py
 cli/hook_session_stats.py
 cli/hook_terse_advisor.py
-cli/hub.html
 cli/hub_server.py
 cli/hub_ui.html
 cli/mcp_proxy.py
@@ -132,6 +131,7 @@ oracle/services/c3_bridge.py
 oracle/services/chat_engine.py
 oracle/services/chat_store.py
 oracle/services/cross_memory.py
+oracle/services/discovery_audit.py
 oracle/services/federated_graph.py
 oracle/services/health_checker.py
 oracle/services/insight_engine.py
@@ -285,6 +285,7 @@ tests/test_hub_credentials_routes_write.py
 tests/test_hub_inspect_api.py
 tests/test_hub_server_smoke.py
 tests/test_hub_subproject_links.py
+tests/test_ide_workflow_adaptation.py
 tests/test_init_scan.py
 tests/test_install_mcp_entrypoint.py
 tests/test_jira_cli_smoke.py
@@ -314,11 +315,14 @@ tests/test_oracle_api_auth.py
 tests/test_oracle_apikey_api.py
 tests/test_oracle_c3_bridge.py
 tests/test_oracle_chat_engine.py
+tests/test_oracle_chat_store.py
 tests/test_oracle_discovery_api.py
+tests/test_oracle_discovery_audit.py
 tests/test_oracle_local_auth.py
 tests/test_oracle_ollama_bridge.py
 tests/test_oracle_scanner_cache.py
 tests/test_oracle_security_fixes.py
+tests/test_oracle_session_bootstrap.py
 tests/test_oracle_subproject_awareness.py
 tests/test_oracle_ui_bundle.py
 tests/test_output_filter.py

{code_context_control-2.63.2 → code_context_control-2.64.0}/oracle/config.py

@@ -14,6 +14,9 @@ DEFAULTS = {
     "api_enabled": True,            # expose /api/discovery/* REST surface
     "api_require_auth": True,       # require Bearer token on /api/discovery/*
     "api_max_tier": "action",       # cap exposed tools: "read" | "action"
+    "api_rate_limit_per_min": 60,   # per-caller tool-call budget; 0 disables
+    "api_rate_burst": 0,            # bucket size; 0 = quarter-minute of budget
+    "api_audit_enabled": True,      # JSONL audit line per discovery tool call
     "mcp_enabled": True,            # start FastMCP HTTP/SSE discovery server
     "mcp_port": 3332,               # discovery MCP transport port (loopback)
     "ollama_base_url": "https://ollama.com",

{code_context_control-2.63.2 → code_context_control-2.64.0}/oracle/oracle_server.py

@@ -6,6 +6,7 @@ import logging
 import socket
 import sys
 import threading
+import time
 import urllib.request
 import webbrowser
 from pathlib import Path
@@ -15,7 +16,7 @@ _PROJECT_ROOT = Path(__file__).resolve().parent.parent
 if str(_PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(_PROJECT_ROOT))
 
-from flask import Flask, Response, jsonify, request  # noqa: E402
+from flask import Flask, Response, jsonify, redirect, request, url_for  # noqa: E402
 
 from oracle.config import ORACLE_DIR, load_config, save_config  # noqa: E402
 from oracle.mcp_oracle import mcp_url, start_mcp_thread  # noqa: E402
@@ -143,6 +144,42 @@ _install_web_guard(
 )
 
 
+# ── Discovery API rate limit + audit (#33) ────────────────
+from oracle.services import discovery_audit  # noqa: E402
+
+# Only tool-executing routes are throttled; /tools, /openapi.json and
+# /mcp-info are cheap reads.
+_RATE_LIMITED_PATHS = {"/api/discovery/call", "/api/discovery/call/stream"}
+
+_limiter: discovery_audit.RateLimiter | None = None
+_limiter_key: tuple[int, int] | None = None
+
+
+def _rate_limiter() -> discovery_audit.RateLimiter:
+    """Rebuild the bucket only when the configured budget actually changes,
+    so a config reload does not silently reset every caller's usage."""
+    global _limiter, _limiter_key
+    key = (int(_cfg.get("api_rate_limit_per_min", 60) or 0),
+           int(_cfg.get("api_rate_burst", 0) or 0))
+    if _limiter is None or key != _limiter_key:
+        _limiter = discovery_audit.RateLimiter(per_minute=key[0], burst=key[1])
+        _limiter_key = key
+    return _limiter
+
+
+def _audit_call(name: str, args: dict, started: float, status: str) -> None:
+    if not _cfg.get("api_audit_enabled", True):
+        return
+    token = extract_bearer(request.headers.get("Authorization"))
+    discovery_audit.record(
+        name,
+        caller=discovery_audit.caller_id(token, request.remote_addr),
+        args=args,
+        duration_ms=(time.monotonic() - started) * 1000.0,
+        status=status,
+    )
+
+
 # ── Discovery API auth guard ──────────────────────────────
 @app.before_request
 def _discovery_auth_guard():
@@ -154,10 +191,28 @@ def _discovery_auth_guard():
         return None  # allow CORS preflight
     if not _cfg.get("api_enabled", True):
         return jsonify({"error": "discovery API disabled"}), 404
+    token = extract_bearer(request.headers.get("Authorization"))
     if _cfg.get("api_require_auth", True):
-        token = extract_bearer(request.headers.get("Authorization"))
         if not verify_api_key(token):
             return jsonify({"error": "unauthorized"}), 401
+
+    # Throttle the endpoints that actually execute tools. Listing tools, the
+    # OpenAPI doc, and mcp-info are cheap and read-only, so they stay open —
+    # a limiter that blocks discovery of the API is just a worse error message.
+    if request.path.rstrip("/") in _RATE_LIMITED_PATHS or \
+            request.path.startswith("/api/discovery/tools/"):
+        limiter = _rate_limiter()
+        allowed, retry_after = limiter.check(
+            discovery_audit.caller_id(token, request.remote_addr)
+        )
+        if not allowed:
+            resp = jsonify({
+                "error": "rate limited",
+                "detail": f"exceeded {limiter.per_minute} tool calls/min",
+                "retry_after": round(retry_after, 2),
+            })
+            resp.headers["Retry-After"] = str(max(1, int(retry_after + 0.999)))
+            return resp, 429
     return None
 
 
@@ -178,6 +233,10 @@ def _local_write_guard():
         return None
     if request.method in ("GET", "HEAD", "OPTIONS"):
         return None
+    # The bootstrap mint is how a browser ACQUIRES the cookie, so it cannot
+    # require one. It runs its own loopback + bootstrap-key/Bearer check.
+    if path == "/api/session/bootstrap":
+        return None
     if verify_api_key(extract_bearer(request.headers.get("Authorization"))):
         return None
     if local_session.verify(request.cookies.get(local_session.COOKIE_NAME)):
@@ -237,14 +296,48 @@ _oracle_html_cache: str | None = None
 @app.route("/")
 def index():
     global _oracle_html_cache
+    # A single-use bootstrap code is the ONLY way to obtain the session
+    # cookie (#31). Redeeming it redirects to a clean "/" so the code does
+    # not linger in the address bar, browser history, or a Referer header.
+    code = request.args.get(local_session.BOOTSTRAP_PARAM)
+    if code:
+        if local_session.is_loopback(request.remote_addr) and \
+                local_session.consume_code(code):
+            resp = redirect(url_for("index"))
+            local_session.attach_cookie(resp)
+            return resp
+        return redirect(url_for("index", stale="1"))
+
     if _oracle_html_cache is None:
         _oracle_html_cache = _build_oracle_html()
-    resp = Response(_oracle_html_cache, mimetype="text/html")
-    # Issue the dashboard session cookie only to loopback browsers; remote
-    # viewers (LAN bind) can read GET dashboards but cannot mutate.
-    if local_session.is_loopback(request.remote_addr):
-        local_session.attach_cookie(resp)
-    return resp
+    # No cookie here by design: plain GET / is readable by any local process,
+    # including one running as a different OS user.
+    return Response(_oracle_html_cache, mimetype="text/html")
+
+
+@app.route("/api/session/bootstrap", methods=["POST"])
+def api_session_bootstrap():
+    """Mint a single-use bootstrap URL. Used by ``c3 oracle open``.
+
+    Authorized by the on-disk bootstrap key (owner-only) or the Discovery
+    Bearer token — both prove same-OS-user access, which is the boundary
+    this feature enforces.
+    """
+    if not local_session.is_loopback(request.remote_addr):
+        return jsonify({"error": "loopback only"}), 403
+    data = request.get_json(silent=True) or {}
+    presented = (data.get("key") or "").strip() or \
+        request.headers.get("X-C3-Bootstrap-Key", "")
+    authorized = local_session.verify_bootstrap_key(presented) or \
+        verify_api_key(extract_bearer(request.headers.get("Authorization")))
+    if not authorized:
+        return jsonify({"error": "unauthorized"}), 401
+    code = local_session.mint_code()
+    base = request.host_url.rstrip("/")
+    return jsonify({
+        "url": f"{base}/?{local_session.BOOTSTRAP_PARAM}={code}",
+        "expires_in": local_session.CODE_TTL_SECONDS,
+    })
 
 
 # ── Health ────────────────────────────────────────────────
@@ -778,7 +871,15 @@ def api_discovery_call():
     args = data.get("args") or {}
     if not isinstance(args, dict):
         return jsonify({"error": "'args' must be an object"}), 400
-    return jsonify(_tool_registry.call_tool(name, args))
+    started = time.monotonic()
+    try:
+        result = _tool_registry.call_tool(name, args)
+    except Exception:
+        _audit_call(name, args, started, "error")
+        raise
+    _audit_call(name, args, started,
+                "error" if isinstance(result, dict) and result.get("error") else "ok")
+    return jsonify(result)
 
 
 @app.route("/api/discovery/tools/<name>", methods=["POST"])
@@ -789,7 +890,25 @@ def api_discovery_call_named(name):
     args = request.get_json(silent=True) or {}
     if not isinstance(args, dict):
         return jsonify({"error": "request body must be a JSON object of arguments"}), 400
-    return jsonify(_tool_registry.call_tool(name, args))
+    started = time.monotonic()
+    try:
+        result = _tool_registry.call_tool(name, args)
+    except Exception:
+        _audit_call(name, args, started, "error")
+        raise
+    _audit_call(name, args, started,
+                "error" if isinstance(result, dict) and result.get("error") else "ok")
+    return jsonify(result)
+
+
+@app.route("/api/activity/discovery", methods=["GET"])
+def api_activity_discovery():
+    """Recent Discovery tool calls for the Activity tab (args are hashed)."""
+    try:
+        limit = max(1, min(500, int(request.args.get("limit", 100))))
+    except (TypeError, ValueError):
+        limit = 100
+    return jsonify({"calls": discovery_audit.read_recent(limit)})
 
 
 @app.route("/api/discovery/call/stream", methods=["POST"])
@@ -1019,6 +1138,12 @@ def run_oracle(port: int = None, open_browser: bool = None):
     url = f"http://localhost:{actual_port}"
     print(f"Oracle Memory Agent  →  {url}  (model: {cfg.get('model', 'gemma4:31b-cloud')})")
 
+    # Publish the bootstrap key so a same-user `c3 oracle open` can mint a
+    # sign-in link. Loading the URL above shows the dashboard read-only (#31).
+    local_session.write_bootstrap_key(ORACLE_DIR)
+    print(f"Sign in with:  c3 oracle open"
+          f"{'' if actual_port == 3331 else f' --port {actual_port}'}")
+
     # Start review agent if enabled
     if cfg.get("review_enabled", True) and _agent:
         _agent.start()
@@ -1045,7 +1170,12 @@ def run_oracle(port: int = None, open_browser: bool = None):
             logging.getLogger("oracle").warning("MCP server not started: %s", e)
 
     if open_browser:
-        threading.Timer(0.8, lambda: webbrowser.open(url)).start()
+        # Auto-open lands signed in: the server mints its own code rather
+        # than making the common case require a second command. This grants
+        # nothing extra — the server already holds the secret, and it opens
+        # the default browser as the same OS user that launched it.
+        signed_in = f"{url}/?{local_session.BOOTSTRAP_PARAM}={local_session.mint_code()}"
+        threading.Timer(0.8, lambda: webbrowser.open(signed_in)).start()
 
     app.run(host=cfg.get("bind_host", "127.0.0.1"), port=actual_port, debug=False, use_reloader=False)