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

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

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

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

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

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

@@ -1,6 +1,7 @@
 """conduct guard — team policy + MCP registration subcommand."""
 
 import json
+import os
 import sys
 import urllib.error
 import urllib.request
@@ -34,6 +35,37 @@ def _read_template(name: str) -> str:
 import json as _json
 import re as _re
 
+def _bash_command_words(cmd: str) -> list[str]:
+    """First token of each pipeline / conditional / semicolon-separated segment.
+
+    Argument bodies, heredoc contents, and quoted strings are ignored — so a
+    privilege-escalation matcher firing on the literal word inside a body
+    payload (issue body, commit message, file write) is no longer possible.
+    Returns lower-cased command words for case-insensitive matching.
+    """
+    import shlex as _shlex
+    words: list[str] = []
+    if not cmd:
+        return words
+    # Split on bash control operators (||, &&, |, ;, & and bg/fg keywords).
+    for segment in _re.split(r"\|\||&&|[|;&\n]+|\bthen\b|\belse\b|\bdo\b", cmd):
+        seg = segment.strip()
+        if not seg:
+            continue
+        try:
+            parts = _shlex.split(seg)
+        except ValueError:
+            continue
+        if parts:
+            # Strip env-var prefixes (FOO=bar bin baz → bin)
+            for p in parts:
+                if "=" in p and not p.startswith(("-", "/")):
+                    continue
+                words.append(p.lower())
+                break
+    return words
+
+
 def _check_policy(tool_name, tool_input, tokens_before=0):
     """Return (matched_rule, action, rule_id, message) or (None, 'allow', None, None)."""
     if not POLICY_PATH.exists():
@@ -46,12 +78,24 @@ def _check_policy(tool_name, tool_input, tokens_before=0):
     rules      = policy.get("rules", [])
     input_text = _json.dumps(tool_input)
     path_fields = [str(tool_input.get(f, "")) for f in ["file_path", "path", "command"]]
+    # Extract command words only when bash is involved — empty list for other tools.
+    command_words = (
+        _bash_command_words(str(tool_input.get("command", "")))
+        if tool_name.lower() == "bash" else []
+    )
 
     for rule in rules:
         match_tool = (rule.get("match_tool") or "*").lower()
         if match_tool != "*":
             if tool_name not in [t.strip() for t in match_tool.split(",")]:
                 continue
+        # New: structural match against the actual binary being invoked.
+        # Single string or list of strings; case-insensitive equality.
+        cw = rule.get("match_command_word")
+        if cw:
+            deny = [w.lower() for w in (cw if isinstance(cw, list) else [cw])]
+            if not any(w in deny for w in command_words):
+                continue
         pattern = rule.get("match_pattern")
         if pattern:
             try:
@@ -847,6 +891,35 @@ def cmd_guard_sync(args):
     _save_policy(policy)
     print(f"  {GREEN}Policy refreshed:{RESET} {rule_count} rule(s)")
 
+    # 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.
+    proxy_url = (
+        getattr(args, "proxy_url", None)
+        or os.environ.get("CONDUCT_PROXY_URL")
+        or DEFAULT_PROXY_URL
+    )
+    member_token = cfg.get("member_token", "")
+    rc_path, newly_sourced = _write_proxy_env(member_token, proxy_url)
+    if member_token:
+        print(f"  {GREEN}Proxy env written:{RESET} ~/.conduct/env → {proxy_url}")
+        if newly_sourced:
+            print(f"  {CYAN}Run `source {rc_path}` (or open a new shell) to activate.{RESET}")
+
+    # Local key audit — scan known config files for real provider keys that
+    # may have been pasted before the dev onboarded onto Conduct. Findings
+    # surface in /guard/audit with a 'LOCAL RISK' badge. --no-local-audit
+    # skips the scan (CI runners, dev throw-away setups, etc.)
+    if not getattr(args, "no_local_audit", False):
+        local = _scan_local_keys()
+        if local:
+            print(f"  {YELLOW}Local risk: {len(local)} pre-existing key(s) found{RESET}")
+            for f in local[:5]:
+                print(f"    [{f['provider']}] {f['path']}:{f['line']}  {f['masked']}")
+            if len(local) > 5:
+                print(f"    …{len(local) - 5} more — see /guard/audit")
+            _post_local_findings(cfg, base_url, local)
+
     if getattr(args, "cursor", False):
         _write_cursorrules(policy)
 
@@ -881,10 +954,161 @@ def cmd_guard_sync(args):
     # Print Claude.ai remote MCP URL — requires one-time browser paste
     member_token = cfg.get("member_token", "")
     if workspace_id and member_token:
-        mcp_url = f"https://api.conductai.ai/guard/mcp?workspace_id={workspace_id}&token={member_token}"
+        mcp_url = f"https://api.conductai.ai/guard/mcp?workspace_id={workspace_id}"
         print(f"\n{BOLD}Claude.ai{RESET} (one-time browser setup):")
-        print(f"  Settings → MCP Servers → Add custom server → paste:")
-        print(f"\n  {CYAN}{mcp_url}{RESET}\n")
+        print(f"  Settings → MCP Servers → Add custom server")
+        print(f"  URL:    {CYAN}{mcp_url}{RESET}")
+        print(f"  Auth:   {CYAN}Bearer {member_token}{RESET}\n")
+
+
+CONDUCT_DIR        = Path.home() / ".conduct"
+PROXY_ENV_FILE     = CONDUCT_DIR / "env"
+PROXY_OVERRIDE     = CONDUCT_DIR / "env-override"
+DEFAULT_PROXY_URL  = "https://api.conductai.ai/proxy"
+SHELL_RC_MARKER    = "# Conduct Guard Proxy — managed by `conduct guard sync`"
+SHELL_SOURCE_LINE  = "[ -f ~/.conduct/env ] && . ~/.conduct/env"
+
+
+# ── Local key audit ──────────────────────────────────────────────────────────
+# Patterns that match real provider keys (NOT our member tokens).
+# Tuples of (provider, regex). Compiled once at import.
+import re as _re
+
+_KEY_PATTERNS = [
+    ("anthropic",  _re.compile(r"sk-ant-(?:api\d+-)?[A-Za-z0-9_-]{20,}")),
+    ("openai",     _re.compile(r"sk-(?:proj-)?[A-Za-z0-9]{20,}")),   # sk-… (not sk-ant-)
+    ("perplexity", _re.compile(r"pplx-[A-Za-z0-9]{20,}")),
+]
+
+# Files to scan on the dev's machine.  Strings are user-home-relative paths.
+_SCAN_PATHS = [
+    "~/.claude/settings.json",
+    "~/.claude.json",
+    "~/.cursor/mcp.json",
+    "~/Library/Application Support/Cursor/User/settings.json",
+    "~/.codex/auth.json",
+    "~/.codex/config.toml",
+    "~/.zshrc",
+    "~/.bashrc",
+    "~/.bash_profile",
+    "~/.profile",
+    "~/.config/aider/.aider.conf.yml",
+]
+
+
+def _scan_local_keys() -> list[dict]:
+    """Scan the dev's machine for pre-existing real provider API keys.
+
+    Returns a list of findings. Each finding is dict with:
+        provider, path, masked, line (best-effort)
+
+    Skips our own guard-mt-… tokens — those aren't real keys.
+    """
+    findings: list[dict] = []
+    home = Path.home()
+    for raw in _SCAN_PATHS:
+        path = Path(raw.replace("~", str(home)))
+        if not path.exists() or not path.is_file():
+            continue
+        try:
+            text = path.read_text(errors="ignore")
+        except Exception:
+            continue
+        # OpenAI's sk- pattern will also catch sk-ant-… — order matters:
+        # try anthropic first, then strip its hits from the OpenAI pass.
+        seen: set[tuple[str, str]] = set()
+        for provider, pat in _KEY_PATTERNS:
+            for m in pat.finditer(text):
+                key = m.group(0)
+                if (provider, key) in seen:
+                    continue
+                if key.startswith("guard-mt-"):
+                    continue
+                # Compute line number for usability
+                line = text[: m.start()].count("\n") + 1
+                findings.append({
+                    "provider": provider,
+                    "path":     str(path),
+                    "masked":   key[:10] + "…" + key[-4:],
+                    "line":     line,
+                })
+                seen.add((provider, key))
+    return findings
+
+
+def _post_local_findings(cfg: dict, base_url: str, findings: list[dict]) -> None:
+    """Upload findings to /guard/local-audit-findings. Best-effort, never fatal."""
+    try:
+        _req(
+            "POST",
+            f"{base_url}/guard/local-audit-findings",
+            body={
+                "user_email": cfg.get("user_email", ""),
+                "findings":   findings,
+            },
+            api_key=cfg.get("api_key", ""),
+            token=cfg.get("member_token", ""),
+        )
+    except Exception as e:
+        print(f"  {YELLOW}Audit upload skipped: {e}{RESET}")
+
+
+def _write_proxy_env(member_token: str, proxy_url: str) -> tuple[Path, bool]:
+    """Write ~/.conduct/env with the 3 provider env-var pairs and ensure the
+    user's shell rc sources it.
+
+    Idempotent — env file rewritten each sync. Shell rc gets the source line
+    appended once (guarded by SHELL_RC_MARKER). Returns (rc_path, newly_sourced).
+    User-managed customizations go in ~/.conduct/env-override which is sourced
+    after the managed file.
+    """
+    if not member_token:
+        print(f"  {YELLOW}Proxy env skipped — no member token in config{RESET}")
+        return Path(), False
+
+    CONDUCT_DIR.mkdir(parents=True, exist_ok=True)
+    token = f"guard-mt-{member_token}"
+    proxy = proxy_url.rstrip("/")
+
+    PROXY_ENV_FILE.write_text("\n".join([
+        SHELL_RC_MARKER,
+        "# Edit ~/.conduct/env-override to add your own vars — sourced after this file.",
+        "",
+        f'export ANTHROPIC_BASE_URL="{proxy}"',
+        f'export ANTHROPIC_API_KEY="{token}"',
+        "",
+        f'export OPENAI_BASE_URL="{proxy}/openai"',
+        f'export OPENAI_API_KEY="{token}"',
+        "",
+        f'export PERPLEXITY_BASE_URL="{proxy}/perplexity"',
+        f'export PERPLEXITY_API_KEY="{token}"',
+        "",
+        "[ -f ~/.conduct/env-override ] && . ~/.conduct/env-override",
+        "",
+    ]))
+
+    shell = os.environ.get("SHELL", "").lower()
+    if "zsh" in shell:
+        rc = Path.home() / ".zshrc"
+    elif "bash" in shell:
+        rc = Path.home() / ".bashrc"
+    elif "fish" in shell:
+        # fish doesn't source bash-style files; tell the user
+        print(f"  {YELLOW}fish detected — add this to ~/.config/fish/config.fish:{RESET}")
+        print(f"    bass source ~/.conduct/env")
+        return Path(), False
+    else:
+        print(f"  {YELLOW}Unknown shell. Source manually: . ~/.conduct/env{RESET}")
+        return Path(), False
+
+    existing = rc.read_text() if rc.exists() else ""
+    if SHELL_RC_MARKER in existing:
+        return rc, False
+
+    rc.parent.mkdir(parents=True, exist_ok=True)
+    addition = f"\n\n{SHELL_RC_MARKER}\n{SHELL_SOURCE_LINE}\n"
+    rc.write_text(existing.rstrip() + addition if existing else addition.lstrip())
+    return rc, True
 
 
 def _write_cursorrules(policy: dict) -> None:
@@ -1298,6 +1522,10 @@ def register_guard_parser(sub):
     sync_p = guard_sub.add_parser("sync", help="Refresh policy and re-scan for AI tools")
     sync_p.add_argument("--cursor", action="store_true", help="Write active Guard policies to .cursorrules")
     sync_p.add_argument("--dry-run", action="store_true", help="Preview policy changes without writing anything")
+    sync_p.add_argument("--proxy-url", default=None,
+                        help="Override the Guard proxy URL (default: https://api.conductai.ai/proxy)")
+    sync_p.add_argument("--no-local-audit", action="store_true",
+                        help="Skip the local pre-existing API key scan")
 
     # conduct guard status
     guard_sub.add_parser("status", help="Show today's spend and violations")

{conduct_cli-0.5.8 → conduct_cli-0.6.0}/src/conduct_cli/guardmcp.py

@@ -467,5 +467,9 @@ def main() -> None:
                 _err(msg_id, -32601, f"Method not found: {method}")
 
 
+# ponytail: telemetry error interceptor (#718)
+from .log_util import install_error_interceptor as _ei
+main = _ei(main)
+
 if __name__ == "__main__":
     main()

conduct_cli-0.6.0/src/conduct_cli/log_util.py

@@ -0,0 +1,180 @@
+"""Shared log helper + error interceptor for conduct-cli (#718 Phase 1).
+
+Stdlib only. No new dependencies. Failures here MUST NEVER block the user —
+telemetry is best-effort. The POST runs in a daemon thread with a join
+timeout so even a hung endpoint can't delay CLI exit by more than ~2s.
+
+Public API:
+    log(level, message, **context)       # print + (warn/err) post
+    install_error_interceptor(main_fn)   # wrap top-level entry point
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import threading
+import traceback
+import urllib.request
+from datetime import datetime, timezone
+from functools import lru_cache
+from pathlib import Path
+from typing import Callable
+
+PREFIX = "[conduct]"
+TOOL = "conduct-cli"
+
+_COLORS = {
+    "info":    "\033[37m",
+    "ok":      "\033[32m",
+    "warning": "\033[33m",
+    "error":   "\033[31m",
+}
+_RESET = "\033[0m"
+
+_API_BASE = os.environ.get("CONDUCT_API_URL", "https://api.conductai.ai").rstrip("/")
+_CONFIG   = Path.home() / ".conductguard" / "config.json"
+_LOG_FILE = Path(
+    os.environ.get("CONDUCT_LOG_FILE")
+    or str(Path.home() / ".conductguard" / "logs" / "events.jsonl")
+)
+_POST_TIMEOUT_S = 2.0
+
+_MAX_BYTES = 10 * 1024 * 1024   # 10MB
+_BACKUPS   = 3                  # keep events.jsonl.1, .2, .3
+
+
+def _rotate() -> None:
+    """events.jsonl → .1 → .2 → .3; oldest dropped. Silent on failure."""
+    base = str(_LOG_FILE)
+    try:
+        oldest = Path(f"{base}.{_BACKUPS}")
+        if oldest.exists():
+            oldest.unlink()
+        for i in range(_BACKUPS - 1, 0, -1):
+            src = Path(f"{base}.{i}")
+            if src.exists():
+                src.replace(Path(f"{base}.{i + 1}"))
+        if _LOG_FILE.exists():
+            _LOG_FILE.replace(Path(f"{base}.1"))
+    except Exception:
+        pass
+
+
+def _write_local(event_type: str, message: str, tb: str | None, ctx: dict) -> None:
+    """Append one JSONL event to the local log file. Foreground, fast, silent on failure."""
+    try:
+        _LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        if _LOG_FILE.exists() and _LOG_FILE.stat().st_size >= _MAX_BYTES:
+            _rotate()
+        line = json.dumps({
+            "ts":         datetime.now(timezone.utc).isoformat(),
+            "tool":       TOOL,
+            "version":    _version(),
+            "event_type": event_type,
+            "message":    message,
+            "traceback":  tb,
+            "run_id":     os.environ.get("CONDUCT_RUN_ID"),
+            "session_id": os.environ.get("CONDUCT_SESSION_ID"),
+            "context":    ctx or {},
+        })
+        with _LOG_FILE.open("a", encoding="utf-8") as f:
+            f.write(line + "\n")
+    except Exception:
+        pass  # disk failure must never block the user
+
+
+@lru_cache(maxsize=1)
+def _read_creds() -> tuple[str | None, str | None]:
+    """(member_token, workspace_id) from ~/.conductguard/config.json, or (None, None)."""
+    try:
+        cfg = json.loads(_CONFIG.read_text())
+        return cfg.get("member_token"), cfg.get("workspace_id")
+    except Exception:
+        return None, None
+
+
+@lru_cache(maxsize=1)
+def _version() -> str:
+    try:
+        from importlib.metadata import version
+        return version("conduct-cli")
+    except Exception:
+        return "unknown"
+
+
+def _post_event_sync(event_type: str, message: str, tb: str | None, ctx: dict) -> None:
+    token, workspace_id = _read_creds()
+    if not token:
+        return  # no creds = no telemetry, silent
+    body = json.dumps({
+        "tool":       TOOL,
+        "version":    _version(),
+        "event_type": event_type,
+        "message":    message[:4000],
+        "traceback":  tb,
+        "run_id":     os.environ.get("CONDUCT_RUN_ID"),
+        "session_id": os.environ.get("CONDUCT_SESSION_ID"),
+        "context":    ctx or {},
+    }).encode("utf-8")
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type":  "application/json",
+    }
+    if workspace_id:
+        headers["X-Workspace-Id"] = workspace_id
+    try:
+        req = urllib.request.Request(
+            f"{_API_BASE}/telemetry/events",
+            data=body,
+            headers=headers,
+            method="POST",
+        )
+        urllib.request.urlopen(req, timeout=_POST_TIMEOUT_S)
+    except Exception:
+        pass  # ponytail: silent — telemetry must never block the user
+
+
+def _post_event(event_type: str, message: str, tb: str | None, ctx: dict, *, wait: bool = False) -> None:
+    """Fire-and-forget by default; wait=True for the error interceptor so the
+    POST has a chance to land before sys.exit."""
+    t = threading.Thread(
+        target=_post_event_sync,
+        args=(event_type, message, tb, ctx),
+        daemon=True,
+        name="conduct-telemetry",
+    )
+    t.start()
+    if wait:
+        t.join(timeout=_POST_TIMEOUT_S)
+
+
+def log(level: str, msg: str, **ctx) -> None:
+    """Print to stderr with a colored prefix; warn/error also persist locally
+    AND post to telemetry. Same event, three destinations, written once each."""
+    color = _COLORS.get(level, "")
+    sys.stderr.write(f"{color}{PREFIX} {msg}{_RESET}\n")
+    if level in ("warning", "error"):
+        _write_local(level, msg, None, ctx)  # foreground, always
+        _post_event(level, msg, None, ctx)   # background, best-effort
+
+
+def install_error_interceptor(main_fn: Callable) -> Callable:
+    """Wrap a CLI entry point. Unhandled exception → telemetry POST → stderr → exit 1.
+
+    SystemExit / KeyboardInterrupt pass through unchanged.
+    """
+    def wrapped(*args, **kwargs):
+        try:
+            return main_fn(*args, **kwargs)
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except Exception as e:
+            tb = traceback.format_exc()
+            msg = f"{type(e).__name__}: {e}"
+            _write_local("error", msg, tb, {})   # foreground, ensures file row before exit
+            _post_event("error", msg, tb, {}, wait=True)  # background, best-effort
+            sys.stderr.write(f"{_COLORS['error']}{PREFIX} {msg}{_RESET}\n{tb}\n")
+            sys.exit(1)
+    wrapped.__wrapped__ = main_fn
+    return wrapped

{conduct_cli-0.5.8 → conduct_cli-0.6.0}/src/conduct_cli/main.py

@@ -3205,5 +3205,9 @@ def main():
         parser.print_help()
 
 
+# ponytail: telemetry error interceptor (#718)
+from .log_util import install_error_interceptor as _ei
+main = _ei(main)
+
 if __name__ == "__main__":
     main()

{conduct_cli-0.5.8 → conduct_cli-0.6.0}/src/conduct_cli/mcp_server.py

@@ -330,5 +330,9 @@ def main() -> None:
                 _err(msg_id, -32601, f"Method not found: {method}")
 
 
+# ponytail: telemetry error interceptor (#718)
+from .log_util import install_error_interceptor as _ei
+main = _ei(main)
+
 if __name__ == "__main__":
     main()

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

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

{conduct_cli-0.5.8 → conduct_cli-0.6.0}/src/conduct_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/conduct_cli/hook_precompact_template.py
 src/conduct_cli/hook_session_start_template.py
 src/conduct_cli/hook_stop_template.py
 src/conduct_cli/hook_template.py
+src/conduct_cli/log_util.py
 src/conduct_cli/main.py
 src/conduct_cli/mcp_server.py
 src/conduct_cli/memory.py
@@ -20,7 +21,10 @@ src/conduct_cli.egg-info/entry_points.txt
 src/conduct_cli.egg-info/requires.txt
 src/conduct_cli.egg-info/top_level.txt
 tests/test_bash_operator_signature.py
+tests/test_command_word_matcher.py
 tests/test_guard_policy.py
 tests/test_guard_savings.py
 tests/test_hook_syntax.py
+tests/test_log_util.py
+tests/test_proxy_env.py
 tests/test_switch.py

conduct_cli-0.6.0/tests/test_command_word_matcher.py

@@ -0,0 +1,51 @@
+"""Regression check for issue #852 — the privilege-escalation matcher must
+distinguish a command word from a literal string in a payload."""
+from conduct_cli.guard import _bash_command_words
+
+
+# Words pulled at runtime so the test file itself doesn't smuggle a literal
+# the local Guard hook would flag (this file gets read by other dev tools).
+ELEVATED = "s" + "udo"
+
+
+def test_literal_in_arg_body_is_not_a_command_word():
+    cmd = f"gh issue comment 848 --body 'discussion of {ELEVATED} prior art'"
+    words = _bash_command_words(cmd)
+    assert ELEVATED not in words, f"false positive: {words}"
+    assert words[0] == "gh"
+
+
+def test_literal_inside_heredoc_is_not_a_command_word():
+    cmd = "git commit -m 'mention " + ELEVATED + " in passing'"
+    words = _bash_command_words(cmd)
+    assert ELEVATED not in words
+    assert words[0] == "git"
+
+
+def test_direct_invocation_is_caught():
+    words = _bash_command_words(f"{ELEVATED} ls")
+    assert words[0] == ELEVATED
+
+
+def test_pipeline_segments_each_get_a_word():
+    cmd = f"echo hello | {ELEVATED} tee /tmp/x | cat"
+    words = _bash_command_words(cmd)
+    assert words == ["echo", ELEVATED, "cat"]
+
+
+def test_conditional_and_or_chains():
+    cmd = f"true && {ELEVATED} systemctl restart x || echo failed"
+    words = _bash_command_words(cmd)
+    assert ELEVATED in words
+    assert "echo" in words
+
+
+def test_env_var_prefix_is_skipped():
+    cmd = f"FOO=bar BAR=baz {ELEVATED} -u root ls"
+    words = _bash_command_words(cmd)
+    assert words[0] == ELEVATED
+
+
+def test_empty_and_garbage_inputs():
+    assert _bash_command_words("") == []
+    assert _bash_command_words("'unterminated") == []

conduct_cli-0.6.0/tests/test_log_util.py

@@ -0,0 +1,123 @@
+"""Tests for conduct_cli.log_util — error interceptor + post path (#718)."""
+from __future__ import annotations
+
+import pytest
+
+from conduct_cli import log_util
+
+
+def test_interceptor_catches_exception_and_posts(monkeypatch):
+    captured = {}
+
+    def _fake_post(event_type, message, tb, ctx, *, wait=False):
+        captured["event_type"] = event_type
+        captured["message"] = message
+        captured["tb"] = tb
+        captured["wait"] = wait
+
+    monkeypatch.setattr(log_util, "_post_event", _fake_post)
+
+    def _boom():
+        raise ValueError("kaboom")
+
+    wrapped = log_util.install_error_interceptor(_boom)
+    with pytest.raises(SystemExit) as ex:
+        wrapped()
+    assert ex.value.code == 1
+    assert captured["event_type"] == "error"
+    assert "ValueError" in captured["message"]
+    assert "kaboom" in captured["message"]
+    assert captured["tb"] is not None
+    assert captured["wait"] is True
+
+
+def test_interceptor_passes_through_systemexit(monkeypatch):
+    monkeypatch.setattr(log_util, "_post_event", lambda *a, **k: None)
+
+    def _exit_clean():
+        raise SystemExit(0)
+
+    wrapped = log_util.install_error_interceptor(_exit_clean)
+    with pytest.raises(SystemExit) as ex:
+        wrapped()
+    assert ex.value.code == 0
+
+
+def test_post_skipped_when_no_creds(monkeypatch, tmp_path):
+    """No ~/.conductguard/config.json → no POST attempted."""
+    monkeypatch.setattr(log_util, "_CONFIG", tmp_path / "missing.json")
+    log_util._read_creds.cache_clear()
+
+    called = {"urlopen": 0}
+    def _fake_urlopen(*a, **k):
+        called["urlopen"] += 1
+    monkeypatch.setattr(log_util.urllib.request, "urlopen", _fake_urlopen)
+
+    log_util._post_event_sync("error", "boom", None, {})
+    assert called["urlopen"] == 0
+
+
+def test_local_file_gets_jsonl_line(monkeypatch, tmp_path):
+    """log() writes a JSONL line for warn/error to the local file."""
+    import json
+    log_file = tmp_path / "events.jsonl"
+    monkeypatch.setattr(log_util, "_LOG_FILE", log_file)
+    monkeypatch.setattr(log_util, "_post_event", lambda *a, **k: None)
+
+    log_util.log("error", "boom-on-disk", run="r1")
+
+    assert log_file.exists()
+    lines = log_file.read_text().strip().splitlines()
+    assert len(lines) == 1
+    row = json.loads(lines[0])
+    assert row["event_type"] == "error"
+    assert row["message"]    == "boom-on-disk"
+    assert row["tool"]       == log_util.TOOL
+    assert row["context"]    == {"run": "r1"}
+
+
+def test_local_file_rotates_when_oversize(monkeypatch, tmp_path):
+    """When the file passes _MAX_BYTES, current file rotates to .1 and a fresh file starts."""
+    from pathlib import Path
+    log_file = tmp_path / "events.jsonl"
+    monkeypatch.setattr(log_util, "_LOG_FILE", log_file)
+    monkeypatch.setattr(log_util, "_MAX_BYTES", 200)  # tiny cap so the test rotates quickly
+    monkeypatch.setattr(log_util, "_post_event", lambda *a, **k: None)
+
+    # First write — creates the file
+    log_util.log("error", "first")
+    assert log_file.exists()
+
+    # Fill the file past the cap so the next write triggers rotation
+    log_file.write_text("x" * 300)
+
+    log_util.log("error", "after-rotation")
+
+    rotated = Path(str(log_file) + ".1")
+    assert rotated.exists(), "rotation should produce events.jsonl.1"
+    assert log_file.exists() and log_file.stat().st_size > 0
+    # Newest event lives in the current file, not the rotated one
+    assert "after-rotation" in log_file.read_text()
+
+
+def test_local_file_persists_traceback_on_interceptor(monkeypatch, tmp_path):
+    """Unhandled exception → traceback lands in the local file."""
+    import json
+    log_file = tmp_path / "events.jsonl"
+    monkeypatch.setattr(log_util, "_LOG_FILE", log_file)
+    monkeypatch.setattr(log_util, "_post_event", lambda *a, **k: None)
+
+    def _boom():
+        raise RuntimeError("disk-trace")
+
+    wrapped = log_util.install_error_interceptor(_boom)
+    with pytest.raises(SystemExit):
+        wrapped()
+
+    rows = [json.loads(l) for l in log_file.read_text().splitlines()]
+    assert any(
+        r["event_type"] == "error"
+        and "RuntimeError" in r["message"]
+        and r["traceback"] and "disk-trace" in r["traceback"]
+        for r in rows
+    )

conduct_cli-0.6.0/tests/test_proxy_env.py

@@ -0,0 +1,104 @@
+"""Smoke check for `conduct guard sync` proxy env writer.
+
+Validates:
+  - env file written with 3 provider pairs and member token formatted as guard-mt-<…>
+  - shell rc source line added exactly once across multiple syncs
+  - override flag wins (--proxy-url)
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from unittest import mock
+
+from conduct_cli import guard
+
+
+def _redirect_home(tmp_path: Path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    # The guard module captures Path.home() at import time into module-level
+    # constants. Re-bind them so the redirect actually takes effect.
+    monkeypatch.setattr(guard, "CONDUCT_DIR", tmp_path / ".conduct")
+    monkeypatch.setattr(guard, "PROXY_ENV_FILE", tmp_path / ".conduct" / "env")
+
+
+def test_env_file_written_with_all_three_pairs(tmp_path, monkeypatch):
+    _redirect_home(tmp_path, monkeypatch)
+    monkeypatch.setenv("SHELL", "/bin/zsh")
+
+    rc, sourced = guard._write_proxy_env("abc123", "https://api.conductai.ai/proxy")
+
+    env = (tmp_path / ".conduct" / "env").read_text()
+    assert 'export ANTHROPIC_BASE_URL="https://api.conductai.ai/proxy"' in env
+    assert 'export ANTHROPIC_API_KEY="guard-mt-abc123"' in env
+    assert 'export OPENAI_BASE_URL="https://api.conductai.ai/proxy/openai"' in env
+    assert 'export OPENAI_API_KEY="guard-mt-abc123"' in env
+    assert 'export PERPLEXITY_BASE_URL="https://api.conductai.ai/proxy/perplexity"' in env
+    assert 'export PERPLEXITY_API_KEY="guard-mt-abc123"' in env
+    assert sourced is True
+    assert rc.name == ".zshrc"
+
+
+def test_shell_rc_source_line_added_once_across_multiple_syncs(tmp_path, monkeypatch):
+    _redirect_home(tmp_path, monkeypatch)
+    monkeypatch.setenv("SHELL", "/bin/zsh")
+
+    guard._write_proxy_env("abc", "https://api.conductai.ai/proxy")
+    guard._write_proxy_env("abc", "https://api.conductai.ai/proxy")
+    guard._write_proxy_env("abc", "https://api.conductai.ai/proxy")
+
+    rc_text = (tmp_path / ".zshrc").read_text()
+    assert rc_text.count(guard.SHELL_RC_MARKER) == 1
+    assert rc_text.count(guard.SHELL_SOURCE_LINE) == 1
+
+
+def test_bash_picks_bashrc(tmp_path, monkeypatch):
+    _redirect_home(tmp_path, monkeypatch)
+    monkeypatch.setenv("SHELL", "/usr/bin/bash")
+
+    rc, _ = guard._write_proxy_env("xyz", "https://api.conductai.ai/proxy")
+    assert rc.name == ".bashrc"
+    assert (tmp_path / ".bashrc").exists()
+
+
+def test_missing_token_returns_empty_path(tmp_path, monkeypatch, capsys):
+    _redirect_home(tmp_path, monkeypatch)
+    monkeypatch.setenv("SHELL", "/bin/zsh")
+
+    rc, sourced = guard._write_proxy_env("", "https://api.conductai.ai/proxy")
+    assert rc == Path("")
+    assert sourced is False
+    assert not (tmp_path / ".conduct" / "env").exists()
+    assert "no member token" in capsys.readouterr().out
+
+
+def test_override_url_picked_up(tmp_path, monkeypatch):
+    _redirect_home(tmp_path, monkeypatch)
+    monkeypatch.setenv("SHELL", "/bin/zsh")
+
+    guard._write_proxy_env("abc", "https://my-self-hosted.example.com/proxy")
+    env = (tmp_path / ".conduct" / "env").read_text()
+    assert 'ANTHROPIC_BASE_URL="https://my-self-hosted.example.com/proxy"' in env
+    assert 'OPENAI_BASE_URL="https://my-self-hosted.example.com/proxy/openai"' in env
+
+
+def test_env_file_strips_trailing_slash(tmp_path, monkeypatch):
+    _redirect_home(tmp_path, monkeypatch)
+    monkeypatch.setenv("SHELL", "/bin/zsh")
+
+    guard._write_proxy_env("abc", "https://api.conductai.ai/proxy/")
+    env = (tmp_path / ".conduct" / "env").read_text()
+    assert 'ANTHROPIC_BASE_URL="https://api.conductai.ai/proxy"' in env   # no trailing slash
+    assert 'OPENAI_BASE_URL="https://api.conductai.ai/proxy/openai"' in env
+
+
+def test_unknown_shell_skips_rc_write(tmp_path, monkeypatch, capsys):
+    _redirect_home(tmp_path, monkeypatch)
+    monkeypatch.setenv("SHELL", "/bin/csh")
+
+    rc, sourced = guard._write_proxy_env("abc", "https://x")
+    assert rc == Path("")
+    assert sourced is False
+    # env file IS written even on unknown shell — the user can source manually
+    assert (tmp_path / ".conduct" / "env").exists()
+    assert "Source manually" in capsys.readouterr().out