conduct-cli 0.5.7__tar.gz → 0.5.9__tar.gz

{conduct_cli-0.5.7 → conduct_cli-0.5.9}/PKG-INFO

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

{conduct_cli-0.5.7 → conduct_cli-0.5.9}/pyproject.toml

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

{conduct_cli-0.5.7 → conduct_cli-0.5.9}/src/conduct_cli/guard.py

@@ -572,8 +572,13 @@ def cmd_guard_install(args):
             api_key=api_key,
         )
         _save_policy(policy)
+        # Mirror fail_mode into guard config so the hook can enforce it
+        # even when POLICY_PATH is missing or unreadable.
+        cfg = _load_guard_config()
+        cfg["fail_mode"] = policy.get("fail_mode", "fail_open")
+        _save_guard_config(cfg)
         rule_count = len(policy.get("rules", []))
-        print(f"  {GREEN}Guard policies:{RESET} {rule_count} rule(s) active")
+        print(f"  {GREEN}Guard policies:{RESET} {rule_count} rule(s) active · fail mode: {cfg['fail_mode']}")
     except SystemExit:
         rule_count = 0
 

{conduct_cli-0.5.7 → conduct_cli-0.5.9}/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.5.7 → conduct_cli-0.5.9}/src/conduct_cli/hook_template.py

@@ -86,7 +86,17 @@ def _maybe_sync_policy():
             POLICY_PATH.write_text(json.dumps(remote, indent=2))
         VERSION_CACHE_PATH.write_text(json.dumps({"ts": time.time(), "version": remote_version}))
     except Exception:
-        pass  # Never block a tool call due to sync failure
+        pass  # sync failure does not directly block; policy file may still be present
+
+
+def _get_fail_mode():
+    """Read fail_mode from ~/.conduct/config.json. Default: fail_open."""
+    try:
+        cfg = json.loads(CONFIG_PATH.read_text()) if CONFIG_PATH.exists() else {}
+    except Exception:
+        return "fail_open"
+    mode = cfg.get("fail_mode", "fail_open")
+    return mode if mode in ("fail_open", "fail_closed") else "fail_open"
 
 
 def _load_budget_cache():
@@ -685,10 +695,35 @@ def main():
     # Policy version check (cached 60s) — auto-syncs if server version differs
     _maybe_sync_policy()
 
+    # Fail-closed gate: if the local policy file is missing and the workspace
+    # is configured for fail_closed, block every tool call with a clear
+    # message. fail_open (default) silently allows.
+    if _get_fail_mode() == "fail_closed" and not POLICY_PATH.exists():
+        tool_name  = (data.get("tool_name") or "").lower()
+        tool_input = data.get("tool_input") or {}
+        session_id = data.get("session_id")
+        msg = "[ConductGuard] Policy cache unavailable — fail-closed mode is on. Run `conduct guard sync` or contact your admin."
+        print(msg)
+        print(msg, file=sys.stderr)
+        _post_event(tool_name, tool_input, "blocked", "guard-unavailable", msg, session_id=session_id)
+        sys.exit(2)
+
     # Hard budget cap (cached 5 min)
     hard_blocked, reason = _load_budget_cache()
     if hard_blocked is None:
         hard_blocked, reason = _fetch_budget_status()
+        # Fail-closed: if the budget check returned default (None reason) AND
+        # we just hit the API for a fresh value, the API was unreachable.
+        # Treat as unavailable and block.
+        if not hard_blocked and reason is None and _get_fail_mode() == "fail_closed":
+            tool_name  = (data.get("tool_name") or "").lower()
+            tool_input = data.get("tool_input") or {}
+            session_id = data.get("session_id")
+            msg = "[ConductGuard] Spend budget check unavailable — fail-closed mode is on."
+            print(msg)
+            print(msg, file=sys.stderr)
+            _post_event(tool_name, tool_input, "blocked", "guard-unavailable", msg, session_id=session_id)
+            sys.exit(2)
     if hard_blocked:
         msg = f"[ConductGuard] {reason or 'Budget hard cap reached. Contact your manager.'}"
         print(msg)

conduct_cli-0.5.9/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.7 → conduct_cli-0.5.9}/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.7 → conduct_cli-0.5.9}/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.7 → conduct_cli-0.5.9}/src/conduct_cli.egg-info/PKG-INFO

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

{conduct_cli-0.5.7 → conduct_cli-0.5.9}/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
@@ -23,4 +24,5 @@ tests/test_bash_operator_signature.py
 tests/test_guard_policy.py
 tests/test_guard_savings.py
 tests/test_hook_syntax.py
+tests/test_log_util.py
 tests/test_switch.py

conduct_cli-0.5.9/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
+    )