conduct-cli 0.7.48__tar.gz → 0.8.1__tar.gz

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.7.48
+Version: 0.8.1
 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.7.48 → conduct_cli-0.8.1}/pyproject.toml

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

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/api.py

@@ -22,11 +22,9 @@ def _friendly(code: int, detail: str) -> str:
     return detail
 
 
-def headers(workspace_id: str, token=None, content_type="application/json", api_key=None) -> dict:
+def headers(workspace_id: str, token=None, content_type="application/json") -> dict:
     h = {"Content-Type": content_type, "X-Workspace-Id": workspace_id}
-    if api_key:
-        h["X-Api-Key"] = api_key
-    elif token:
+    if token:
         h["Authorization"] = f"Bearer {token}"
     return h
 

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/guard.py

@@ -276,11 +276,12 @@ _PERSONA_LABELS = {
 }
 
 
-def _ensure_persona(workspace_id: str, api_key: str, base_url: str) -> str:
+def _ensure_persona(workspace_id: str, base_url: str) -> str:
     """Prompt for persona if none is set yet. Saves choice to guard config and API.
 
     Returns the active persona name. Skips prompt silently if already set.
     """
+    agent_token = _default_agent_token() or ""
     cfg = _load_guard_config()
     if cfg.get("persona"):
         return cfg["persona"]
@@ -310,7 +311,7 @@ def _ensure_persona(workspace_id: str, api_key: str, base_url: str) -> str:
             "PATCH",
             f"{base_url}/guard/config/persona",
             body={"persona": chosen},
-            api_key=api_key,
+            token=agent_token or None,
         )
     except Exception:
         pass  # non-fatal — local config still records the choice
@@ -352,7 +353,7 @@ def _require_guard_config() -> dict:
     if not cfg or not ws:
         print(f"{RED}Guard not connected. Run: conduct login{RESET}", file=sys.stderr)
         sys.exit(0)
-    if not cfg.get("agent_token") and not cfg.get("api_key"):
+    if not cfg.get("agent_token"):
         print(f"{RED}Guard config is missing credentials. Run: conduct login{RESET}", file=sys.stderr)
         sys.exit(0)
     return cfg
@@ -522,12 +523,19 @@ def _write_mcp_file(
 
 
 _GUARD_RULES_TEXT = (
+    "## ConductGuard — AI Governance Policy\n\n"
+    "A ConductGuard MCP server is connected to this session (server name: `conduct-guard`).\n"
+    "All Guard policies are enforced through it. You MUST follow these rules:\n\n"
     "Before executing any shell command, file write, network request, API call, or code change:\n"
-    "- Call guard_check (conductguard MCP tool) with the action and parameters.\n"
-    "- If BLOCKED: stop immediately and explain the policy rule to the user.\n"
-    "- If WARNING: proceed but surface the warning. If ALLOWED: proceed normally.\n"
-    "- Never write credentials, API keys, or secrets to files or output.\n"
-    "- Never send PII (emails, names, payment data) to external endpoints."
+    "1. Call the `guard_check` tool from the `conduct-guard` MCP server with the action and parameters.\n"
+    "2. If the response is BLOCKED: stop immediately and explain the policy rule to the user. Do not proceed.\n"
+    "3. If the response is WARNING: proceed but surface the warning message to the user.\n"
+    "4. If the response is ALLOWED: proceed normally.\n\n"
+    "Always-on rules (no guard_check needed, enforce unconditionally):\n"
+    "- Never write credentials, API keys, tokens, or secrets to any file or output.\n"
+    "- Never send PII (emails, names, payment data) to external endpoints.\n\n"
+    "Use `guard_status` (conduct-guard MCP) to show the user their current policy and team info.\n"
+    "Use `guard_activity` at the start of every session with a one-line summary of what you are doing."
 )
 
 
@@ -582,22 +590,10 @@ def _patch_tool_instruction_files(agent_token: str, api_url: str, dry_run: bool
     MARKER_END   = "<!-- /ConductGuard -->"
     GUARD_RULES  = _GUARD_RULES_TEXT
 
-    # Pull team instructions from API (non-fatal)
-    # Only write if admin has explicitly published (version != "v0")
-    team_content = ""
-    try:
-        resp = _req("GET", f"{api_url}/team-os/instructions", token=agent_token)
-        if (resp.get("version") or "v0") != "v0":
-            team_content = (resp.get("content") or "").strip()
-    except Exception:
-        pass
-
-    parts = [MARKER_START, "## ConductGuard Policy"]
-    if team_content:
-        parts.append(team_content)
-    parts.append(GUARD_RULES)
-    parts.append(MARKER_END)
-    guard_block = "\n".join(parts)
+    # Guard-only for now — team-os instructions are hidden pending redesign.
+    # This block just ensures every AI tool knows to invoke Guard via hooks
+    # or the conduct-guard MCP before taking action.
+    guard_block = "\n".join([MARKER_START, "## ConductGuard Policy", GUARD_RULES, MARKER_END])
 
     repo_root: Path | None = None
     for parent in [Path.cwd(), *Path.cwd().parents]:
@@ -751,12 +747,26 @@ def _install_codex_hook(hook_path: Path) -> None:
 
 # ── HTTP helpers (no third-party deps — mirrors api.py style) ─────────────────
 
-def _req(method: str, url: str, body=None, token: str = None, api_key: str = None, timeout: int = 20) -> dict:
+def _default_agent_token() -> str | None:
+    """Read the agent_token minted by `conduct login` from ~/.conduct/config.json.
+    This is the CLI's single canonical credential — every call to the central
+    API should carry it via Authorization: Bearer."""
+    try:
+        cfg_path = Path.home() / ".conduct" / "config.json"
+        if cfg_path.exists():
+            return json.loads(cfg_path.read_text()).get("agent_token") or None
+    except Exception:
+        pass
+    return None
+
+
+def _req(method: str, url: str, body=None, token: str = None, timeout: int = 20) -> dict:
+    # If no explicit token passed, fall back to the login-minted agent_token.
+    if not token:
+        token = _default_agent_token()
     headers = {"Content-Type": "application/json"}
     if token:
         headers["Authorization"] = f"Bearer {token}"
-    if api_key:
-        headers["X-Api-Key"] = api_key
     data = json.dumps(body).encode() if body is not None else None
     r = urllib.request.Request(url, data=data, headers=headers, method=method)
     try:
@@ -892,10 +902,10 @@ def _install_claude_hook(hook_path: Path) -> None:
 
 def cmd_guard_install(args):
     """Called automatically from `conduct login`. Sets up Guard: downloads policies, installs hook + MCP."""
-    api_key = getattr(args, "api_key", None)
-    server  = (getattr(args, "server", None) or "https://api.conductai.ai").rstrip("/")
+    agent_token = getattr(args, "agent_token", None)
+    server      = (getattr(args, "server", None) or "https://api.conductai.ai").rstrip("/")
 
-    # Load workspace_id from ~/.conduct/config.json
+    # Load workspace_id (and fallback agent_token) from ~/.conduct/config.json
     conduct_cfg_path = Path.home() / ".conduct" / "config.json"
     conduct_cfg: dict = {}
     if conduct_cfg_path.exists():
@@ -905,7 +915,9 @@ def cmd_guard_install(args):
             pass
 
     workspace_id = conduct_cfg.get("workspace")
-    if not workspace_id or not api_key:
+    if not agent_token:
+        agent_token = conduct_cfg.get("agent_token")
+    if not workspace_id or not agent_token:
         return  # nothing to do
 
     print(f"  Setting up Guard…")
@@ -913,16 +925,16 @@ def cmd_guard_install(args):
     result = _req(
         "GET",
         f"{server}/guard/config/installed?workspace_id={workspace_id}",
-        api_key=api_key,
+        token=agent_token or None,
     )
 
     if not result.get("installed"):
         print(f"  {GRAY}Guard not installed for this workspace — skipping{RESET}")
         return
 
-    agent_token    = result.get("agent_token") or ""
-    user_email     = result.get("user_email") or ""
-    clerk_user_id  = result.get("clerk_user_id") or ""
+    resp_agent_token = result.get("agent_token") or agent_token
+    user_email       = result.get("user_email") or ""
+    clerk_user_id    = result.get("clerk_user_id") or ""
 
     # Persona selection — prompt once, skip if already chosen
 
@@ -930,10 +942,9 @@ def cmd_guard_install(args):
     import time as _time
     _save_guard_config({
         "workspace_id":          workspace_id,
-        "agent_token":           agent_token,
+        "agent_token":           resp_agent_token,
         "user_email":            user_email,
         "clerk_user_id":         clerk_user_id,
-        "api_key":               api_key,
         "api_url":               server,
         "last_synced_at":        _time.time(),
     })
@@ -1243,24 +1254,20 @@ def _report_tools_to_server() -> None:
         base_url = _api_url(cfg)
         email = cfg.get("user_email", "")
         token = cfg.get("agent_token", "")
-        api_key = cfg.get("api_key", "")
-
         if not email:
             return
-
-        # Also pull conduct API key for X-Api-Key auth (member_token is not accepted by this endpoint)
         conduct_cfg_path = Path.home() / ".conduct" / "config.json"
-        conduct_api_key = ""
+        conduct_agent_token = ""
         if conduct_cfg_path.exists():
             try:
-                conduct_api_key = json.loads(conduct_cfg_path.read_text()).get("api_key", "")
+                conduct_agent_token = json.loads(conduct_cfg_path.read_text()).get("agent_token", "")
             except Exception:
                 pass
 
         payload = json.dumps({"email": email, "tools": tools}).encode()
         headers = {"Content-Type": "application/json"}
-        if conduct_api_key and conduct_api_key.startswith("cond_live_"):
-            headers["X-Api-Key"] = conduct_api_key
+        if conduct_agent_token and conduct_agent_token.startswith("cond_live_"):
+            headers["Authorization"] = f"Bearer {conduct_agent_token}"
         elif token:
             headers["Authorization"] = f"Bearer {token}"
         req = urllib.request.Request(
@@ -1465,14 +1472,6 @@ def cmd_guard_sync(args):
     except Exception as e:
         print(f"  {YELLOW}Warning: could not refresh token ({e}) — using cached value{RESET}")
 
-    # Fetch team instructions version so session-start hook can detect staleness
-    try:
-        ver_resp = _req("GET", f"{base_url}/team-os/instructions/version", token=_token)
-        if ver_resp.get("version"):
-            _save_guard_config({"instructions_version": ver_resp["version"]})
-    except Exception:
-        pass  # non-fatal
-
     # 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; otherwise fetched from server (workspace_config).
@@ -1868,7 +1867,7 @@ def _ensure_booster(root: Path) -> None:
             pass
 
 
-def _report_savings(cfg: dict, base_url: str, api_key: str = "") -> None:
+def _report_savings(cfg: dict, base_url: str, agent_token: str = "") -> None:
     import subprocess
 
     rtk_data = {}
@@ -1929,12 +1928,10 @@ def _report_savings(cfg: dict, base_url: str, api_key: str = "") -> None:
     }
 
     try:
-        agent_token_evt = cfg.get("agent_token", "")
+        agent_token_evt = cfg.get("agent_token", "") or agent_token
         headers = {"Content-Type": "application/json"}
         if agent_token_evt:
             headers["Authorization"] = f"Bearer {agent_token_evt}"
-        elif api_key:
-            headers["X-Api-Key"] = api_key
         data = json.dumps(payload).encode()
         req = urllib.request.Request(
             f"{base_url}/guard/savings",
@@ -1963,13 +1960,13 @@ def cmd_guard_status(args):
     cfg          = _require_guard_config()
     workspace_id = cfg.get("workspace_id")
     user_email   = cfg.get("user_email", "")
-    api_key      = cfg.get("api_key", "")
+    agent_token  = cfg.get("agent_token", "")
     base_url     = _api_url(cfg)
 
     # Auto-refresh user_email + clerk_user_id into config if missing
-    if (not user_email or not cfg.get("clerk_user_id")) and api_key:
+    if (not user_email or not cfg.get("clerk_user_id")) and agent_token:
         try:
-            installed = _req("GET", f"{base_url}/guard/config/installed", api_key=api_key)
+            installed = _req("GET", f"{base_url}/guard/config/installed", token=agent_token or None)
             fetched_email = installed.get("user_email") or ""
             fetched_clerk = installed.get("clerk_user_id") or ""
             if fetched_email:
@@ -1993,7 +1990,7 @@ def cmd_guard_status(args):
         spend = _req(
             "GET",
             f"{base_url}/guard/spend?workspace_id={workspace_id}",
-            api_key=api_key,
+            token=agent_token or None,
         )
     except SystemExit:
         pass
@@ -2013,7 +2010,7 @@ def cmd_guard_status(args):
                 f"&since={today_iso}"
                 f"&limit=20"
             ),
-            api_key=api_key,
+            token=agent_token or None,
         )
         if not isinstance(events, list):
             events = events.get("events", [])
@@ -2094,14 +2091,14 @@ def cmd_guard_status(args):
 def cmd_guard_savings(args):
     cfg          = _require_guard_config()
     workspace_id = cfg.get("workspace_id")
-    api_key      = cfg.get("api_key", "")
+    agent_token  = cfg.get("agent_token", "")
     base_url     = _api_url(cfg)
 
     try:
         data = _req(
             "GET",
             f"{base_url}/guard/savings/team-summary?workspace_id={workspace_id}",
-            api_key=api_key,
+            token=agent_token or None,
         )
     except Exception:
         print(f"{RED}Failed to fetch team savings.{RESET}")
@@ -2112,9 +2109,11 @@ def cmd_guard_savings(args):
 
     dev_count   = data.get("developer_count", 0)
     total_tok   = data.get("total_tokens_saved", 0)
+    total_usd   = data.get("total_cost_saved_usd", 0.0)
     per_day     = data.get("per_day_usd", 0.0)
     per_month   = data.get("per_month_usd", 0.0)
     per_year    = data.get("per_year_usd", 0.0)
+    days_obs    = data.get("days_observed", 1)
     tools       = data.get("tools_installed", [])
     avg_tok     = total_tok // dev_count if dev_count else 0
     avg_day_usd = round(per_day / dev_count, 2) if dev_count else 0.0
@@ -2122,8 +2121,8 @@ def cmd_guard_savings(args):
     print()
     print(f"{BOLD}Team Token Savings{RESET}  ({dev_count} developer{'s' if dev_count != 1 else ''})")
     print("─" * 52)
-    print(f"  Total tokens saved:    {total_tok:>14,}")
-    print(f"  Estimated savings:     ${per_day:>8.2f}/day  ·  ${per_month:,.0f}/month  ·  ${per_year:,.0f}/year")
+    print(f"  Total tokens saved:    {total_tok:>14,}    (${total_usd:,.2f} over {days_obs} day{'s' if days_obs != 1 else ''})")
+    print(f"  Daily rate:            ${per_day:>8.2f}/day  ·  projected ${per_month:,.0f}/month  ·  ${per_year:,.0f}/year")
     if dev_count:
         print(f"  Avg per developer:     {avg_tok:>14,} tokens  ·  ${avg_day_usd:.2f}/day")
     if tools:
@@ -2161,7 +2160,7 @@ def cmd_guard_audit(args):
     cfg          = _require_guard_config()
     workspace_id = cfg.get("workspace_id")
     user_email   = cfg.get("user_email", "")
-    api_key      = cfg.get("api_key", "")
+    agent_token  = cfg.get("agent_token", "")
     base_url     = _api_url(cfg)
 
     since_str = getattr(args, "since", None) or "24h"
@@ -2176,7 +2175,7 @@ def cmd_guard_audit(args):
             f"&since={since_iso}"
             f"&limit=50"
         ),
-        api_key=api_key,
+        token=agent_token or None,
     )
     events = events_resp if isinstance(events_resp, list) else events_resp.get("events", [])
 
@@ -2486,7 +2485,7 @@ def _watch_loop():
             c       = _cfg()
             api_url = _api_url(c)
             token   = c.get("agent_token", "")
-            api_key = c.get("api_key", "")
+            agent_token = c.get("agent_token", "")
             agents = []
             for name, config_path, mcp_key in _discover_config_agents():
                 agents.append({
@@ -2506,7 +2505,7 @@ def _watch_loop():
                 pass
             _req("POST", f"{api_url}/guard/discover/scan",
                  body={"triggered_by": "watch", "agents": agents},
-                 token=token, api_key=api_key)
+                 token=token or agent_token)
         except Exception:
             pass
         time.sleep(_WATCH_INTERVAL)
@@ -2662,7 +2661,6 @@ def cmd_guard_discover(args):
     cfg      = _load_guard_config()
     api_url  = _api_url(cfg)
     token    = cfg.get("agent_token", "")
-    api_key  = cfg.get("api_key", "")
     hdrs     = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
 
     # Config file scan — detect AI tools from known config dirs
@@ -2722,7 +2720,7 @@ def cmd_guard_discover(args):
                 "proxy_routed": t.get("proxy_routed", False),
             })
         payload = {"triggered_by": "cli", "agents": agents_payload}
-        _req("POST", f"{api_url}/guard/discover/scan", body=payload, token=token, api_key=api_key)
+        _req("POST", f"{api_url}/guard/discover/scan", body=payload, token=token)
     except SystemExit:
         pass  # 401/network errors — local output still useful
 
@@ -2936,14 +2934,14 @@ def cmd_verify(args) -> None:
 
     cfg          = _require_guard_config()
     workspace_id = cfg.get("workspace_id")
-    api_key      = cfg.get("api_key", "")
+    agent_token  = cfg.get("agent_token", "")
     base_url     = _api_url(cfg)
 
     # ── fetch evidence from API ───────────────────────────────────────────────
     ev = _req(
         "GET",
         f"{base_url}/guard/verify/evidence?workspace_id={workspace_id}",
-        api_key=api_key,
+        token=agent_token or None,
     )
 
     grade        = ev.get("grade", "F")
@@ -2960,7 +2958,7 @@ def cmd_verify(args) -> None:
         run_result = _req(
             "POST",
             f"{base_url}/guard/verify/run?workspace_id={workspace_id}",
-            api_key=api_key,
+            token=agent_token or None,
         )
         if fmt == "json":
             print(_json.dumps(run_result, indent=2))

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/hooks/base.py

@@ -148,14 +148,14 @@ def _refresh_policy_from_api() -> None:
     try:
         cfg = load_config()
         workspace_id = cfg.get("workspace_id")
-        api_key = cfg.get("api_key", "")
+        agent_token = cfg.get("agent_token", "")
         api_url = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
-        if not api_key:
+        if not agent_token:
             return
         url = f"{api_url}/guard/policies/sync"
         if workspace_id:
             url += f"?workspace_id={workspace_id}"
-        req = urllib.request.Request(url, headers={"X-Api-Key": api_key})
+        req = urllib.request.Request(url, headers={"Authorization": f"Bearer {agent_token}"})
         with urllib.request.urlopen(req, timeout=8) as resp:
             data = resp.read()
         POLICY_PATH.parent.mkdir(parents=True, exist_ok=True)

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/hooks/posttooluse.py

@@ -92,7 +92,7 @@ def _maybe_emit_security_finding(tool_response, session_id, tool_name, tool_inpu
     if not cfg.get("security_emit_enabled", False):
         return
     workspace_id = cfg.get("workspace_id")
-    api_key      = cfg.get("api_key", "")
+    agent_token = cfg.get("agent_token", "")
     api_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
     if not workspace_id:
         return
@@ -138,7 +138,7 @@ def _maybe_emit_security_finding(tool_response, session_id, tool_name, tool_inpu
         "try:\n"
         f"    req = urllib.request.Request(\"{api_url}/security-findings?workspace_id={workspace_id}\","
         f" data={repr(payload.encode())}, headers={{\"Content-Type\": \"application/json\","
-        f" \"X-Api-Key\": \"{api_key}\"}}, method=\"POST\")\n"
+        f" \"Authorization\": \"Bearer {agent_token}\"}}, method=\"POST\")\n"
         "    urllib.request.urlopen(req, timeout=5)\n"
         "except: pass\n"
     )

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/hooks/pretooluse.py

@@ -156,7 +156,7 @@ def _maybe_sync_policy() -> None:
     try:
         cfg = load_config()
         workspace_id = cfg.get("workspace_id") or cfg.get("workspace")
-        api_key      = cfg.get("agent_token") or cfg.get("api_key", "")
+        agent_token  = cfg.get("agent_token", "")
         api_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
         if not workspace_id:
             return
@@ -175,7 +175,7 @@ def _maybe_sync_policy() -> None:
             if time.time() - cache.get("ts", 0) < VERSION_CACHE_TTL:
                 return
         url = f"{api_url}/guard/policies/sync?workspace_id={workspace_id}"
-        req = urllib.request.Request(url, headers={"Authorization": f"Bearer {api_key}"} if api_key else {})
+        req = urllib.request.Request(url, headers={"Authorization": f"Bearer {agent_token}"} if agent_token else {})
         with urllib.request.urlopen(req, timeout=2) as resp:
             remote = json.loads(resp.read())
 

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/hooks/session_report_push.py

@@ -33,7 +33,7 @@ def _load_config() -> dict:
 def run(session_id: str = "") -> None:
     cfg = _load_config()
     server = (cfg.get("api_url") or cfg.get("server") or "https://api.conductai.ai").rstrip("/")
-    api_key = cfg.get("api_key", "")
+    agent_token = cfg.get("agent_token", "")
     member_token = cfg.get("member_token", "")
     workspace_id = cfg.get("workspace_id", "")
 
@@ -115,8 +115,8 @@ def run(session_id: str = "") -> None:
         }
         if member_token:
             headers["Authorization"] = f"Bearer {member_token}"
-        elif api_key:
-            headers["X-API-Key"] = api_key
+        elif agent_token:
+            headers["Authorization"] = f"Bearer {agent_token}"
 
         req = urllib.request.Request(
             f"{server}/guard/session-reports",

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/hooks/session_start.py

@@ -124,7 +124,7 @@ def _backfill_prev_session(current_session_id: str, cwd: str | None) -> None:
             return
         cfg = json.loads(cfg_path.read_text())
         server = cfg.get("server", "").rstrip("/")
-        api_key = cfg.get("api_key", "")
+        agent_token = cfg.get("agent_token", "")
         workspace_id = cfg.get("workspace_id") or cfg.get("workspace", "")
         if not server:
             return
@@ -145,7 +145,7 @@ def _backfill_prev_session(current_session_id: str, cwd: str | None) -> None:
                     data=payload,
                     headers={
                         "Content-Type": "application/json",
-                        "X-API-Key": api_key,
+                        "Authorization": f"Bearer {agent_token}",
                         "X-Workspace-ID": workspace_id,
                     },
                     method="PATCH",

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/hooks/stop.py

@@ -26,7 +26,7 @@ def _post_intent(session_id: str, ai_tool: str, cwd: str | None) -> None:
             return
         cfg = _json.loads(cfg_path.read_text())
         server = cfg.get("server", "").rstrip("/")
-        api_key = cfg.get("api_key", "")
+        agent_token = cfg.get("agent_token", "")
         workspace_id = cfg.get("workspace_id") or cfg.get("workspace", "")
         if not server or not session_id:
             return
@@ -43,7 +43,7 @@ def _post_intent(session_id: str, ai_tool: str, cwd: str | None) -> None:
             data=payload,
             headers={
                 "Content-Type": "application/json",
-                "X-API-Key": api_key,
+                "Authorization": f"Bearer {agent_token}",
                 "X-Workspace-ID": workspace_id,
             },
             method="PATCH",

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/main.py

@@ -109,12 +109,10 @@ def _resolve(args, key: str, config_key=None):
 
 
 def _require_auth(args):
-    """Return (server, workspace_id, api_key, token) — exit if not configured."""
+    """Return (server, workspace_id, token) — exit if not configured."""
     cfg        = _load_config()
     server     = _resolve(args, "server") or cfg.get("api_url", "")
     workspace  = _resolve(args, "workspace") or cfg.get("workspace_id") or cfg.get("workspace")
-    api_key    = _resolve(args, "api_key", "api_key")
-    # agent_token (new) takes precedence over legacy token
     token      = _resolve(args, "token") or cfg.get("agent_token")
 
     if not server:
@@ -123,23 +121,21 @@ def _require_auth(args):
     if not workspace:
         print(f"{RED}No workspace set. Run: conduct login{RESET}")
         sys.exit(1)
-    if not api_key and not token:
+    if not token:
         print(f"{RED}Not authenticated. Run: conduct login{RESET}")
         sys.exit(1)
 
-    return server.rstrip("/"), workspace, api_key, token
+    return server.rstrip("/"), workspace, token
 
 
 # ── Stream helper ─────────────────────────────────────────────────────────────
 
-def _stream_run(server: str, workflow_id: str, run_id: str, workspace_id: str, token=None, api_key=None) -> bool:
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+def _stream_run(server: str, workflow_id: str, run_id: str, workspace_id: str, token=None) -> bool:
+    hdrs = api.headers(workspace_id, token, "application/json")
     # SSE endpoint reads auth from query params (EventSource can't set headers)
     qs_parts = [f"workspace_id={workspace_id}"]
     if token:
         qs_parts.append(f"token={token}")
-    if api_key:
-        qs_parts.append(f"api_key={api_key}")
     url  = f"{server}/workflows/{workflow_id}/runs/{run_id}/stream?{'&'.join(qs_parts)}"
 
     for data in api.stream(url, hdrs):
@@ -348,7 +344,7 @@ def _report_tool_coverage() -> None:
     try:
         cfg = _load_config()
         server  = cfg.get("server", "").rstrip("/")
-        api_key = cfg.get("api_key", "")
+        api_key = cfg.get("agent_token", "")
         token   = cfg.get("token", "")
         email   = cfg.get("email", "")
 
@@ -363,7 +359,7 @@ def _report_tool_coverage() -> None:
         payload = json.dumps({"email": email, "tools": tools}).encode()
         headers = {"Content-Type": "application/json"}
         if api_key and api_key.startswith("cond_live_"):
-            headers["X-Api-Key"] = api_key
+            headers["Authorization"] = f"Bearer {api_key}"
         elif token:
             headers["Authorization"] = f"Bearer {token}"
         req = urllib.request.Request(
@@ -594,8 +590,8 @@ def cmd_login(args):
 
 
 def cmd_agents(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
 
     project_filter = getattr(args, "project", None)
     url = f"{server}/workflows"
@@ -638,8 +634,8 @@ def cmd_agents(args):
 
 
 def cmd_test(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
 
     agent_names    = args.agents
     run_all        = getattr(args, "all", False)
@@ -717,10 +713,10 @@ def cmd_test(args):
             })
         return payload
 
-    _run_tests(server, workspace_id, api_key, token, hdrs, targets, _build_payload, parallel=parallel)
+    _run_tests(server, workspace_id, token, hdrs, targets, _build_payload, parallel=parallel)
 
 
-def _run_tests(server, workspace_id, api_key, token, hdrs, targets, build_payload, *, parallel: bool = False):
+def _run_tests(server, workspace_id, token, hdrs, targets, build_payload, *, parallel: bool = False):
     import threading
 
     if not parallel:
@@ -739,7 +735,7 @@ def _run_tests(server, workspace_id, api_key, token, hdrs, targets, build_payloa
             run_id = run.get("run_id")
             print(f"  {GRAY}run: {run_id}{RESET}")
             try:
-                ok = _stream_run(server, wf_id, run_id, workspace_id, token, api_key)
+                ok = _stream_run(server, wf_id, run_id, workspace_id, token)
             except Exception:
                 ok = _poll_run(server, wf_id, run_id, hdrs)
             results.append((name, ok, run_id))
@@ -824,8 +820,8 @@ def _resolve_environment(server: str, workspace_id: str, hdrs: dict, name: str)
 # ── Environment commands ──────────────────────────────────────────────────────
 
 def cmd_environments(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
     envs = _list_environments(server, workspace_id, hdrs)
 
     if not envs:
@@ -840,8 +836,8 @@ def cmd_environments(args):
 
 
 def cmd_credentials(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
     env = _resolve_environment(server, workspace_id, hdrs, args.environment)
 
     rows = api.req("GET", f"{server}/credentials/env-vars/{env['id']}", hdrs)
@@ -862,8 +858,8 @@ def cmd_credentials(args):
     print()
 
 
-def _do_set_credential(server, workspace_id, api_key, token, env_name, key, value):
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+def _do_set_credential(server, workspace_id, token, env_name, key, value):
+    hdrs = api.headers(workspace_id, token, "application/json")
     env = _resolve_environment(server, workspace_id, hdrs, env_name)
 
     existing = api.req("GET", f"{server}/credentials/env-vars/{env['id']}", hdrs)
@@ -875,8 +871,8 @@ def _do_set_credential(server, workspace_id, api_key, token, env_name, key, valu
     print(f"{GREEN}✓ {key}{RESET} set in environment '{env_name}'  {GRAY}({masked}){RESET}")
 
 
-def _do_delete_credential(server, workspace_id, api_key, token, env_name, key, yes):
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+def _do_delete_credential(server, workspace_id, token, env_name, key, yes):
+    hdrs = api.headers(workspace_id, token, "application/json")
     env = _resolve_environment(server, workspace_id, hdrs, env_name)
 
     existing = api.req("GET", f"{server}/credentials/env-vars/{env['id']}", hdrs)
@@ -898,12 +894,12 @@ def _do_delete_credential(server, workspace_id, api_key, token, env_name, key, y
 
 def cmd_set(args):
     if args.set_command == "credential":
-        server, workspace_id, api_key, token = _require_auth(args)
-        _do_set_credential(server, workspace_id, api_key, token,
+        server, workspace_id, token = _require_auth(args)
+        _do_set_credential(server, workspace_id, token,
                            args.environment, args.key, args.value)
     elif args.set_command == "environment":
-        server, workspace_id, api_key, token = _require_auth(args)
-        hdrs = api.headers(workspace_id, token, "application/json", api_key)
+        server, workspace_id, token = _require_auth(args)
+        hdrs = api.headers(workspace_id, token, "application/json")
 
         workflows = api.req("GET", f"{server}/workflows", hdrs)
         wf = next((w for w in workflows if w["name"].lower() == args.agent.lower()), None)
@@ -936,8 +932,8 @@ def _resolve_project(server: str, workspace_id: str, hdrs: dict, name: str) -> d
 
 
 def cmd_projects(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs     = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs     = api.headers(workspace_id, token, "application/json")
     projects = _list_projects(server, workspace_id, hdrs)
 
     if not projects:
@@ -953,8 +949,8 @@ def cmd_projects(args):
 
 
 def cmd_create(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
     parts = args.create_args
 
     if parts and parts[0] == "environment":
@@ -975,8 +971,8 @@ def cmd_create(args):
 
 
 def cmd_delete(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
     parts = args.delete_args
 
     if parts and parts[0] == "environment":
@@ -999,7 +995,7 @@ def cmd_delete(args):
         if not env_name or not key:
             print(f"{RED}Usage: conduct delete credential --environment <name> --key <KEY>{RESET}")
             sys.exit(1)
-        _do_delete_credential(server, workspace_id, api_key, token, env_name, key, args.yes)
+        _do_delete_credential(server, workspace_id, token, env_name, key, args.yes)
 
     else:
         # conduct delete [project] <name> [--yes] [--purge]
@@ -1035,8 +1031,8 @@ def cmd_delete(args):
 # ── Playbook commands ─────────────────────────────────────────────────────────
 
 def cmd_playbooks(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
     slug = getattr(args, "slug", None)
 
     if slug:
@@ -1080,8 +1076,8 @@ def cmd_playbooks(args):
 # ── Install command ───────────────────────────────────────────────────────────
 
 def cmd_install(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
 
     slug = args.slug
 
@@ -1181,8 +1177,8 @@ def cmd_install(args):
 # ── Reset command ─────────────────────────────────────────────────────────────
 
 def cmd_reset(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
     proj = _resolve_project(server, workspace_id, hdrs, args.name)
     project_id = proj["id"]
 
@@ -1268,8 +1264,8 @@ _FRIENDLY_NAMES = {
 
 
 def cmd_install_all(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
 
     slugs = _ALL_SLUGS
 
@@ -1361,16 +1357,16 @@ def _atomic_write(path: Path, data: dict) -> None:
 def cmd_switch(args):
     cfg = _load_config()
     server  = cfg.get("server", "").rstrip("/")
-    api_key = cfg.get("api_key", "")
+    api_key = cfg.get("agent_token", "")
     token   = cfg.get("token", "")
 
     if not server or (not api_key and not token):
-        print(f"{RED}Not logged in. Run: conduct login --server <url> --api-key <key>{RESET}")
+        print(f"{RED}Not logged in. Run: conduct login{RESET}")
         sys.exit(1)
 
     hdrs = {"Content-Type": "application/json"}
     if api_key:
-        hdrs["X-Api-Key"] = api_key
+        hdrs["Authorization"] = f"Bearer {api_key}"
     elif token:
         hdrs["Authorization"] = f"Bearer {token}"
 
@@ -1433,7 +1429,7 @@ def cmd_switch(args):
         policy = _guard._req(
             "GET",
             f"{server}/guard/policies/sync?workspace_id={new_id}",
-            api_key=api_key,
+            token=token,
         )
         _guard._save_policy(policy)
         rule_count = len(policy.get("rules", []))
@@ -1451,13 +1447,13 @@ def cmd_whoami(args):
 
     workspace_id   = cfg.get("workspace", "")
     server         = cfg.get("server", "—")
-    api_key        = cfg.get("api_key", "")
+    api_key        = cfg.get("agent_token", "")
 
     # Try to resolve workspace name from /projects
     workspace_name = ""
     if workspace_id and server != "—" and api_key:
         try:
-            hdrs = {"Content-Type": "application/json", "X-Api-Key": api_key}
+            hdrs = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
             projects = api.req("GET", f"{server.rstrip('/')}/projects", hdrs)
             match = next((p for p in projects if str(p.get("id", "")) == str(workspace_id)), None)
             if match:
@@ -1804,12 +1800,12 @@ def _render_table(rows: list[dict]) -> str:
 def _fetch_runs(cfg: dict) -> list[dict]:
     """Fetch recent runs from GET /runs."""
     server  = cfg.get("server", "").rstrip("/")
-    api_key = cfg.get("api_key", "")
+    api_key = cfg.get("agent_token", "")
     ws_id   = cfg.get("workspace", "")
     if not all([server, api_key, ws_id]):
         return []
     try:
-        hdrs = {"Content-Type": "application/json", "X-Api-Key": api_key}
+        hdrs = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
         data = api.req("GET", f"{server}/runs?limit=15&workspace_id={ws_id}", hdrs)
         runs = data if isinstance(data, list) else data.get("runs", data.get("items", []))
         return runs[:15]
@@ -1820,12 +1816,12 @@ def _fetch_runs(cfg: dict) -> list[dict]:
 def _fetch_guard_activity(cfg: dict, guard_cfg: dict) -> list[dict]:
     """Fetch recent Guard events grouped by developer."""
     server  = cfg.get("server", "").rstrip("/")
-    api_key = cfg.get("api_key", "")
+    api_key = cfg.get("agent_token", "")
     ws_id   = cfg.get("workspace", "")
     if not all([server, api_key, ws_id]):
         return []
     try:
-        hdrs = {"Content-Type": "application/json", "X-Api-Key": api_key}
+        hdrs = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
         data = api.req("GET", f"{server}/guard/events?workspace_id={ws_id}&limit=200", hdrs)
         events = data if isinstance(data, list) else data.get("events", [])
         # Group by user_email
@@ -2280,8 +2276,8 @@ def cmd_session_report(args):
 
     # ── 5. Push report to Guard dashboard ────────────────────────────────────
     try:
-        server, workspace_id, api_key, token = _require_auth(args)
-        hdrs = api.headers(workspace_id, token, "application/json", api_key)
+        server, workspace_id, token = _require_auth(args)
+        hdrs = api.headers(workspace_id, token, "application/json")
         import getpass as _getpass
         email = getattr(args, "developer", None) or _getpass.getuser()
         payload = _json.dumps({
@@ -2313,8 +2309,8 @@ def cmd_session_report(args):
 
 def cmd_emit_finding(args):
     """POST a security finding to /security-findings."""
-    server, workspace_id, api_key, token = _require_auth(args)
-    hdrs = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    hdrs = api.headers(workspace_id, token, "application/json")
 
     from_stdin = getattr(args, "from_stdin", False)
 
@@ -2408,8 +2404,8 @@ def _prompt_issue_choice(issues: list) -> dict:
 
 
 def cmd_run(args):
-    server, workspace_id, api_key, token = _require_auth(args)
-    json_h = api.headers(workspace_id, token, "application/json", api_key)
+    server, workspace_id, token = _require_auth(args)
+    json_h = api.headers(workspace_id, token, "application/json")
 
     # Fix 1: --input values go into state["inputs"], not top-level state.
     # {{inputs.key}} refs in YAML only resolve when the executor finds state["inputs"].
@@ -2548,7 +2544,7 @@ def cmd_run(args):
         body["__max_turns"] = suggested
     run = api.req("POST", f"{server}/workflows/{workflow_id}/trigger", json_h, body)
     run_id = run.get("run_id") or run.get("id")
-    _stream_run(server, workflow_id, run_id, workspace_id, token, api_key)
+    _stream_run(server, workflow_id, run_id, workspace_id, token)
 
 
 # ── conduct sync / test-guard / test-security ────────────────────────────────
@@ -2630,7 +2626,7 @@ def cmd_test_security(args):
         cfg = {}
 
     workspace_id = cfg.get("workspace_id")
-    api_key      = cfg.get("api_key", "")
+    api_key      = cfg.get("agent_token", "")
     user_email   = cfg.get("user_email", "")
     api_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
 
@@ -2647,7 +2643,7 @@ def cmd_test_security(args):
     try:
         req = urllib.request.Request(
             f"{api_url}/security-findings?workspace_id={workspace_id}&source_run_id=conduct-test-security",
-            headers={"X-Api-Key": api_key},
+            headers={"Authorization": f"Bearer {api_key}"},
             method="DELETE",
         )
         with urllib.request.urlopen(req, timeout=8) as resp:
@@ -2678,7 +2674,7 @@ def cmd_test_security(args):
             req = urllib.request.Request(
                 f"{api_url}/security-findings?workspace_id={workspace_id}",
                 data=payload,
-                headers={"Content-Type": "application/json", "X-Api-Key": api_key},
+                headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"},
                 method="POST",
             )
             with urllib.request.urlopen(req, timeout=8) as resp:
@@ -2707,7 +2703,7 @@ def cmd_test_security_verify(args):
         cfg = {}
 
     workspace_id = cfg.get("workspace_id")
-    api_key      = cfg.get("api_key", "")
+    api_key      = cfg.get("agent_token", "")
     user_email   = cfg.get("user_email", "")
     api_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
 
@@ -2727,7 +2723,7 @@ def cmd_test_security_verify(args):
         req = urllib.request.Request(
             f"{api_url}/secure/refresh-automation?workspace_id={workspace_id}",
             data=b"{}",
-            headers={"Content-Type": "application/json", "X-Api-Key": api_key},
+            headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"},
             method="POST",
         )
         with urllib.request.urlopen(req, timeout=15) as resp:
@@ -2743,7 +2739,7 @@ def cmd_test_security_verify(args):
     try:
         req = urllib.request.Request(
             f"{api_url}/security-findings?workspace_id={workspace_id}&source_run_id=conduct-test-security",
-            headers={"X-Api-Key": api_key},
+            headers={"Authorization": f"Bearer {api_key}"},
             method="DELETE",
         )
         with urllib.request.urlopen(req, timeout=8) as resp:
@@ -2773,7 +2769,7 @@ def cmd_test_security_verify(args):
             req = urllib.request.Request(
                 f"{api_url}/security-findings?workspace_id={workspace_id}",
                 data=payload,
-                headers={"Content-Type": "application/json", "X-Api-Key": api_key},
+                headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"},
                 method="POST",
             )
             with urllib.request.urlopen(req, timeout=8) as resp:
@@ -2799,7 +2795,7 @@ def cmd_test_security_verify(args):
         try:
             req = urllib.request.Request(
                 f"{api_url}/security-findings?workspace_id={workspace_id}&source_run_id=conduct-test-security&limit=100",
-                headers={"X-Api-Key": api_key},
+                headers={"Authorization": f"Bearer {api_key}"},
             )
             with urllib.request.urlopen(req, timeout=10) as resp:
                 findings = _json.loads(resp.read())
@@ -2890,7 +2886,7 @@ def cmd_test_guard(args):
         sys.exit(0)
 
     workspace_id = cfg.get("workspace_id")
-    api_key      = cfg.get("api_key", "")
+    api_key      = cfg.get("agent_token", "")
     api_url      = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
 
     print(f"\n{BOLD}▶ conduct test-guard — {len(rules)} rule(s){RESET}\n")
@@ -2934,7 +2930,7 @@ def cmd_test_guard(args):
                 req = urllib.request.Request(
                     f"{api_url}/guard/events/test?workspace_id={workspace_id}",
                     data=payload,
-                    headers={"Content-Type": "application/json", "X-Api-Key": api_key},
+                    headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"},
                     method="POST",
                 )
                 with urllib.request.urlopen(req, timeout=5):
@@ -3009,12 +3005,10 @@ def _check_guard_setup(command: str) -> None:
 def cmd_skill(args):
     """conduct skill list | install <slug> | uninstall <slug>"""
     skill_command = getattr(args, "skill_command", None)
-    server, workspace, api_key, token = _require_auth(args)
+    server, workspace, token = _require_auth(args)
 
     headers = {"Content-Type": "application/json"}
-    if api_key:
-        headers["X-Api-Key"] = api_key
-    elif token:
+    if token:
         headers["Authorization"] = f"Bearer {token}"
 
     def _req(method, path, expect=None):
@@ -3086,7 +3080,6 @@ def main():
     )
     # Global overrides (optional — config file is preferred)
     parser.add_argument("--server",    help="API URL (default: from ~/.conduct/config.json)")
-    parser.add_argument("--api-key",   dest="api_key", help="CLI API key")
     parser.add_argument("--token",     help=argparse.SUPPRESS)
     parser.add_argument("--workspace", help="Workspace ID")
 

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/mcp_server.py

@@ -294,7 +294,7 @@ def main() -> None:
     cfg          = _load_conduct_config()
     server       = cfg.get("server", "").rstrip("/")
     workspace_id = cfg.get("workspace", "")
-    api_key      = cfg.get("api_key")
+    api_key      = cfg.get("agent_token")
     token        = cfg.get("token")
 
     for raw in sys.stdin:

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli/memory.py

@@ -45,7 +45,7 @@ def post_session_to_api(session_id: str, transcript_path: str | None, repo: str
     if not cfg:
         return False
     server = cfg.get("server", "").rstrip("/")
-    api_key = cfg.get("api_key", "")
+    api_key = cfg.get("agent_token", "")
     workspace_id = cfg.get("workspace_id") or cfg.get("workspace", "")
     if not server or not workspace_id:
         return False
@@ -96,7 +96,7 @@ def post_session_to_api(session_id: str, transcript_path: str | None, repo: str
                 data=payload,
                 headers={
                     "Content-Type": "application/json",
-                    "X-API-Key": api_key,
+                    "Authorization": f"Bearer {api_key}",
                     "X-Workspace-ID": workspace_id,
                 },
                 method="POST",
@@ -116,7 +116,7 @@ def search_team_memory(query: str, repo: str | None = None, limit: int = 5) -> l
     if not cfg:
         return []
     server = cfg.get("server", "").rstrip("/")
-    api_key = cfg.get("api_key", "")
+    api_key = cfg.get("agent_token", "")
     workspace_id = cfg.get("workspace_id") or cfg.get("workspace", "")
     if not server or not workspace_id:
         return []
@@ -130,7 +130,7 @@ def search_team_memory(query: str, repo: str | None = None, limit: int = 5) -> l
         req = urllib.request.Request(
             url,
             headers={
-                "X-API-Key": api_key,
+                "Authorization": f"Bearer {api_key}",
                 "X-Workspace-ID": workspace_id,
             },
         )

{conduct_cli-0.7.48 → conduct_cli-0.8.1}/src/conduct_cli.egg-info/PKG-INFO

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