conduct-cli 0.9.2__tar.gz → 0.9.4__tar.gz

{conduct_cli-0.9.2 → conduct_cli-0.9.4}/PKG-INFO

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

{conduct_cli-0.9.2 → conduct_cli-0.9.4}/pyproject.toml

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

{conduct_cli-0.9.2 → conduct_cli-0.9.4}/src/conduct_cli/guard.py

@@ -353,10 +353,10 @@ def _require_guard_config() -> dict:
     ws = cfg.get("workspace_id") or cfg.get("workspace")
     if not cfg or not ws:
         print(f"{RED}Guard not connected. Run: conduct login{RESET}", file=sys.stderr)
-        sys.exit(0)
+        sys.exit(1)
     if not cfg.get("agent_token"):
         print(f"{RED}Guard config is missing credentials. Run: conduct login{RESET}", file=sys.stderr)
-        sys.exit(0)
+        sys.exit(1)
     return cfg
 
 
@@ -2374,6 +2374,21 @@ def register_guard_parser(sub):
     session_sub.add_parser("stop", help="End the current goal session")
     p_session.set_defaults(func=cmd_guard_session)
 
+    # conduct guard approvals list|approve|reject — HITL decide from CLI (#1140)
+    approv_p = guard_sub.add_parser("approvals", help="List and decide Guard HITL approval requests")
+    approv_sub = approv_p.add_subparsers(dest="approvals_command")
+    list_p = approv_sub.add_parser("list", help="List approval requests")
+    list_p.add_argument("--status", default="pending",
+                        choices=["pending", "approved", "rejected", "timed_out", "all"],
+                        help="Filter by status (default: pending)")
+    list_p.add_argument("--limit", type=int, default=50, help="Max rows (default: 50)")
+    approve_p = approv_sub.add_parser("approve", help="Approve a pending request by id")
+    approve_p.add_argument("request_id", help="Approval request UUID")
+    approve_p.add_argument("--reason", default=None, help="Optional decision reason")
+    reject_p = approv_sub.add_parser("reject", help="Reject a pending request by id")
+    reject_p.add_argument("request_id", help="Approval request UUID")
+    reject_p.add_argument("--reason", default=None, help="Optional decision reason")
+
     return guard_p, guard_sub
 
 
@@ -3178,6 +3193,60 @@ def cmd_guard_simulate(args):
         print("[simulation] identity   : (none — token did not resolve to an AgentIdentity)")
 
 
+def cmd_guard_approvals(args, guard_p):
+    """List and decide Guard HITL approval requests (#1140)."""
+    sub = getattr(args, "approvals_command", None)
+    if sub not in ("list", "approve", "reject"):
+        guard_p.print_help()
+        sys.exit(1)
+
+    cfg          = _require_guard_config()
+    workspace_id = cfg.get("workspace_id")
+    agent_token  = cfg.get("agent_token", "")
+    base_url     = _api_url(cfg)
+
+    if sub == "list":
+        url = f"{base_url}/guard/approvals?workspace_id={workspace_id}&status={args.status}&limit={args.limit}"
+        resp = _req("GET", url, token=agent_token or None)
+        items = resp.get("items", []) if isinstance(resp, dict) else []
+        if not items:
+            print(f"{GRAY}No approvals with status={args.status}.{RESET}")
+            return
+        id_w, req_w, rule_w, msg_w = 38, 26, 24, 40
+        print()
+        print(f"{BOLD}{'ID':<{id_w}} {'Requester':<{req_w}} {'Rule':<{rule_w}} {'Message':<{msg_w}} Status{RESET}")
+        print("─" * (id_w + req_w + rule_w + msg_w + 12))
+        colors = {"pending": YELLOW, "approved": GREEN, "rejected": RED, "timed_out": GRAY}
+        for it in items:
+            st = it.get("status", "?")
+            print(
+                f"{it.get('id',''):<{id_w}} "
+                f"{(it.get('requester_email') or '—')[:req_w-1]:<{req_w}} "
+                f"{(it.get('rule_id') or '—')[:rule_w-1]:<{rule_w}} "
+                f"{(it.get('rule_message') or '—')[:msg_w-1]:<{msg_w}} "
+                f"{colors.get(st, '')}{st}{RESET}"
+            )
+        return
+
+    # approve / reject share a body shape
+    decision = "approved" if sub == "approve" else "rejected"
+    body = {"decision": decision}
+    if args.reason:
+        body["reason"] = args.reason
+    url = f"{base_url}/guard/approvals/{args.request_id}/decide?workspace_id={workspace_id}"
+    resp = _req("POST", url, body=body, token=agent_token or None)
+    req = resp.get("request") if isinstance(resp, dict) else None
+    if not req:
+        print(f"{RED}Decision failed — no response body.{RESET}")
+        sys.exit(1)
+    color = GREEN if decision == "approved" else RED
+    print(f"{color}{decision.upper()}{RESET} — {req.get('rule_id','')}  "
+          f"by {req.get('decided_by_email','?')}  "
+          f"latency={req.get('latency_ms','?')}ms  "
+          f"run_resumed={resp.get('run_resumed')}")
+
+
+
 def dispatch_guard(args, guard_p):
     """Dispatch to the correct guard handler. Called from main()."""
     guard_command = getattr(args, "guard_command", None)
@@ -3205,6 +3274,8 @@ def dispatch_guard(args, guard_p):
         cmd_guard_session(args)
     elif guard_command == "simulate":
         cmd_guard_simulate(args)
+    elif guard_command == "approvals":
+        cmd_guard_approvals(args, guard_p)
     else:
         guard_p.print_help()
         sys.exit(1)

{conduct_cli-0.9.2 → conduct_cli-0.9.4}/src/conduct_cli/hooks/pretooluse.py

@@ -670,6 +670,80 @@ def _record_session_warn(session_id: str, rule_id: str) -> None:
 
 # ── Hook entrypoint ───────────────────────────────────────────────────────────
 
+
+def _guard_approval_request(
+    tool_name: str,
+    tool_input: dict,
+    rule_id: str,
+    message: str,
+    session_id: str | None,
+) -> str:
+    """Create a Guard approval request and long-poll for a decision.
+
+    Returns one of: "approved" | "rejected" | "timed_out" | "unavailable".
+    Fail-open on unavailable — the caller decides whether to allow (fail_open)
+    or block (fail_closed) based on Guard's configured fail mode."""
+    try:
+        cfg = load_config()
+        workspace_id = cfg.get("workspace_id") or cfg.get("workspace")
+        agent_token  = cfg.get("agent_token", "")
+        api_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
+        if not workspace_id or not agent_token:
+            return "unavailable"
+
+        body = json.dumps({
+            "rule_id":       rule_id or "unknown",
+            "rule_message":  message,
+            "tool_name":     tool_name,
+            "tool_input":    tool_input,
+            "surface":       "claude_code_hook",
+            "session_id":    session_id,
+        }).encode()
+        create_req = urllib.request.Request(
+            f"{api_url}/guard/approvals?workspace_id={workspace_id}",
+            data=body,
+            method="POST",
+            headers={
+                "Authorization": f"Bearer {agent_token}",
+                "Content-Type":  "application/json",
+                "X-Workspace-ID": workspace_id,
+            },
+        )
+        with urllib.request.urlopen(create_req, timeout=8) as resp:
+            created = json.loads(resp.read())
+        request_id = created.get("id")
+        url = created.get("url") or ""
+        if not request_id:
+            return "unavailable"
+
+        print(
+            f"[ConductGuard] PENDING approval - {message}\n"
+            f"  rule: {rule_id}\n"
+            f"  decide: {url}\n"
+            f"  waiting up to 5min for a decision...",
+            file=sys.stderr,
+        )
+
+        deadline = time.time() + 300
+        poll_url = f"{api_url}/guard/approvals/{request_id}?workspace_id={workspace_id}"
+        headers = {"Authorization": f"Bearer {agent_token}", "X-Workspace-ID": workspace_id}
+        while time.time() < deadline:
+            time.sleep(3.0)
+            try:
+                poll_req = urllib.request.Request(poll_url, headers=headers)
+                with urllib.request.urlopen(poll_req, timeout=5) as resp:
+                    row = json.loads(resp.read())
+                st = row.get("status", "pending")
+                if st in ("approved", "rejected", "timed_out"):
+                    return st
+            except Exception:
+                continue
+        return "timed_out"
+    except Exception as exc:
+        print(f"[ConductGuard] approval request failed: {exc}", file=sys.stderr)
+        return "unavailable"
+
+
 def main() -> None:
     try:
         data = json.load(sys.stdin)
@@ -735,7 +809,30 @@ def main() -> None:
         post_event(tool_name, tool_input, "audited", rule_id, f"[advisory] {message}", session_id, drain_via=_this_file)
         sys.exit(0)
 
-    decision = {"block": "blocked", "warn": "warned", "approval": "blocked"}.get(action, "allowed")
+    if action == "approval":
+        outcome = _guard_approval_request(tool_name, tool_input, rule_id, message, session_id)
+        if outcome == "approved":
+            post_event(tool_name, tool_input, "allowed", rule_id, f"[approval:approved] {message}", session_id, drain_via=_this_file)
+            print("[ConductGuard] approval granted - proceeding.", file=sys.stderr)
+            sys.exit(0)
+        if outcome == "rejected":
+            post_event(tool_name, tool_input, "blocked", rule_id, f"[approval:rejected] {message}", session_id, drain_via=_this_file)
+            print("[ConductGuard] approval rejected - tool call blocked.", file=sys.stderr)
+            sys.exit(2)
+        if outcome == "timed_out":
+            post_event(tool_name, tool_input, "blocked", rule_id, f"[approval:timed_out] {message}", session_id, drain_via=_this_file)
+            print("[ConductGuard] approval timed out - tool call blocked.", file=sys.stderr)
+            sys.exit(2)
+        # unavailable - respect Guard's fail mode. Default fail-closed.
+        fail_mode = _get_fail_mode()
+        post_event(tool_name, tool_input, "blocked", rule_id, f"[approval:unavailable/{fail_mode}] {message}", session_id, drain_via=_this_file)
+        if fail_mode == "fail_open":
+            print("[ConductGuard] approval service unavailable - fail-open allows.", file=sys.stderr)
+            sys.exit(0)
+        print("[ConductGuard] approval service unavailable - fail-closed blocks.", file=sys.stderr)
+        sys.exit(2)
+
+    decision = {"block": "blocked", "warn": "warned"}.get(action, "allowed")
     if action == "warn" and session_id and rule_id and _already_warned_this_session(session_id, rule_id):
         sys.exit(0)
     if action == "warn" and session_id and rule_id:
@@ -747,7 +844,7 @@ def main() -> None:
         print(msg)
         print(msg, file=sys.stderr)
         sys.exit(2)
-    if action in ("warn", "approval"):
+    if action == "warn":
         print(f"[ConductGuard] {message}")
 
     sys.exit(0)

{conduct_cli-0.9.2 → conduct_cli-0.9.4}/src/conduct_cli.egg-info/PKG-INFO

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

{conduct_cli-0.9.2 → conduct_cli-0.9.4}/src/conduct_cli.egg-info/SOURCES.txt

@@ -35,7 +35,9 @@ tests/test_blast_radius.py
 tests/test_cli_matrix.py
 tests/test_cmd_run.py
 tests/test_command_word_matcher.py
+tests/test_conductguard_mcp_stdio.py
 tests/test_drain_daemon_health.py
+tests/test_guard_approvals.py
 tests/test_guard_policy.py
 tests/test_guard_savings.py
 tests/test_hook_dispatch.py

{conduct_cli-0.9.2 → conduct_cli-0.9.4}/tests/test_cli_matrix.py

@@ -30,11 +30,24 @@ CONDUCT = shutil.which("conduct") or "conduct"
 # Commands that intentionally do NOT touch the API (local ops only).
 # Kept small on purpose — add sparingly, with a comment.
 OFFLINE_ONLY: set[tuple[str, ...]] = {
-    ("login",),               # opens browser, no direct API from CLI process
-    ("mcp", "install"),       # writes local Claude/Codex config
-    ("session-report",),      # scans local files
-    ("test-guard",),          # local synthetic events
-    ("test-security",),       # local synthetic findings
+    ("login",),                    # opens browser, no direct API from CLI process
+    ("mcp", "install"),            # writes local Claude/Codex config
+    ("session-report",),           # scans local files
+    ("test-guard",),               # local synthetic events
+    ("test-security",),            # local synthetic findings
+    ("sessions",),                 # reads local Claude Code session directory
+    ("whoami",),                   # status query — prints config state, no API call when unauth'd
+    ("guard", "audit"),            # reads local ~/.conduct/audit.log
+    ("guard", "booster-status"),   # checks local booster install
+    ("guard", "discover"),         # scans local system for AI tools
+    ("guard", "install"),          # writes local hook + policy files
+    ("guard", "lint"),             # lints local policy YAML
+    ("guard", "savings"),          # reads local telemetry file
+    ("guard", "session", "start"), # local session state file
+    ("guard", "session", "stop"),  # local session state file
+    ("guard", "skip-setup"),       # writes local "skip" flag
+    ("guard", "status"),           # reads local guard config
+    ("guard", "watch"),            # local daemon
 }
 
 # Match `{a,b,c}` in the argparse "positional arguments:" section only.

conduct_cli-0.9.4/tests/test_conductguard_mcp_stdio.py

@@ -0,0 +1,68 @@
+"""conductguard-mcp stdio smoke test — runs in cli-matrix on every OS x Python combo.
+
+Spawns the installed `conductguard-mcp` binary, sends `initialize` + `tools/list`
+over stdin, asserts the responses parse and expose the standard tool set. The
+CLI matrix would catch packaging regressions, stdio-loop crashes, or a broken
+initialize handshake that would otherwise only surface in Claude Desktop.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+pytestmark = pytest.mark.skipif(
+    shutil.which("conductguard-mcp") is None,
+    reason="conductguard-mcp not on PATH (install the package first)",
+)
+
+
+def _run(messages, timeout=8):
+    """Feed newline-delimited JSON-RPC messages, collect newline-delimited responses."""
+    payload = "\n".join(json.dumps(m) for m in messages) + "\n"
+    proc = subprocess.run(
+        ["conductguard-mcp", "--workspace", "00000000-0000-0000-0000-000000000000",
+         "--token", "dummy-for-stdio-smoke"],
+        input=payload,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+    lines = [ln for ln in proc.stdout.splitlines() if ln.strip()]
+    return proc, [json.loads(ln) for ln in lines]
+
+
+def test_initialize_returns_protocol_and_capabilities():
+    proc, replies = _run([
+        {"jsonrpc": "2.0", "id": 1, "method": "initialize",
+         "params": {"protocolVersion": "2024-11-05", "clientInfo": {"name": "cli-matrix"}}},
+    ])
+    assert proc.returncode == 0, "conductguard-mcp exited " + str(proc.returncode) + ": " + proc.stderr[-400:]
+    assert len(replies) == 1
+    result = replies[0]["result"]
+    assert "protocolVersion" in result
+    assert "capabilities" in result and "tools" in result["capabilities"]
+
+
+def test_tools_list_exposes_guard_tools():
+    proc, replies = _run([
+        {"jsonrpc": "2.0", "id": 1, "method": "initialize",
+         "params": {"protocolVersion": "2024-11-05", "clientInfo": {"name": "cli-matrix"}}},
+        {"jsonrpc": "2.0", "method": "notifications/initialized", "params": {}},
+        {"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}},
+    ])
+    assert proc.returncode == 0
+    tool_lists = [r for r in replies if isinstance(r, dict) and r.get("id") == 2]
+    assert tool_lists, "no tools/list response found in: " + str(replies)
+    tools = tool_lists[0]["result"]["tools"]
+    names = {t["name"] for t in tools}
+    assert {"guard_check", "guard_activity"}.issubset(names), (
+        "expected the standard guard tool set, got: " + str(sorted(names))
+    )
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__, "-v"]))

conduct_cli-0.9.4/tests/test_guard_approvals.py

@@ -0,0 +1,117 @@
+"""Tests for `conduct guard approvals list|approve|reject` CLI (#1140).
+
+Mocks _req + _require_guard_config so no network. Verifies URL/body shape
+for decide, output for list (populated + empty), and dispatcher routing.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+HERE = Path(__file__).resolve()
+CLI_PKG = HERE.parent.parent / "src"
+if str(CLI_PKG) not in sys.path:
+    sys.path.insert(0, str(CLI_PKG))
+
+_FAKE_CFG = {
+    "workspace_id": "ws-abc-123",
+    "agent_token":  "cond_agt_test",
+    "api_url":      "https://api.example.com",
+}
+
+
+@pytest.fixture(autouse=True)
+def patch_config(monkeypatch):
+    import conduct_cli.guard as g
+    monkeypatch.setattr(g, "_require_guard_config", lambda: _FAKE_CFG)
+    monkeypatch.setattr(g, "_api_url", lambda cfg: cfg["api_url"])
+
+
+def _parse(*argv):
+    import conduct_cli.guard as g
+    p = argparse.ArgumentParser()
+    s = p.add_subparsers(dest="command")
+    guard_p, _ = g.register_guard_parser(s)
+    return p.parse_args(list(argv)), guard_p
+
+
+def test_parser_routes_list_approve_reject():
+    args, _ = _parse("guard", "approvals", "list", "--status", "approved", "--limit", "5")
+    assert args.approvals_command == "list"
+    assert args.status == "approved" and args.limit == 5
+
+    args, _ = _parse("guard", "approvals", "approve", "req-1", "--reason", "ok")
+    assert args.approvals_command == "approve" and args.request_id == "req-1" and args.reason == "ok"
+
+    args, _ = _parse("guard", "approvals", "reject", "req-2")
+    assert args.approvals_command == "reject" and args.reason is None
+
+
+def test_list_renders_rows(capsys):
+    import conduct_cli.guard as g
+    resp = {"items": [
+        {"id":"req-1","requester_email":"a@x.io","rule_id":"r.one","rule_message":"m1","status":"pending"},
+        {"id":"req-2","requester_email":"b@x.io","rule_id":"r.two","rule_message":"m2","status":"approved"},
+    ]}
+    args, guard_p = _parse("guard", "approvals", "list")
+    with patch.object(g, "_req", return_value=resp) as mock:
+        g.dispatch_guard(args, guard_p)
+    call_url = mock.call_args.args[1]
+    assert "/guard/approvals" in call_url and "status=pending" in call_url and "workspace_id=ws-abc-123" in call_url
+    out = capsys.readouterr().out
+    assert "req-1" in out and "req-2" in out
+    assert "pending" in out and "approved" in out
+
+
+def test_list_empty_state(capsys):
+    import conduct_cli.guard as g
+    args, guard_p = _parse("guard", "approvals", "list", "--status", "all")
+    with patch.object(g, "_req", return_value={"items": []}):
+        g.dispatch_guard(args, guard_p)
+    out = capsys.readouterr().out
+    assert "No approvals" in out
+
+
+def test_approve_sends_correct_body_and_url(capsys):
+    import conduct_cli.guard as g
+    decision_resp = {
+        "request": {"rule_id":"r.x","decided_by_email":"me@x.io","latency_ms":42,"status":"approved"},
+        "run_resumed": True,
+    }
+    args, guard_p = _parse("guard", "approvals", "approve", "req-9", "--reason", "looks ok")
+    with patch.object(g, "_req", return_value=decision_resp) as mock:
+        g.dispatch_guard(args, guard_p)
+    method, url = mock.call_args.args[0], mock.call_args.args[1]
+    body = mock.call_args.kwargs["body"]
+    assert method == "POST"
+    assert "/guard/approvals/req-9/decide" in url and "workspace_id=ws-abc-123" in url
+    assert body == {"decision": "approved", "reason": "looks ok"}
+    out = capsys.readouterr().out
+    assert "APPROVED" in out and "run_resumed=True" in out and "42ms" in out
+
+
+def test_reject_without_reason_omits_field(capsys):
+    import conduct_cli.guard as g
+    decision_resp = {
+        "request": {"rule_id":"r.x","decided_by_email":"me@x.io","latency_ms":10,"status":"rejected"},
+        "run_resumed": False,
+    }
+    args, guard_p = _parse("guard", "approvals", "reject", "req-9")
+    with patch.object(g, "_req", return_value=decision_resp) as mock:
+        g.dispatch_guard(args, guard_p)
+    body = mock.call_args.kwargs["body"]
+    assert body == {"decision": "rejected"}  # no reason key when None
+    out = capsys.readouterr().out
+    assert "REJECTED" in out
+
+
+def test_bare_approvals_prints_help(capsys):
+    import conduct_cli.guard as g
+    args, guard_p = _parse("guard", "approvals")
+    with pytest.raises(SystemExit) as excinfo:
+        g.dispatch_guard(args, guard_p)
+    assert excinfo.value.code == 1