conduct-cli 0.6.0__tar.gz → 0.6.2__tar.gz

{conduct_cli-0.6.0 → conduct_cli-0.6.2}/PKG-INFO

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

{conduct_cli-0.6.0 → conduct_cli-0.6.2}/pyproject.toml

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

{conduct_cli-0.6.0 → conduct_cli-0.6.2}/src/conduct_cli/guard.py

@@ -643,6 +643,38 @@ def cmd_guard_install(args):
     except Exception:
         pass
 
+    # Write signing key if provided by the admin at onboarding time.
+    signing_key_hex = getattr(args, "signing_key", None)
+    if signing_key_hex:
+        _write_signing_key(signing_key_hex)
+
+
+def _write_signing_key(hex_key: str) -> None:
+    """Write a hex-encoded signing key to ~/.conductguard/signing.key.
+
+    Validates that the path resolves within GUARD_DIR (no traversal) and
+    that the value is a valid 64-char hex string (32 bytes).
+    """
+    import re as _re
+    signing_key_path = GUARD_DIR / "signing.key"
+
+    # Path traversal guard.
+    try:
+        resolved = signing_key_path.resolve()
+        resolved.relative_to(GUARD_DIR.resolve())
+    except (ValueError, RuntimeError):
+        print(f"  {RED}Signing key path rejected (traversal check failed).{RESET}")
+        return
+
+    # Must be exactly 64 hex characters (32 bytes).
+    if not _re.fullmatch(r"[0-9a-fA-F]{64}", hex_key.strip()):
+        print(f"  {RED}Invalid signing key: expected 64 hex characters.{RESET}")
+        return
+
+    GUARD_DIR.mkdir(parents=True, exist_ok=True)
+    signing_key_path.write_text(hex_key.strip())
+    print(f"  {GREEN}Signing key written:{RESET} {signing_key_path}")
+
 
 def cmd_guard_join(args):
     invite_code = args.invite_code
@@ -830,6 +862,64 @@ def _report_tools_to_server() -> None:
         pass  # Never surface errors — this is background telemetry
 
 
+def _check_and_upgrade_packages() -> None:
+    """Print installed versions and pip-upgrade if PyPI has a newer release."""
+    import importlib.metadata
+    import urllib.request
+
+    packages = ["conduct-cli", "agent-booster"]
+    installed: dict[str, str] = {}
+    for pkg in packages:
+        try:
+            installed[pkg] = importlib.metadata.version(pkg)
+        except importlib.metadata.PackageNotFoundError:
+            # agent-booster may live under a different Python interpreter
+            try:
+                import subprocess as _sp, shutil
+                for py in ["python3.11", "python3.12", "python3.10"]:
+                    if shutil.which(py):
+                        out = _sp.check_output(
+                            [py, "-c", f"import importlib.metadata; print(importlib.metadata.version('{pkg}'))"],
+                            stderr=_sp.DEVNULL, text=True,
+                        ).strip()
+                        if out:
+                            installed[pkg] = out
+                            break
+                else:
+                    installed[pkg] = "unknown"
+            except Exception:
+                installed[pkg] = "unknown"
+
+    print(f"  conduct-cli {installed['conduct-cli']}  ·  agent-booster {installed['agent-booster']}")
+
+    stale = []
+    for pkg, current in installed.items():
+        if current == "unknown":
+            continue
+        try:
+            with urllib.request.urlopen(f"https://pypi.org/pypi/{pkg}/json", timeout=4) as r:
+                latest = __import__("json").loads(r.read())["info"]["version"]
+            if latest != current:
+                stale.append((pkg, current, latest))
+        except Exception:
+            pass  # offline or PyPI down — skip silently
+
+    if not stale:
+        return
+
+    print(f"  {YELLOW}Updates available:{RESET} " + ", ".join(f"{p} {c} → {l}" for p, c, l in stale))
+    try:
+        import subprocess
+        pkgs = [p for p, _, _ in stale]
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "--quiet"] + pkgs,
+            check=True,
+        )
+        print(f"  {GREEN}Updated:{RESET} " + ", ".join(f"{p} → {l}" for p, _, l in stale))
+    except Exception as e:
+        print(f"  {YELLOW}Auto-update failed:{RESET} {e} — run: pip install --upgrade {' '.join(p for p,_,_ in stale)}")
+
+
 def cmd_guard_sync(args):
     cfg          = _require_guard_config()
     workspace_id = cfg.get("workspace_id")
@@ -841,6 +931,7 @@ def cmd_guard_sync(args):
 
     dry_run = getattr(args, "dry_run", False)
     print(f"{'[dry-run] ' if dry_run else ''}Syncing policy…")
+    _check_and_upgrade_packages()
 
     try:
         policy = _req(
@@ -891,6 +982,24 @@ def cmd_guard_sync(args):
     _save_policy(policy)
     print(f"  {GREEN}Policy refreshed:{RESET} {rule_count} rule(s)")
 
+    # Refresh member token from server (workspace API key → fresh guard-mt- token).
+    # Never rely on the locally-cached value — it may be stale or missing.
+    try:
+        installed = _req(
+            "GET",
+            f"{base_url}/guard/config/installed?workspace_id={workspace_id}",
+            api_key=api_key,
+        )
+        fresh_token = installed.get("member_token") or ""
+        if fresh_token:
+            cfg["member_token"] = fresh_token
+            _save_guard_config(cfg)
+        else:
+            print(f"  {YELLOW}Warning: server returned no member token — proxy env may be stale{RESET}")
+    except Exception as e:
+        fresh_token = ""
+        print(f"  {YELLOW}Warning: could not refresh member token ({e}) — using cached value{RESET}")
+
     # Write LLM proxy env vars so any AI tool (Claude Code, Cursor, Codex, …)
     # routes through Conduct Guard. Customer-overridable via --proxy-url or
     # CONDUCT_PROXY_URL env var; defaults to api.conductai.ai/proxy.
@@ -1499,6 +1608,23 @@ def cmd_guard_audit(args):
         decision = ev.get("decision", "—")
         rule     = (ev.get("rule_id") or ev.get("rule_message") or "—")
 
+        # policy_signature_invalid events get a distinct BLOCK prefix line.
+        if rule == "policy_signature_invalid":
+            hostname = ""
+            try:
+                import json as _j
+                payload = _j.loads(ev.get("input_summary") or "{}")
+                hostname = payload.get("hostname", ev.get("hostname") or "")
+            except Exception:
+                pass
+            ws_slug = cfg.get("workspace_id", "")
+            print(
+                f"  {RED}[BLOCK]{RESET} {GRAY}{ts}{RESET} "
+                f"policy_signature_invalid "
+                f"host={hostname} workspace={ws_slug}"
+            )
+            continue
+
         dec_color = RED if decision == "blocked" else GREEN if decision == "allowed" else GRAY
         print(
             f"  {GRAY}{ts:<{ts_w}}{RESET} "
@@ -1542,6 +1668,16 @@ def register_guard_parser(sub):
         help="Time window: 1h, 24h, 7d, 30d (default: 24h)",
     )
 
+    # conduct guard install [--signing-key <hex>]
+    install_p = guard_sub.add_parser("install", help="Install Guard hook and download policies")
+    install_p.add_argument(
+        "--signing-key",
+        default=None,
+        metavar="HEX",
+        help="Hex-encoded 32-byte signing key from POST /workspaces/{id}/signing-key. "
+             "Written to ~/.conductguard/signing.key.",
+    )
+
     # conduct guard booster-status
     guard_sub.add_parser("booster-status", help="Verify Agent Booster intercept is active for this project")
 
@@ -1655,6 +1791,8 @@ def dispatch_guard(args, guard_p):
         cmd_guard_savings(args)
     elif guard_command == "audit":
         cmd_guard_audit(args)
+    elif guard_command == "install":
+        cmd_guard_install(args)
     elif guard_command == "booster-status":
         cmd_guard_booster_status(args)
     else:

{conduct_cli-0.6.0 → conduct_cli-0.6.2}/src/conduct_cli/hook_session_start_template.py

@@ -9,12 +9,71 @@ SNAPSHOT_PATH = Path.home() / ".conductguard" / "session_snapshot.json"
 MAX_AGE_HOURS = 2
 
 
+CONDUCT_ENV_PATH = Path.home() / ".conduct" / "env"
+GUARD_CONFIG_PATH = Path.home() / ".conductguard" / "config.json"
+
+
+def _check_proxy_token() -> None:
+    """Warn + alert server if the proxy token is missing or malformed.
+
+    Reads ~/.conduct/env directly (not shell env) so this works regardless
+    of whether the user sourced their rc file in this session.
+    """
+    if not CONDUCT_ENV_PATH.exists():
+        return
+    env_text = CONDUCT_ENV_PATH.read_text()
+    # Check if proxy is configured and token is valid
+    has_base_url = 'ANTHROPIC_BASE_URL=' in env_text
+    has_valid_token = 'ANTHROPIC_API_KEY="guard-mt-' in env_text or "ANTHROPIC_API_KEY='guard-mt-" in env_text
+    if not has_base_url:
+        return  # proxy not configured — nothing to check
+    if has_valid_token:
+        return  # all good
+
+    # Token is missing or malformed — warn locally and ping the server
+    print("## ConductGuard: proxy token missing or malformed")
+    print("Run `conduct guard sync` to refresh your token before making LLM calls.\n")
+
+    # Alert the server so the admin can prompt the developer to re-sync
+    try:
+        cfg: dict = {}
+        if GUARD_CONFIG_PATH.exists():
+            cfg = json.loads(GUARD_CONFIG_PATH.read_text())
+        workspace_id = cfg.get("workspace_id", "")
+        clerk_user_id = cfg.get("clerk_user_id", "") or cfg.get("user_email", "")
+        api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
+        member_token = cfg.get("member_token", "")
+        if workspace_id and member_token:
+            import urllib.request
+            payload = json.dumps({
+                "workspace_id": workspace_id,
+                "clerk_user_id": clerk_user_id,
+                "ai_tool": "claude_code",
+                "tool_call": "session_start",
+                "decision": "warned",
+                "rule_id": "proxy_token_missing",
+                "rule_message": "Developer proxy token missing or malformed — run conduct guard sync",
+                "input_summary": "session_start: proxy token not found in ~/.conduct/env",
+            }).encode()
+            req = urllib.request.Request(
+                f"{api_url}/guard/events",
+                data=payload,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            urllib.request.urlopen(req, timeout=3)
+    except Exception:
+        pass  # best-effort — never block the session
+
+
 def main():
     try:
         sys.stdin.read()
     except Exception:
         pass
 
+    _check_proxy_token()
+
     if not SNAPSHOT_PATH.exists():
         sys.exit(0)
 

{conduct_cli-0.6.0 → conduct_cli-0.6.2}/src/conduct_cli/hook_template.py

@@ -38,6 +38,7 @@ BUDGET_CACHE_TTL    = 300  # 5 minutes
 VERSION_CACHE_PATH  = GUARD_DIR / "version_cache.json"
 VERSION_CACHE_TTL   = 60   # 1 minute — matches server poll window
 WARNED_RULES_PATH   = GUARD_DIR / "warned_rules.json"
+SIGNING_KEY_PATH    = GUARD_DIR / "signing.key"
 
 
 _DAEMON_URL = "http://127.0.0.1:7878"
@@ -51,6 +52,91 @@ def _daemon_alive() -> bool:
         return False
 
 
+def _verify_policy_signature(policy_dict: dict) -> bool:
+    """Verify HMAC-SHA256 signature on a policy dict. Returns True on success.
+
+    If SIGNING_KEY_PATH does not exist (dev mode / workspace has no signing key),
+    always returns True for backwards compatibility.
+
+    Uses hmac.compare_digest to prevent timing attacks.
+    """
+    import hashlib as _hashlib
+    import hmac as _hmac
+
+    # Path traversal guard: ensure SIGNING_KEY_PATH resolves within GUARD_DIR.
+    try:
+        resolved = SIGNING_KEY_PATH.resolve()
+        resolved.relative_to(GUARD_DIR.resolve())
+    except (ValueError, RuntimeError):
+        return True  # path outside guard dir -- skip verification
+
+    if not SIGNING_KEY_PATH.exists():
+        return True  # no local key -- dev mode, backwards compat
+
+    try:
+        raw = SIGNING_KEY_PATH.read_text().strip()
+        key_bytes = bytes.fromhex(raw)
+    except Exception:
+        return True  # unreadable or malformed key -- skip verification
+
+    expected_sig = policy_dict.get("signature")
+    if not expected_sig:
+        # Policy has no signature but we have a local key -- treat as invalid.
+        return False
+
+    # Reconstruct the canonical body the server signed.
+    body_dict = {k: v for k, v in policy_dict.items() if k not in ("signature", "signed_at")}
+    canonical = json.dumps(body_dict, sort_keys=True, separators=(",", ":"))
+    computed_sig = _hmac.new(key_bytes, canonical.encode(), _hashlib.sha256).hexdigest()
+
+    return _hmac.compare_digest(expected_sig, computed_sig)
+
+
+def _post_signature_invalid_event(expected_sig, computed_sig, policy_version, hostname):
+    """Fire-and-forget audit event for a failed signature check."""
+    try:
+        cfg = json.loads(CONFIG_PATH.read_text()) if CONFIG_PATH.exists() else {}
+    except Exception:
+        return
+    workspace_id = cfg.get("workspace_id")
+    if not workspace_id:
+        return
+    import platform as _platform
+    _hostname = hostname or _platform.node()
+    payload = json.dumps({
+        "workspace_id":  workspace_id,
+        "clerk_user_id": cfg.get("user_email"),
+        "user_email":    cfg.get("user_email"),
+        "ai_tool":       "hook",
+        "tool_call":     "policy_signature_invalid",
+        "input_summary": json.dumps({
+            "expected_signature": expected_sig or "",
+            "computed_signature": computed_sig or "",
+            "policy_version": policy_version or "",
+            "hostname": _hostname,
+        })[:500],
+        "decision":      "blocked",
+        "rule_id":       "policy_signature_invalid",
+        "rule_message":  "Policy signature verification failed",
+        "hostname":      _hostname,
+    })
+    api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
+    script = (
+        "import urllib.request\n"
+        "try:\n"
+        f"    req = urllib.request.Request(\"{api_url}/guard/events\","
+        f" data={repr(payload.encode())}, headers={{\"Content-Type\": \"application/json\"}}, method=\"POST\")\n"
+        "    urllib.request.urlopen(req, timeout=5)\n"
+        "except: pass\n"
+    )
+    subprocess.Popen(
+        [sys.executable, "-c", script],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+
+
 def _maybe_sync_policy():
     """Sync policy from daemon (instant) or remote API (once per minute). Never raises."""
     try:
@@ -78,6 +164,19 @@ def _maybe_sync_policy():
         req = urllib.request.Request(url, headers={"Authorization": f"Bearer {api_key}"} if api_key else {})
         with urllib.request.urlopen(req, timeout=2) as resp:
             remote = json.loads(resp.read())
+
+        # Verify signature before writing to disk. If verification fails, keep
+        # the existing cached policy and emit an audit event.
+        import platform as _platform
+        if not _verify_policy_signature(remote):
+            _post_signature_invalid_event(
+                expected_sig=remote.get("signature"),
+                computed_sig=None,
+                policy_version=remote.get("version"),
+                hostname=_platform.node(),
+            )
+            return  # do not overwrite the cached policy with a tampered one
+
         remote_version = remote.get("version", "")
         local_version = ""
         if POLICY_PATH.exists():
@@ -176,6 +275,17 @@ except Exception:
         except Exception:
             return None, "allow", None, None
 
+        # Verify the cached policy's signature on every hook invocation.
+        if not _verify_policy_signature(policy):
+            import platform as _platform
+            _post_signature_invalid_event(
+                expected_sig=policy.get("signature"),
+                computed_sig=None,
+                policy_version=policy.get("version"),
+                hostname=_platform.node(),
+            )
+            return None, "allow", None, None
+
         rules      = policy.get("rules", [])
         # For Bash, match against operator signature (argv[0] + subcommand + flags) — not raw JSON.
         # Prevents false positives where dangerous patterns appear inside quoted argument values

{conduct_cli-0.6.0 → conduct_cli-0.6.2}/src/conduct_cli.egg-info/PKG-INFO

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