conduct-cli 0.14.6__tar.gz → 0.14.8__tar.gz

{conduct_cli-0.14.6 → conduct_cli-0.14.8}/PKG-INFO

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

{conduct_cli-0.14.6 → conduct_cli-0.14.8}/pyproject.toml

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

{conduct_cli-0.14.6 → conduct_cli-0.14.8}/src/conduct_cli/guard.py

@@ -1550,26 +1550,23 @@ def cmd_guard_sync(args):
     _save_policy(policy)
     print(f"  {GREEN}Policy refreshed:{RESET} {rule_count} hook rule(s). Proxy and non-hook rules run server-side.")
 
-    # Refresh agent token from server via refresh_token grant.
-    # Never rely on the locally-cached value — it may be stale or missing.
+    # Installation metadata is not a refresh grant. Keep the access/refresh pair
+    # together; another OAuth client's token must never replace this session.
     try:
         installed = _req(
             "GET",
             f"{base_url}/guard/config/installed?workspace_id={workspace_id}",
             token=_token,
         )
-        fresh_agent_token = installed.get("agent_token") or ""
-        if fresh_agent_token:
-            cfg["agent_token"] = fresh_agent_token
         if installed.get("user_email"):
             cfg["user_email"] = installed["user_email"]
         if installed.get("clerk_user_id"):
             cfg["clerk_user_id"] = installed["clerk_user_id"]
         _save_guard_config(cfg)
-        if not fresh_agent_token and not cfg.get("agent_token"):
+        if not cfg.get("agent_token"):
             print(f"  {YELLOW}Warning: server returned no token — proxy env may be stale{RESET}")
     except Exception as e:
-        print(f"  {YELLOW}Warning: could not refresh token ({e}) — using cached value{RESET}")
+        print(f"  {YELLOW}Warning: could not fetch installation metadata ({e}){RESET}")
 
     # Write LLM proxy env vars so any AI tool (Claude Code, Cursor, Codex, …)
     # routes through Conduct Guard. Customer-overridable via --proxy-url or

{conduct_cli-0.14.6 → conduct_cli-0.14.8}/src/conduct_cli/hooks/pretooluse.py

@@ -8,6 +8,7 @@ import shlex
 import subprocess
 import sys
 import time
+import urllib.parse
 import urllib.request
 from pathlib import Path
 
@@ -230,9 +231,18 @@ def _fetch_budget_status():
     api_url       = cfg.get("api_url", "https://api.conductai.ai").rstrip("/")
     if not workspace_id:
         return False, "unconfigured"
+    # ai_tool lets the server scope enforcement per-tool so an overspend in
+    # one client (e.g. codex-desktop) doesn't block others (e.g. claude-code).
+    try:
+        from conduct_cli.hooks.base import detect_ai_tool
+        ai_tool = detect_ai_tool() or ""
+    except Exception:
+        ai_tool = ""
     url = f"{api_url}/guard/spend/budget-check?workspace_id={workspace_id}"
     if clerk_user_id:
-        url += f"&clerk_user_id={clerk_user_id}"
+        url += f"&clerk_user_id={urllib.parse.quote(clerk_user_id, safe='')}"
+    if ai_tool:
+        url += f"&ai_tool={urllib.parse.quote(ai_tool, safe='')}"
     try:
         with urllib.request.urlopen(urllib.request.Request(url), timeout=5) as resp:
             data = json.loads(resp.read())
@@ -828,9 +838,12 @@ def main() -> None:
         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:
+    # Deduplicate the warning message, never the audit event.
+    suppress_warning = bool(
+        action == "warn" and session_id and rule_id
+        and _already_warned_this_session(session_id, rule_id)
+    )
+    if action == "warn" and session_id and rule_id and not suppress_warning:
         _record_session_warn(session_id, rule_id)
 
     # Pre-mint the audit-row id ONLY on block. That way the receipt URL
@@ -855,7 +868,7 @@ def main() -> None:
         print(msg)
         print(_boxed(msg, receipt_url), file=sys.stderr)
         sys.exit(2)
-    if action == "warn":
+    if action == "warn" and not suppress_warning:
         print(f"[ConductGuard] {message}")
 
     sys.exit(0)

{conduct_cli-0.14.6 → conduct_cli-0.14.8}/src/conduct_cli/main.py

@@ -2885,6 +2885,215 @@ def cmd_import_cedar(args):
         print(f"\nThis was a preview. Re-run with --install to create the pack in your workspace.")
 
 
+def cmd_import_gateway_config(args):
+    """conduct import --gateway-config <file.json> [--name NEW_NAME]
+
+    Import a Gateway Profile v2 from a portable JSON file. Server strips
+    every ``credential_ref`` on import — the admin then picks vault +
+    credential handle per target in the UI (Save gate blocks until
+    filled).
+
+    The JSON shape is the ``working_copy`` dict — same shape
+    ``conduct export --gateway-config`` emits and the same shape the
+    editor's Save call posts. Round-trip is safe: export → import
+    produces a draft the admin can complete in one editor session.
+
+    Exit codes: 0 on success, 1 on any failure (auth, missing file,
+    invalid JSON, backend rejection). Error output goes to stderr so
+    callers can pipe stdout without noise.
+    """
+    server, workspace, token = _require_auth(args)
+    if not token:
+        print(f"{RED}Not authenticated. Run `conduct login` first.{RESET}", file=sys.stderr)
+        sys.exit(1)
+
+    path = Path(args.file)
+    if not path.exists():
+        print(f"{RED}File not found: {path}{RESET}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        working_copy = json.loads(path.read_text())
+    except json.JSONDecodeError as e:
+        print(f"{RED}Invalid JSON in {path}: {e}{RESET}", file=sys.stderr)
+        sys.exit(1)
+
+    if not isinstance(working_copy, dict):
+        print(
+            f"{RED}Expected a JSON object at the top level (the "
+            f"working_copy dict); got {type(working_copy).__name__}.{RESET}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    body_dict = {"working_copy": working_copy}
+    if getattr(args, "name", None):
+        body_dict["name_override"] = args.name
+
+    req = urllib.request.Request(
+        f"{server}/workspaces/{workspace}/gateway-profiles-v2/import",
+        data=json.dumps(body_dict).encode("utf-8"),
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {token}",
+            "X-Workspace-Id": workspace or "",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:
+            result = json.loads(r.read())
+    except urllib.error.HTTPError as e:
+        body_text = e.read().decode(errors="replace")
+        # Backend returns structured errors (PR #2033) — parse them
+        # into a readable per-line summary when possible.
+        try:
+            payload = json.loads(body_text)
+            detail = payload.get("detail")
+            if isinstance(detail, dict) and isinstance(detail.get("errors"), list):
+                lines = [detail.get("summary", "import failed")]
+                for err in detail["errors"][:5]:
+                    where = err.get("path") or "(profile)"
+                    lines.append(f"  {where}: {err.get('message', 'invalid')}")
+                if len(detail["errors"]) > 5:
+                    lines.append(f"  +{len(detail['errors']) - 5} more")
+                detail_text = "\n".join(lines)
+            else:
+                detail_text = str(detail or body_text)[:600]
+        except Exception:
+            detail_text = body_text[:600]
+        print(f"{RED}Import failed ({e.code}):{RESET}\n{detail_text}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"{RED}Request failed: {e}{RESET}", file=sys.stderr)
+        sys.exit(1)
+
+    profile = result.get("profile") or {}
+    gaps = result.get("credential_gaps") or []
+    next_url = result.get("next_url") or ""
+
+    print(f"{BOLD}Gateway profile imported{RESET}")
+    print(f"  {GREEN}Name:{RESET}       {profile.get('name', '?')}")
+    print(f"  {GREEN}Profile ID:{RESET} {profile.get('id', '?')}")
+    print(f"  {GREEN}Cond code:{RESET}  {profile.get('cond_code', '?')}")
+
+    if gaps:
+        print(f"\n{YELLOW}{len(gaps)} target(s) need credentials before publish:{RESET}")
+        for g in gaps:
+            print(
+                f"  #{g.get('target_index', '?') + 1 if isinstance(g.get('target_index'), int) else '?'} "
+                f"{g.get('target_id', '?')} ({g.get('transport', '?')}): "
+                f"{g.get('reason', 'pick a vault')}"
+            )
+
+    if next_url:
+        print(f"\n{BLUE}Finish setup:{RESET} {next_url}")
+
+
+def cmd_export_gateway_config(args):
+    """conduct export --gateway-config <profile-id-or-cond-code> [--out FILE]
+
+    Pull a Gateway Profile v2 as portable JSON. Server strips every
+    ``credential_ref`` on export (safe to commit / share). Writes to
+    stdout by default; ``--out FILE`` writes to a file instead.
+
+    ``target`` is one of:
+      * a profile UUID (e.g. ``123e4567-e89b-12d3-a456-426614174000``),
+      * a bare cond_code (e.g. ``abc12345``), OR
+      * the full ``cond-<code>-<alias>`` string admins see in the
+        "How to use" panel (e.g. ``cond-abc12345-my-profile``).
+
+    Bare model aliases (e.g. ``claude-sonnet-4-6``) are NOT resolved —
+    they map to targets inside a profile, not to profiles themselves.
+
+    Exit codes: 0 on success, 1 on any failure (auth, unresolved
+    target, backend error). Errors go to stderr so ``--out`` piping
+    stays clean.
+    """
+    server, workspace, token = _require_auth(args)
+    if not token:
+        print(f"{RED}Not authenticated. Run `conduct login` first.{RESET}", file=sys.stderr)
+        sys.exit(1)
+
+    profile_id = _resolve_gateway_profile_id(server, workspace, token, args.target)
+    if not profile_id:
+        # _resolve_gateway_profile_id already printed the specific
+        # error to stderr — just exit nonzero here.
+        sys.exit(1)
+
+    req = urllib.request.Request(
+        f"{server}/workspaces/{workspace}/gateway-profiles-v2/{profile_id}/export",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "X-Workspace-Id": workspace or "",
+        },
+        method="GET",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:
+            snapshot = json.loads(r.read())
+    except urllib.error.HTTPError as e:
+        body_text = e.read().decode(errors="replace")
+        print(f"{RED}Export failed ({e.code}): {body_text[:400]}{RESET}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"{RED}Request failed: {e}{RESET}", file=sys.stderr)
+        sys.exit(1)
+
+    out_json = json.dumps(snapshot, indent=2)
+    out_path = getattr(args, "out", None)
+    if out_path:
+        Path(out_path).write_text(out_json + "\n")
+        print(f"{GREEN}Wrote:{RESET} {out_path}", file=sys.stderr)
+    else:
+        print(out_json)
+
+
+def _resolve_gateway_profile_id(server: str, workspace: str, token: str, target: str) -> str | None:
+    """Accept either a UUID or a cond_code. Returns the UUID or prints
+    an error + returns None."""
+    # UUID shape: 8-4-4-4-12 hex.
+    import re as _re
+    if _re.match(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", target, _re.IGNORECASE):
+        return target
+
+    # cond_code lookup — fetch the list, match by cond_code.
+    req = urllib.request.Request(
+        f"{server}/workspaces/{workspace}/gateway-profiles-v2",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "X-Workspace-Id": workspace or "",
+        },
+        method="GET",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:
+            profiles = json.loads(r.read())
+    except Exception as e:
+        print(
+            f"{RED}Could not list profiles to resolve {target!r}: {e}{RESET}",
+            file=sys.stderr,
+        )
+        return None
+
+    for p in profiles or []:
+        if p.get("cond_code") == target:
+            return p.get("id")
+        # Also accept "cond-<code>-<alias>" for convenience.
+        alias = p.get("model_alias") or ""
+        full = f"cond-{p.get('cond_code', '')}-{alias}"
+        if target == full:
+            return p.get("id")
+
+    print(
+        f"{RED}No profile matched {target!r}. Pass a profile UUID, "
+        f"a cond_code, or the full cond-<code>-<alias> identifier.{RESET}",
+        file=sys.stderr,
+    )
+    return None
+
+
 def cmd_skill(args):
     """conduct skill list | install <slug> | uninstall <slug>"""
     skill_command = getattr(args, "skill_command", None)
@@ -3102,6 +3311,46 @@ def main():
     ic_p.add_argument("--install", action="store_true", help="Install immediately (default is preview only)")
     ic_p.add_argument("--yes", action="store_true", help="Skip confirmation prompt when installing")
 
+    # conduct import --gateway-config <file>
+    # conduct export --gateway-config <profile-id-or-cond-code> [--out FILE]
+    #
+    # Both commands share ``--gateway-config`` as the surface. Adding
+    # future importable resource types (e.g. --guard-pack, --persona)
+    # is a matter of extending these two parsers, keeping the noun
+    # namespace ``conduct import`` / ``conduct export`` uncluttered.
+    imp_p = sub.add_parser(
+        "import",
+        help="Import a resource from JSON (currently: Gateway Profile v2)",
+    )
+    imp_p.add_argument(
+        "--gateway-config",
+        metavar="FILE",
+        help="Path to a Gateway Profile v2 JSON file (working_copy shape).",
+    )
+    imp_p.add_argument(
+        "--name",
+        metavar="NAME",
+        default=None,
+        help="Override the profile name in the JSON. Useful when the "
+             "source name is already taken in the target workspace.",
+    )
+
+    exp_p = sub.add_parser(
+        "export",
+        help="Export a resource as portable JSON (currently: Gateway Profile v2)",
+    )
+    exp_p.add_argument(
+        "--gateway-config",
+        metavar="PROFILE",
+        help="Profile UUID, cond_code (8 chars), or full cond-<code>-<alias> identifier.",
+    )
+    exp_p.add_argument(
+        "--out",
+        metavar="FILE",
+        default=None,
+        help="Write JSON to FILE (default: stdout).",
+    )
+
     # conduct sync
     sub.add_parser("sync", help="Sync Guard policies (and Security Loop policies if installed)")
 
@@ -3205,6 +3454,22 @@ def main():
         cmd_skill(args)
     elif args.command == "import-cedar":
         cmd_import_cedar(args)
+    elif args.command == "import":
+        # Only Gateway Profile v2 import today. Other imports (Guard
+        # skill packs, personas, etc.) already have their own commands.
+        if getattr(args, "gateway_config", None):
+            args.file = args.gateway_config
+            cmd_import_gateway_config(args)
+        else:
+            print(f"{RED}Usage: conduct import --gateway-config <file.json>{RESET}", file=sys.stderr)
+            sys.exit(1)
+    elif args.command == "export":
+        if getattr(args, "gateway_config", None):
+            args.target = args.gateway_config
+            cmd_export_gateway_config(args)
+        else:
+            print(f"{RED}Usage: conduct export --gateway-config <profile-id-or-cond-code>{RESET}", file=sys.stderr)
+            sys.exit(1)
     elif args.command == "sync":
         cmd_sync(args)
     elif args.command == "verify":

{conduct_cli-0.14.6 → conduct_cli-0.14.8}/src/conduct_cli.egg-info/PKG-INFO

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

{conduct_cli-0.14.6 → conduct_cli-0.14.8}/src/conduct_cli.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ tests/test_cli_matrix.py
 tests/test_cmd_run.py
 tests/test_command_word_matcher.py
 tests/test_drain_daemon_health.py
+tests/test_gateway_config_import_export.py
 tests/test_guard_approvals.py
 tests/test_guard_policy.py
 tests/test_guard_savings.py
@@ -54,4 +55,5 @@ tests/test_report_tool_coverage.py
 tests/test_session_start.py
 tests/test_signed_policy.py
 tests/test_switch.py
+tests/test_sync_credential_isolation.py
 tests/test_token_lifecycle.py

{conduct_cli-0.14.6 → conduct_cli-0.14.8}/tests/test_advisory_and_hook.py

@@ -308,7 +308,8 @@ class TestWarnDedup:
         posted = self._run_warn(monkeypatch, "sess-abc")
         assert "warned" in posted
 
-    def test_second_warn_same_session_skips(self, monkeypatch, tmp_path):
+    @pytest.mark.parametrize("tool", ["Bash", "exec_command", "apply_patch"])
+    def test_repeated_warn_records_every_call_but_prints_once(self, monkeypatch, capsys, tool):
         import conduct_cli.hooks.pretooluse as pt
         warns: dict[str, set] = {}
 
@@ -321,9 +322,6 @@ class TestWarnDedup:
         monkeypatch.setattr(pt, "_already_warned_this_session", _fake_already)
         monkeypatch.setattr(pt, "_record_session_warn", _fake_record)
 
-        # First call records the warn
-        _fake_record("sess-xyz", "no-echo")
-
         monkeypatch.setattr(pt, "check_policy", lambda tn, ti, **kw: ({}, "warn", "no-echo", "watch out"))
         monkeypatch.setattr(pt, "_get_fail_mode", lambda: "fail_open")
         monkeypatch.setattr(pt, "_get_advisory_mode", lambda: False)
@@ -332,16 +330,21 @@ class TestWarnDedup:
         monkeypatch.setattr(pt, "_maybe_sync_policy", lambda: None)
         monkeypatch.setattr(pt, "_should_periodic_flush", lambda: False)
 
-        posted: list[str] = []
-        monkeypatch.setattr(pt, "post_event", lambda tn, ti, d, r, m, s, **kw: posted.append(d))
-        monkeypatch.setattr(sys, "stdin", StringIO(_hook_input(session="sess-xyz")))
-
-        try:
-            pt.main()
-        except SystemExit:
-            pass
-
-        assert posted == [], "second warn same session should be skipped"
+        posted = []
+        monkeypatch.setattr(pt, "post_event", lambda tn, ti, d, r, m, s, **kw: posted.append((tn, ti, d, r, s)))
+        monkeypatch.setattr(pt, "record_hook_heartbeat", lambda *args: None)
+
+        for index, session in enumerate(["sess-xyz", "sess-xyz", "sess-new"]):
+            command = f"echo call-{index}"
+            monkeypatch.setattr(sys, "stdin", StringIO(_hook_input(tool=tool, cmd=command, session=session)))
+            with pytest.raises(SystemExit) as exc:
+                pt.main()
+            assert exc.value.code == 0
+            assert posted[-1] == (tool.lower(), {"command": command}, "warned", "no-echo", session)
+            assert len(posted) == index + 1
+            output = capsys.readouterr()
+            assert output.out == ("" if index == 1 else "[ConductGuard] watch out\n")
+            assert output.err == ""
 
 
 # ── advisory_mode mirrored on sync ────────────────────────────────────────────

conduct_cli-0.14.8/tests/test_gateway_config_import_export.py

@@ -0,0 +1,293 @@
+"""Tests for gateway-config import/export CLI commands.
+
+Scope: argparse wiring + happy path + error paths. HTTP layer stubbed
+via ``urllib.request.urlopen`` so no real API calls.
+
+Invariants locked:
+- Import posts to the design-locked URL.
+- ``--name`` translates to ``name_override``.
+- Non-existent file → readable error, no HTTP call.
+- Non-JSON file → readable error, no HTTP call.
+- Structured backend errors (PR #2033) render per-line.
+- Export resolves cond_code via the list endpoint first.
+"""
+from __future__ import annotations
+
+import io
+import json
+from unittest.mock import MagicMock
+
+import pytest
+
+from conduct_cli import main as cli
+
+
+UUID = "22222222-2222-2222-2222-222222222222"
+
+
+@pytest.fixture(autouse=True)
+def _stub_auth(monkeypatch):
+    monkeypatch.setattr(
+        cli, "_require_auth",
+        lambda args: ("https://api.example.com", "ws-1", "guard-mt-fake"),
+    )
+
+
+def _mk_response(payload, status=200):
+    class _CM:
+        def __enter__(self):
+            fake = MagicMock()
+            fake.read.return_value = json.dumps(payload).encode("utf-8")
+            fake.status = status
+            return fake
+        def __exit__(self, *a): return False
+    return _CM()
+
+
+# ─── import ──────────────────────────────────────────────────────────
+
+
+def test_import_posts_to_correct_url(tmp_path, monkeypatch):
+    src = tmp_path / "profile.json"
+    src.write_text(json.dumps({"name": "x", "targets": []}))
+    captured = {}
+    def _fake(req, timeout=None):
+        captured["url"] = req.full_url
+        captured["method"] = req.get_method()
+        return _mk_response({
+            "profile": {"id": UUID, "name": "x", "cond_code": "aa"},
+            "credential_gaps": [], "next_url": "",
+        })
+    monkeypatch.setattr(cli.urllib.request, "urlopen", _fake)
+
+    args = MagicMock(); args.file = str(src); args.name = None
+    cli.cmd_import_gateway_config(args)
+
+    assert captured["url"].endswith("/workspaces/ws-1/gateway-profiles-v2/import")
+    assert captured["method"] == "POST"
+
+
+def test_import_body_wraps_json_in_working_copy(tmp_path, monkeypatch):
+    src = tmp_path / "p.json"
+    payload = {"name": "x", "targets": [{"id": "a"}]}
+    src.write_text(json.dumps(payload))
+    captured = {}
+    def _fake(req, timeout=None):
+        captured["body"] = json.loads(req.data.decode("utf-8"))
+        return _mk_response({
+            "profile": {"id": UUID, "name": "x", "cond_code": "aa"},
+            "credential_gaps": [], "next_url": "",
+        })
+    monkeypatch.setattr(cli.urllib.request, "urlopen", _fake)
+
+    args = MagicMock(); args.file = str(src); args.name = None
+    cli.cmd_import_gateway_config(args)
+
+    assert captured["body"]["working_copy"] == payload
+
+
+def test_import_name_flag_becomes_override(tmp_path, monkeypatch):
+    src = tmp_path / "p.json"
+    src.write_text(json.dumps({"name": "orig"}))
+    captured = {}
+    def _fake(req, timeout=None):
+        captured["body"] = json.loads(req.data.decode("utf-8"))
+        return _mk_response({
+            "profile": {"id": UUID, "name": "renamed", "cond_code": "aa"},
+            "credential_gaps": [], "next_url": "",
+        })
+    monkeypatch.setattr(cli.urllib.request, "urlopen", _fake)
+
+    args = MagicMock(); args.file = str(src); args.name = "renamed"
+    cli.cmd_import_gateway_config(args)
+
+    assert captured["body"].get("name_override") == "renamed"
+
+
+def test_import_missing_file_no_http(tmp_path, monkeypatch, capsys):
+    called = []
+    monkeypatch.setattr(
+        cli.urllib.request, "urlopen",
+        lambda req, timeout=None: (called.append(True), _mk_response({}))[1],
+    )
+    args = MagicMock()
+    args.file = str(tmp_path / "nope.json"); args.name = None
+    # R5: missing file exits nonzero and prints the error to stderr,
+    # not stdout — scripts piping stdout must not see this noise.
+    with pytest.raises(SystemExit) as exc_info:
+        cli.cmd_import_gateway_config(args)
+    assert exc_info.value.code == 1
+    assert called == []
+    err = capsys.readouterr()
+    assert "File not found" in err.err
+    assert "File not found" not in err.out
+
+
+def test_import_invalid_json_no_http(tmp_path, monkeypatch, capsys):
+    bad = tmp_path / "bad.json"; bad.write_text("{ not valid")
+    called = []
+    monkeypatch.setattr(
+        cli.urllib.request, "urlopen",
+        lambda req, timeout=None: (called.append(True), _mk_response({}))[1],
+    )
+    args = MagicMock(); args.file = str(bad); args.name = None
+    # R5: invalid JSON exits nonzero and prints to stderr.
+    with pytest.raises(SystemExit) as exc_info:
+        cli.cmd_import_gateway_config(args)
+    assert exc_info.value.code == 1
+    assert called == []
+    err = capsys.readouterr()
+    assert "Invalid JSON" in err.err
+    assert "Invalid JSON" not in err.out
+
+
+def test_import_renders_structured_error_per_line(tmp_path, monkeypatch, capsys):
+    import urllib.error
+    src = tmp_path / "p.json"
+    src.write_text(json.dumps({"name": "x"}))
+    payload = {
+        "detail": {
+            "summary": "schema invalid",
+            "errors": [
+                {"path": "targets.0.credential_ref",
+                 "message": "must not be empty",
+                 "target_index": 0, "type": "value_error"},
+                {"path": "accepts", "message": "field required",
+                 "target_index": None, "type": "missing"},
+            ],
+        }
+    }
+    err = urllib.error.HTTPError(
+        "http://x", 400, "Bad Request", {},
+        io.BytesIO(json.dumps(payload).encode("utf-8")),
+    )
+    monkeypatch.setattr(
+        cli.urllib.request, "urlopen",
+        lambda req, timeout=None: (_ for _ in ()).throw(err),
+    )
+    args = MagicMock(); args.file = str(src); args.name = None
+    # R5: backend rejection exits nonzero and lands on stderr — but
+    # the structured per-line rendering still happens so CI logs are
+    # readable.
+    with pytest.raises(SystemExit) as exc_info:
+        cli.cmd_import_gateway_config(args)
+    assert exc_info.value.code == 1
+    stderr = capsys.readouterr().err
+    assert "schema invalid" in stderr
+    assert "targets.0.credential_ref" in stderr
+    assert "must not be empty" in stderr
+
+
+def test_import_prints_credential_gaps(tmp_path, monkeypatch, capsys):
+    src = tmp_path / "p.json"; src.write_text(json.dumps({"name": "x"}))
+    monkeypatch.setattr(cli.urllib.request, "urlopen", lambda req, timeout=None: _mk_response({
+        "profile": {"id": UUID, "name": "x", "cond_code": "aa"},
+        "credential_gaps": [
+            {"target_index": 0, "target_id": "primary", "transport": "native_http",
+             "reason": "credential_ref stripped on import"},
+            {"target_index": 1, "target_id": "fallback", "transport": "native_http",
+             "reason": "credential_ref stripped on import"},
+        ],
+        "next_url": "https://api.example.com/proxy/gateway-profiles",
+    }))
+    args = MagicMock(); args.file = str(src); args.name = None
+    cli.cmd_import_gateway_config(args)
+    out = capsys.readouterr().out
+    assert "2 target(s) need credentials" in out
+    assert "primary" in out and "fallback" in out
+    assert "/proxy/gateway-profiles" in out
+
+
+# ─── export ──────────────────────────────────────────────────────────
+
+
+def test_export_by_uuid_direct(monkeypatch, capsys):
+    calls = []
+    def _fake(req, timeout=None):
+        calls.append(req.full_url)
+        return _mk_response({"name": "claude", "targets": []})
+    monkeypatch.setattr(cli.urllib.request, "urlopen", _fake)
+    args = MagicMock(); args.target = UUID; args.out = None
+    cli.cmd_export_gateway_config(args)
+    assert calls == [f"https://api.example.com/workspaces/ws-1/gateway-profiles-v2/{UUID}/export"]
+    assert '"name": "claude"' in capsys.readouterr().out
+
+
+def test_export_by_cond_code_resolves_via_list(monkeypatch, capsys):
+    calls = []
+    def _fake(req, timeout=None):
+        calls.append(req.full_url)
+        if req.full_url.endswith("/gateway-profiles-v2"):
+            return _mk_response([
+                {"id": UUID, "cond_code": "abc12345", "model_alias": "claude"},
+            ])
+        return _mk_response({"name": "resolved", "targets": []})
+    monkeypatch.setattr(cli.urllib.request, "urlopen", _fake)
+    args = MagicMock(); args.target = "abc12345"; args.out = None
+    cli.cmd_export_gateway_config(args)
+    assert len(calls) == 2
+    assert calls[0].endswith("/gateway-profiles-v2")
+    assert calls[1].endswith(f"/gateway-profiles-v2/{UUID}/export")
+
+
+def test_export_unknown_cond_code_no_export_call(monkeypatch, capsys):
+    def _fake(req, timeout=None):
+        return _mk_response([{"id": UUID, "cond_code": "other"}])
+    monkeypatch.setattr(cli.urllib.request, "urlopen", _fake)
+    args = MagicMock(); args.target = "unknown"; args.out = None
+    # R5: unresolved target exits nonzero, error on stderr, stdout
+    # stays clean so ``conduct export ... > file.json`` never writes
+    # an error message into the destination file.
+    with pytest.raises(SystemExit) as exc_info:
+        cli.cmd_export_gateway_config(args)
+    assert exc_info.value.code == 1
+    captured = capsys.readouterr()
+    assert "No profile matched" in captured.err
+    assert captured.out == ""
+
+
+def test_export_stdout_stays_clean_on_backend_error(tmp_path, monkeypatch, capsys):
+    """R5: an HTTPError during export must NOT contaminate stdout —
+    ``conduct export ... > profile.json`` piping into a file must
+    only see the profile JSON, never an error message."""
+    import urllib.error
+    err = urllib.error.HTTPError(
+        "http://x", 500, "Server Error", {},
+        io.BytesIO(b"boom"),
+    )
+    calls = []
+    def _fake(req, timeout=None):
+        if req.full_url.endswith("/export"):
+            raise err
+        return _mk_response([{"id": UUID, "cond_code": "abc"}])
+    monkeypatch.setattr(cli.urllib.request, "urlopen", _fake)
+    args = MagicMock(); args.target = UUID; args.out = None
+    with pytest.raises(SystemExit) as exc_info:
+        cli.cmd_export_gateway_config(args)
+    assert exc_info.value.code == 1
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "Export failed" in captured.err
+
+
+def test_import_unauth_exits_nonzero_on_stderr(monkeypatch, capsys, tmp_path):
+    """R5: no token → exit 1, error on stderr."""
+    monkeypatch.setattr(
+        cli, "_require_auth",
+        lambda args: ("https://api.example.com", "ws-1", None),
+    )
+    src = tmp_path / "p.json"; src.write_text(json.dumps({"name": "x"}))
+    args = MagicMock(); args.file = str(src); args.name = None
+    with pytest.raises(SystemExit) as exc_info:
+        cli.cmd_import_gateway_config(args)
+    assert exc_info.value.code == 1
+    assert "Not authenticated" in capsys.readouterr().err
+
+
+def test_export_out_writes_file(tmp_path, monkeypatch):
+    dest = tmp_path / "out.json"
+    monkeypatch.setattr(cli.urllib.request, "urlopen",
+                        lambda req, timeout=None: _mk_response({"name": "x", "targets": []}))
+    args = MagicMock(); args.target = UUID; args.out = str(dest)
+    cli.cmd_export_gateway_config(args)
+    assert json.loads(dest.read_text()) == {"name": "x", "targets": []}

conduct_cli-0.14.8/tests/test_sync_credential_isolation.py

@@ -0,0 +1,44 @@
+"""A metadata fetch must never swap out a client's access/refresh pair."""
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+from conduct_cli import guard
+
+
+def test_sync_preserves_credentials_when_install_status_returns_another_token(monkeypatch):
+    cfg = {
+        "agent_token": "cond_agt_current-session",
+        "refresh_token": "cond_ref_current-session",
+        "workspace_id": "11111111-1111-4111-8111-111111111111",
+        "token_expires_at": "2099-01-01T00:00:00+00:00",
+    }
+    original = cfg.copy()
+    monkeypatch.setattr(guard, "_proactive_token_refresh", lambda: None)
+    monkeypatch.setattr(guard, "_require_guard_config", lambda: cfg)
+    monkeypatch.setattr(guard, "_api_url", lambda _: "https://api.example.test")
+    monkeypatch.setattr(guard, "_check_and_upgrade_packages", lambda: None)
+    monkeypatch.setattr(guard, "_save_policy", lambda _: None)
+    request = Mock(side_effect=[{"rules": []}, {
+        "agent_token": "cond_agt_another-client",
+        "user_email": "synthetic@example.test",
+        "clerk_user_id": "synthetic",
+    }])
+    monkeypatch.setattr(guard, "_req", request)
+
+    class MetadataSaved(BaseException):
+        pass
+
+    def save(value):
+        for key, expected in original.items():
+            assert value[key] == expected
+        assert value["clerk_user_id"] == "synthetic"
+        raise MetadataSaved()
+
+    monkeypatch.setattr(guard, "_save_guard_config", save)
+    # Stop before machine configuration, process launches or external requests.
+    with pytest.raises(MetadataSaved):
+        guard.cmd_guard_sync(SimpleNamespace(dry_run=False))
+    assert request.call_count == 2
+    assert all(call.kwargs["token"] == original["agent_token"] for call in request.call_args_list)