conduct-cli 0.6.14__tar.gz → 0.6.16__tar.gz

{conduct_cli-0.6.14 → conduct_cli-0.6.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.6.14
+Version: 0.6.16
 Summary: CLI for Conduct AI — install agents, manage projects, run tests
 Author-email: Conduct AI <hello@conductai.ai>
 License: MIT

{conduct_cli-0.6.14 → conduct_cli-0.6.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conduct-cli"
-version = "0.6.14"
+version = "0.6.16"
 description = "CLI for Conduct AI — install agents, manage projects, run tests"
 readme = "README.md"
 license = { text = "MIT" }

{conduct_cli-0.6.14 → conduct_cli-0.6.16}/src/conduct_cli/guard.py

@@ -28,6 +28,40 @@ def _read_template(name: str) -> str:
     return (_TEMPLATES_DIR / name).read_text()
 
 
+# ── Thin launcher content ─────────────────────────────────────────────────────
+
+_THIN_LAUNCHERS = {
+    "pretooluse": (
+        "#!/usr/bin/env python3\n"
+        "from conduct_cli.hooks.pretooluse import main; main()\n"
+    ),
+    "posttooluse": (
+        "#!/usr/bin/env python3\n"
+        "from conduct_cli.hooks.posttooluse import main; main()\n"
+    ),
+    "stop": (
+        "#!/usr/bin/env python3\n"
+        "from conduct_cli.hooks.stop import main; main()\n"
+    ),
+    "precompact": (
+        "#!/usr/bin/env python3\n"
+        "from conduct_cli.hooks.precompact import main; main()\n"
+    ),
+    "session-start": (
+        "#!/usr/bin/env python3\n"
+        "from conduct_cli.hooks.session_start import main; main()\n"
+    ),
+}
+
+# Detect whether an installed hook is already a thin launcher (contains the import)
+def _is_thin_launcher(path: Path) -> bool:
+    try:
+        text = path.read_text()
+        return "from conduct_cli.hooks." in text
+    except Exception:
+        return False
+
+
 
 
 # ── Policy engine (also embedded in hook_template.py for standalone use) ──────
@@ -139,16 +173,31 @@ def _best_python() -> str:
 # ── Hook write helper ─────────────────────────────────────────────────────────
 
 def _write_hook(path: Path) -> None:
-    """Write hook_template.py to path, then py_compile-validate it.
+    """Write a thin launcher to path (or legacy template for backward compat), then validate.
+
+    Thin launcher (new default):
+        #!/usr/bin/env python3
+        from conduct_cli.hooks.pretooluse import main; main()
+
+    If conduct_cli.hooks is not importable (e.g. editable install not set up),
+    falls back to writing the full template so hooks still work.
     On syntax failure: restores previous hook (or writes a safe stub) so the
-    system is never left without a working hook file."""
-    import py_compile, tempfile, os
-    # Stash existing hook so we can restore on failure
+    system is never left without a working hook file.
+    """
+    import py_compile
     backup = None
     if path.exists():
         backup = path.read_text()
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(_read_template("hook_template.py"))
+
+    # Prefer thin launcher; fall back to full template if package not importable
+    try:
+        import conduct_cli.hooks.pretooluse  # noqa: F401
+        content = _THIN_LAUNCHERS["pretooluse"]
+    except ImportError:
+        content = _read_template("hook_template.py")
+
+    path.write_text(content)
     path.chmod(0o755)
     try:
         py_compile.compile(str(path), doraise=True)
@@ -162,20 +211,33 @@ def _write_hook(path: Path) -> None:
         ) from exc
 
 
+def _write_session_hook(path: Path, launcher_key: str, template_name: str) -> None:
+    """Write a thin launcher (or legacy template) for a session hook.
+
+    If conduct_cli.hooks is importable, writes the thin launcher.
+    Falls back to the full template so old installs continue to work.
+    Also rewrites old-style (non-thin) hooks to thin launchers on sync.
+    """
+    try:
+        import conduct_cli.hooks  # noqa: F401
+        content = _THIN_LAUNCHERS[launcher_key]
+    except ImportError:
+        content = _read_template(template_name)
+    path.write_text(content)
+    path.chmod(0o755)
+
+
 def _install_session_hooks() -> None:
     """Write PreCompact + SessionStart + Stop hook scripts and register them in ~/.claude/settings.json."""
     python = _best_python()
 
-    precompact_path = GUARD_DIR / "guard-precompact.py"
+    precompact_path    = GUARD_DIR / "guard-precompact.py"
     session_start_path = GUARD_DIR / "guard-session-start.py"
-    stop_path = GUARD_DIR / "guard-stop.py"
+    stop_path          = GUARD_DIR / "guard-stop.py"
 
-    precompact_path.write_text(_read_template("hook_precompact_template.py"))
-    precompact_path.chmod(0o755)
-    session_start_path.write_text(_read_template("hook_session_start_template.py"))
-    session_start_path.chmod(0o755)
-    stop_path.write_text(_read_template("hook_stop_template.py"))
-    stop_path.chmod(0o755)
+    _write_session_hook(precompact_path,    "precompact",    "hook_precompact_template.py")
+    _write_session_hook(session_start_path, "session-start", "hook_session_start_template.py")
+    _write_session_hook(stop_path,          "stop",          "hook_stop_template.py")
 
     claude_settings = Path.home() / ".claude" / "settings.json"
     settings: dict = {}
@@ -353,6 +415,9 @@ def _register_mcp(workspace_id: str, member_token: str, api_url: str) -> None:
     # so all LLM calls route through the Guard proxy (PII blocking, spend limits, audit).
     _patch_claude_desktop_proxy(api_url, member_token)
 
+    # Cursor global rules — write Guard policies as user rules so they apply across all projects.
+    _patch_cursor_global_rules()
+
 
 def _patch_claude_desktop_proxy(api_url: str, member_token: str) -> None:
     """Patch Claude Desktop config to route LLM calls through the Guard proxy.
@@ -383,6 +448,46 @@ def _patch_claude_desktop_proxy(api_url: str, member_token: str) -> None:
         print(f"  {YELLOW}Restart Claude Desktop for proxy routing to take effect{RESET}")
 
 
+def _patch_cursor_global_rules() -> None:
+    """Write ConductGuard policy rules into Cursor's global user rules setting.
+
+    Cursor IDE stores global rules in settings.json under cursor.rules.user —
+    a plain text string injected as system context for every conversation.
+    This is soft enforcement (prompt-level), not structural like Claude Code hooks,
+    but ensures Guard policies are visible to the model across all Cursor projects.
+    """
+    GUARD_RULES = (
+        "# ConductGuard — team AI policies (managed by conduct guard sync)\n"
+        "- ALWAYS call guard_check (via conductguard MCP) before running shell commands, "
+        "reading or writing files, accessing external APIs, or modifying code.\n"
+        "- NEVER write credentials, API keys, or secrets to files or output.\n"
+        "- NEVER send PII (emails, names, SSNs, payment data) to external endpoints.\n"
+        "- If guard_check returns BLOCKED: stop and explain the policy rule to the user.\n"
+        "- If guard_check returns WARNING: proceed but surface the warning.\n"
+        "- These rules are enforced by your team's ConductGuard policy. Do not bypass them."
+    )
+
+    candidates = [
+        Path.home() / "Library" / "Application Support" / "Cursor" / "User" / "settings.json",
+        Path.home() / ".config" / "Cursor" / "User" / "settings.json",
+        Path.home() / "AppData" / "Roaming" / "Cursor" / "User" / "settings.json",
+    ]
+    for settings_path in candidates:
+        if not settings_path.exists():
+            continue
+        try:
+            cfg = json.loads(settings_path.read_text())
+        except (json.JSONDecodeError, OSError):
+            cfg = {}
+        existing = cfg.get("cursor.rules.user", "")
+        if "ConductGuard" in existing:
+            print(f"  {GRAY}Cursor global rules already contain ConductGuard policy{RESET}")
+            continue
+        cfg["cursor.rules.user"] = (existing + "\n\n" + GUARD_RULES).strip()
+        settings_path.write_text(json.dumps(cfg, indent=2))
+        print(f"  {GREEN}Cursor global rules updated with ConductGuard policy{RESET}")
+
+
 def _install_codex_hook(hook_path: Path) -> None:
     """Register PreToolUse and PostToolUse hooks in ~/.codex/hooks.json."""
     codex_hooks = Path.home() / ".codex" / "hooks.json"
@@ -1750,6 +1855,17 @@ def register_guard_parser(sub):
     # conduct guard skip-setup
     guard_sub.add_parser("skip-setup", help="Suppress the Guard setup reminder (does not disable Guard)")
 
+    # conduct guard debug-hook <toolname>
+    debug_hook_p = guard_sub.add_parser(
+        "debug-hook",
+        help="Run any hook standalone with JSON from stdin and print what it would do",
+    )
+    debug_hook_p.add_argument(
+        "toolname",
+        choices=["pretooluse", "posttooluse", "stop", "precompact", "session-start"],
+        help="Which hook to test",
+    )
+
     return guard_p, guard_sub
 
 
@@ -1846,6 +1962,53 @@ def cmd_guard_booster_status(args):
     print()
 
 
+def cmd_guard_debug_hook(args):
+    """Run a hook module standalone with JSON piped from stdin and print the outcome.
+
+    Usage:
+        echo '{"tool_name":"Bash","tool_input":{"command":"rm -rf /"}}' | \\
+            conduct guard debug-hook pretooluse
+    """
+    import subprocess as _sp
+    toolname = args.toolname  # pretooluse | posttooluse | stop | precompact | session-start
+
+    module_map = {
+        "pretooluse":   "conduct_cli.hooks.pretooluse",
+        "posttooluse":  "conduct_cli.hooks.posttooluse",
+        "stop":         "conduct_cli.hooks.stop",
+        "precompact":   "conduct_cli.hooks.precompact",
+        "session-start":"conduct_cli.hooks.session_start",
+    }
+    module = module_map[toolname]
+
+    print(f"{BOLD}conduct guard debug-hook {toolname}{RESET}")
+    print(f"{GRAY}Reading JSON from stdin (send EOF when done — Ctrl+D)…{RESET}\n")
+
+    stdin_data = sys.stdin.read()
+    if not stdin_data.strip():
+        # Provide a neutral no-op payload so the hook doesn't crash
+        stdin_data = "{}"
+
+    result = _sp.run(
+        [sys.executable, "-c", f"from {module} import main; main()"],
+        input=stdin_data,
+        capture_output=True,
+        text=True,
+    )
+
+    if result.stdout:
+        print(f"{BOLD}stdout:{RESET}")
+        print(result.stdout)
+    if result.stderr:
+        print(f"{BOLD}stderr:{RESET}")
+        print(result.stderr)
+
+    exit_label = {0: f"{GREEN}0 — allowed{RESET}", 2: f"{RED}2 — blocked{RESET}"}.get(
+        result.returncode, f"{YELLOW}{result.returncode}{RESET}"
+    )
+    print(f"\n{BOLD}Exit code:{RESET} {exit_label}")
+
+
 def dispatch_guard(args, guard_p):
     """Dispatch to the correct guard handler. Called from main()."""
     guard_command = getattr(args, "guard_command", None)
@@ -1861,6 +2024,8 @@ def dispatch_guard(args, guard_p):
         cmd_guard_install(args)
     elif guard_command == "booster-status":
         cmd_guard_booster_status(args)
+    elif guard_command == "debug-hook":
+        cmd_guard_debug_hook(args)
     else:
         guard_p.print_help()
         sys.exit(1)

conduct_cli-0.6.16/src/conduct_cli/hooks/__init__.py

@@ -0,0 +1 @@
+# ConductGuard hook package — shared utilities + per-hook entrypoints.

conduct_cli-0.6.16/src/conduct_cli/hooks/base.py

@@ -0,0 +1,220 @@
+"""Shared primitives for all ConductGuard hook modules.
+
+Everything here is stdlib-only so hooks work from a bare `pip install conduct-cli`
+with no shell rc sourced.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import time
+import urllib.request
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal, Optional
+
+# ── Canonical paths ───────────────────────────────────────────────────────────
+
+GUARD_DIR          = Path.home() / ".conductguard"
+CONFIG_PATH        = GUARD_DIR / "config.json"
+POLICY_PATH        = GUARD_DIR / "policy.json"
+BUDGET_CACHE_PATH  = GUARD_DIR / "budget_cache.json"
+BUDGET_CACHE_TTL   = 300   # seconds
+VERSION_CACHE_PATH = GUARD_DIR / "version_cache.json"
+VERSION_CACHE_TTL  = 60    # seconds
+WARNED_RULES_PATH  = GUARD_DIR / "warned_rules.json"
+SIGNING_KEY_PATH   = GUARD_DIR / "signing.key"
+JOURNAL_DIR        = GUARD_DIR / "journal"
+JOURNAL_PID_PATH   = JOURNAL_DIR / "drain.pid"
+
+SNAPSHOT_PATH    = GUARD_DIR / "session_snapshot.json"
+CONDUCT_ENV_PATH = Path.home() / ".conduct" / "env"
+
+# ── Result type ───────────────────────────────────────────────────────────────
+
+@dataclass
+class HookResult:
+    action: Literal["allow", "block", "warn"]
+    reason: Optional[str] = None
+    metadata: dict = field(default_factory=dict)
+
+
+# ── Config loading ────────────────────────────────────────────────────────────
+
+def load_config() -> dict:
+    """Return ~/.conductguard/config.json as a dict; empty dict on any error."""
+    try:
+        if CONFIG_PATH.exists():
+            return json.loads(CONFIG_PATH.read_text())
+    except Exception:
+        pass
+    return {}
+
+
+# ── Repo / tool detection ─────────────────────────────────────────────────────
+
+def detect_repo() -> Optional[str]:
+    """Return 'owner/repo' from git remote origin, or None."""
+    try:
+        out = subprocess.check_output(
+            ["git", "remote", "get-url", "origin"],
+            stderr=subprocess.DEVNULL, text=True,
+        ).strip()
+        if "github.com" in out:
+            return out.split("github.com")[-1].lstrip("/:").rstrip(".git")
+    except Exception:
+        pass
+    return None
+
+
+def detect_ai_tool() -> str:
+    """Return a string identifying the active AI coding tool."""
+    import os
+    if os.environ.get("CLAUDE_CODE_ENTRYPOINT") or os.environ.get("CLAUDECODE"):
+        return "claude-code"
+    if os.environ.get("CODEX_SESSION_ID") or os.environ.get("CODEX_CLI_VERSION"):
+        return "codex"
+    term = os.environ.get("TERM_PROGRAM", "").lower()
+    if term == "cursor":
+        return "cursor"
+    if term == "windsurf":
+        return "windsurf"
+    path = os.environ.get("PATH", "")
+    if "Codex.app" in path or "codex" in path.lower():
+        return "codex"
+    if "cursor" in path.lower():
+        return "cursor"
+    if "windsurf" in path.lower():
+        return "windsurf"
+    return "claude-code"
+
+
+# ── Journal / drain (fire-and-forget event posting) ───────────────────────────
+
+def journal_append(payload_str: str, api_url: str) -> None:
+    """Atomically write one event to the journal for the drain daemon to pick up."""
+    try:
+        JOURNAL_DIR.mkdir(parents=True, exist_ok=True)
+        import random
+        name = f"{time.time_ns()}_{random.randint(0, 9999):04d}.json"
+        entry = json.dumps({"api_url": api_url, "payload": payload_str})
+        tmp = JOURNAL_DIR / (name + ".tmp")
+        tmp.write_text(entry)
+        tmp.rename(JOURNAL_DIR / name)
+    except Exception:
+        pass
+
+
+def ensure_drain_daemon(hook_module_path: Optional[Path] = None) -> None:
+    """Start the drain daemon if it is not already running.
+
+    hook_module_path — path of the calling hook file (used to spawn the daemon
+    via `python <path> drain`).  When None the drain subprocess is not started
+    (used in unit tests / debug mode where the daemon is not needed).
+    """
+    try:
+        if JOURNAL_PID_PATH.exists():
+            pid = int(JOURNAL_PID_PATH.read_text().strip())
+            import os as _os
+            try:
+                _os.kill(pid, 0)
+                return  # alive
+            except (ProcessLookupError, PermissionError):
+                pass
+        if hook_module_path is None:
+            return
+        subprocess.Popen(
+            [sys.executable, str(hook_module_path), "drain"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    except Exception:
+        pass
+
+
+def run_drain_daemon() -> None:
+    """Drain the journal directory to the API.  Call via `python hook.py drain`."""
+    import os as _os
+    try:
+        JOURNAL_DIR.mkdir(parents=True, exist_ok=True)
+        JOURNAL_PID_PATH.write_text(str(_os.getpid()))
+    except Exception:
+        return
+    empty_scans = 0
+    while empty_scans < 3:
+        files = sorted(f for f in JOURNAL_DIR.glob("*.json") if f.name != "drain.pid")
+        if not files:
+            empty_scans += 1
+            time.sleep(2)
+            continue
+        posted_any = False
+        for f in files:
+            try:
+                entry = json.loads(f.read_text())
+                api_url = entry["api_url"]
+                payload = (
+                    entry["payload"].encode()
+                    if isinstance(entry["payload"], str)
+                    else entry["payload"]
+                )
+                req = urllib.request.Request(
+                    f"{api_url}/guard/events",
+                    data=payload,
+                    headers={"Content-Type": "application/json"},
+                    method="POST",
+                )
+                urllib.request.urlopen(req, timeout=8)
+                f.unlink(missing_ok=True)
+                posted_any = True
+            except Exception:
+                pass
+        if not posted_any:
+            empty_scans += 1
+            time.sleep(2)
+        else:
+            empty_scans = 0
+    try:
+        JOURNAL_PID_PATH.unlink(missing_ok=True)
+    except Exception:
+        pass
+
+
+def post_event(
+    tool_name: str,
+    tool_input: dict,
+    decision: str,
+    rule_id: Optional[str] = None,
+    message: Optional[str] = None,
+    session_id: Optional[str] = None,
+    *,
+    drain_via: Optional[Path] = None,
+) -> None:
+    """Post one guard event via the journal/drain pattern.  Never raises.
+
+    drain_via — path of the calling hook file passed to ensure_drain_daemon().
+    """
+    cfg = load_config()
+    workspace_id = cfg.get("workspace_id")
+    if not workspace_id:
+        return
+    import platform as _platform
+    _os_info = f"{_platform.system()} {_platform.release()} {_platform.machine()}".strip()
+    payload = json.dumps({
+        "workspace_id":    workspace_id,
+        "clerk_user_id":   cfg.get("user_email"),
+        "user_email":      cfg.get("user_email"),
+        "ai_tool":         detect_ai_tool(),
+        "tool_call":       tool_name,
+        "input_summary":   json.dumps(tool_input)[:200],
+        "decision":        decision,
+        "rule_id":         rule_id,
+        "rule_message":    message,
+        "hook_session_id": session_id,
+        "os_info":         _os_info,
+        "hostname":        _platform.node(),
+    })
+    api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
+    journal_append(payload, api_url)
+    ensure_drain_daemon(drain_via)