conduct-cli 0.4.40__tar.gz → 0.4.41__tar.gz

{conduct_cli-0.4.40 → conduct_cli-0.4.41}/PKG-INFO

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

{conduct_cli-0.4.40 → conduct_cli-0.4.41}/pyproject.toml

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

{conduct_cli-0.4.40 → conduct_cli-0.4.41}/src/conduct_cli/main.py

@@ -1289,6 +1289,175 @@ def _build_state(issue: dict, repo_full_name: str) -> dict:
     return {"github_issue": trigger, "_trigger": trigger}
 
 
+def _atomic_write(path: Path, data: dict) -> None:
+    """Write data to path atomically via a .tmp sibling."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2))
+    os.replace(tmp, path)
+
+
+def cmd_switch(args):
+    cfg = _load_config()
+    server  = cfg.get("server", "").rstrip("/")
+    api_key = cfg.get("api_key", "")
+    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}")
+        sys.exit(1)
+
+    hdrs = {"Content-Type": "application/json"}
+    if api_key:
+        hdrs["X-Api-Key"] = api_key
+    elif token:
+        hdrs["Authorization"] = f"Bearer {token}"
+
+    workspaces = api.req("GET", f"{server}/projects", hdrs)
+
+    current_id = cfg.get("workspace", "")
+    target = getattr(args, "workspace", None)
+
+    if not target:
+        # List mode — print numbered list with current marked
+        if not workspaces:
+            print("No workspaces found.")
+            return
+        print(f"\n{BOLD}Workspaces:{RESET}")
+        for i, ws in enumerate(workspaces, 1):
+            marker = f"{GREEN}*{RESET}" if str(ws.get("id", "")) == str(current_id) else " "
+            wid = str(ws.get("id", ""))
+            print(f"  {marker} {i}. {ws['name']:<35} {GRAY}{wid}{RESET}")
+        print()
+        return
+
+    # Match workspace: exact name (case-insensitive) first
+    target_lower = target.lower()
+
+    exact = [ws for ws in workspaces if ws["name"].lower() == target_lower]
+    if not exact:
+        # Partial name match
+        partial = [ws for ws in workspaces if target_lower in ws["name"].lower()]
+        if not partial:
+            # UUID prefix match
+            partial = [ws for ws in workspaces if str(ws.get("id", "")).startswith(target)]
+        candidates = partial
+    else:
+        candidates = exact
+
+    if len(candidates) > 1:
+        print(f"{YELLOW}Ambiguous — multiple matches for '{target}':{RESET}")
+        for ws in candidates:
+            print(f"  {ws['name']}  {GRAY}({ws['id']}){RESET}")
+        print("Be more specific.")
+        sys.exit(1)
+
+    if not candidates:
+        print(f"{RED}No workspace matching '{target}' found. Available:{RESET}")
+        for ws in workspaces:
+            print(f"  {ws['name']}  {GRAY}({ws['id']}){RESET}")
+        sys.exit(1)
+
+    chosen = candidates[0]
+    new_id   = str(chosen["id"])
+    new_name = chosen["name"]
+
+    # Update ~/.conduct/config.json atomically
+    cfg["workspace"] = new_id
+    _atomic_write(CONFIG_PATH, cfg)
+
+    # Update ~/.conductguard/config.json atomically if it exists
+    guard_cfg_path = Path.home() / ".conductguard" / "config.json"
+    if guard_cfg_path.exists():
+        try:
+            guard_cfg = json.loads(guard_cfg_path.read_text())
+            guard_cfg["workspace_id"] = new_id
+            _atomic_write(guard_cfg_path, guard_cfg)
+        except Exception:
+            pass
+
+    # Re-sync Guard policies for the new workspace
+    try:
+        policy = _guard._req(
+            "GET",
+            f"{server}/guard/policies/sync?workspace_id={new_id}",
+            api_key=api_key,
+        )
+        _guard._save_policy(policy)
+        rule_count = len(policy.get("rules", []))
+        print(f"  {GRAY}Guard policies synced: {rule_count} rule(s){RESET}")
+    except SystemExit:
+        pass  # Guard not configured for this workspace — skip silently
+    except Exception:
+        pass
+
+    print(f"{GREEN}✓ Switched to \"{new_name}\" ({new_id[:8]}){RESET}")
+
+
+def cmd_whoami(args):
+    cfg = _load_config()
+
+    workspace_id   = cfg.get("workspace", "")
+    server         = cfg.get("server", "—")
+    api_key        = cfg.get("api_key", "")
+
+    # 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}
+            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:
+                workspace_name = match["name"]
+        except Exception:
+            pass
+
+    ws_display = workspace_name if workspace_name else workspace_id
+    ws_id_hint = f"  ({workspace_id[:8]})" if workspace_id else ""
+    api_key_display = (api_key[:12] + "…  (set)") if api_key else "not set"
+
+    print(f"\n{BOLD}Workspace:{RESET}  {ws_display}{ws_id_hint}")
+    print(f"{BOLD}Server:{RESET}     {server}")
+    print(f"{BOLD}API key:{RESET}    {api_key_display}")
+
+    # Guard section
+    guard_cfg_path = Path.home() / ".conductguard" / "config.json"
+    policy_path    = Path.home() / ".conductguard" / "policy.json"
+    hook_path      = Path.home() / ".conductguard" / "hook.py"
+
+    if guard_cfg_path.exists():
+        try:
+            gcfg = json.loads(guard_cfg_path.read_text())
+            user_email = gcfg.get("user_email", "")
+            rule_count = 0
+            if policy_path.exists():
+                try:
+                    rule_count = len(json.loads(policy_path.read_text()).get("rules", []))
+                except Exception:
+                    pass
+            hook_status = "hook installed" if hook_path.exists() else "hook missing"
+            email_part  = f"  |  member: {user_email}" if user_email else ""
+            print(f"{BOLD}Guard:{RESET}      {GREEN}✓ {hook_status}{RESET}  |  policy: {rule_count} rules{email_part}")
+        except Exception:
+            print(f"{BOLD}Guard:{RESET}      {YELLOW}config unreadable{RESET}")
+    else:
+        print(f"{BOLD}Guard:{RESET}      not configured")
+
+    # Booster section
+    booster_paths = [
+        Path.home() / ".booster" / "config.json",
+        Path.home() / ".agent-booster" / "config.json",
+    ]
+    booster_found = any(p.exists() for p in booster_paths)
+    if booster_found:
+        print(f"{BOLD}Booster:{RESET}    {GREEN}✓ configured{RESET}")
+    else:
+        print(f"{BOLD}Booster:{RESET}    not configured")
+
+    print()
+
+
 def cmd_run(args):
     server, workspace_id, api_key, token = _require_auth(args)
     json_h = api.headers(workspace_id, token, "application/json", api_key)
@@ -1443,6 +1612,14 @@ def main():
     run_p.add_argument("--input",     action="append", metavar="key=value", help="Runtime input (repeatable)")
     run_p.add_argument("--max-turns", dest="max_turns", type=int, metavar="N", help="Max agentic turns (default: auto)")
 
+    # conduct switch [workspace]
+    switch_p = sub.add_parser("switch", help="Switch active workspace (or list workspaces)")
+    switch_p.add_argument("workspace", nargs="?", metavar="name_or_id",
+                          help="Workspace name or UUID prefix to switch to (omit to list)")
+
+    # conduct whoami
+    sub.add_parser("whoami", help="Show current workspace, server, API key, and Guard/Booster status")
+
     # conduct guard
     guard_p, _guard_sub = _guard.register_guard_parser(sub)
 
@@ -1495,6 +1672,10 @@ def main():
         cmd_test(args)
     elif args.command == "run":
         cmd_run(args)
+    elif args.command == "switch":
+        cmd_switch(args)
+    elif args.command == "whoami":
+        cmd_whoami(args)
     elif args.command == "guard":
         _guard.dispatch_guard(args, guard_p)
     elif args.command == "mcp":

{conduct_cli-0.4.40 → conduct_cli-0.4.41}/src/conduct_cli.egg-info/PKG-INFO

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

{conduct_cli-0.4.40 → conduct_cli-0.4.41}/src/conduct_cli.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ src/conduct_cli.egg-info/SOURCES.txt
 src/conduct_cli.egg-info/dependency_links.txt
 src/conduct_cli.egg-info/entry_points.txt
 src/conduct_cli.egg-info/requires.txt
-src/conduct_cli.egg-info/top_level.txt
+src/conduct_cli.egg-info/top_level.txt
+tests/test_switch.py

conduct_cli-0.4.41/tests/test_switch.py

@@ -0,0 +1,215 @@
+"""Tests for `conduct switch` and `conduct whoami` commands."""
+
+import json
+import sys
+import types
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_args(**kwargs):
+    ns = types.SimpleNamespace(**kwargs)
+    return ns
+
+
+def _fake_workspaces():
+    return [
+        {"id": "ef0a7e36-0000-0000-0000-000000000001", "name": "Engineering",    "owner_id": "u1", "workflow_count": 3},
+        {"id": "ab1b2c3d-0000-0000-0000-000000000002", "name": "Marketing",      "owner_id": "u1", "workflow_count": 1},
+        {"id": "deadbeef-0000-0000-0000-000000000003", "name": "Eng Backup",     "owner_id": "u1", "workflow_count": 0},
+    ]
+
+
+# ---------------------------------------------------------------------------
+# cmd_switch — list mode (no arg)
+# ---------------------------------------------------------------------------
+
+def test_switch_list_prints_workspaces(tmp_path, capsys):
+    """conduct switch with no arg exits 0 and prints workspace list."""
+    from conduct_cli import main as m
+
+    config = {
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_testkey",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }
+    cfg_path = tmp_path / "config.json"
+    cfg_path.write_text(json.dumps(config))
+
+    args = _make_args(workspace=None)
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+    ):
+        m.cmd_switch(args)
+
+    out = capsys.readouterr().out
+    assert "Engineering" in out
+    assert "Marketing"   in out
+    assert "*" in out          # current workspace marked
+
+
+# ---------------------------------------------------------------------------
+# cmd_switch — exact match updates both config files
+# ---------------------------------------------------------------------------
+
+def test_switch_exact_name_updates_configs(tmp_path, capsys):
+    """conduct switch 'Marketing' updates ~/.conduct/config.json and guard config."""
+    from conduct_cli import main as m
+    from conduct_cli import guard as g
+
+    cfg_path        = tmp_path / "conduct" / "config.json"
+    # Guard config lives at <home>/.conductguard/config.json; home is patched to tmp_path
+    guard_cfg_path  = tmp_path / ".conductguard" / "config.json"
+
+    cfg_path.parent.mkdir(parents=True)
+    guard_cfg_path.parent.mkdir(parents=True)
+
+    cfg_path.write_text(json.dumps({
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_testkey",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }))
+    guard_cfg_path.write_text(json.dumps({
+        "workspace_id": "ef0a7e36-0000-0000-0000-000000000001",
+        "user_email":   "dev@example.com",
+    }))
+
+    args = _make_args(workspace="Marketing")
+
+    fake_policy = {"version": "2", "rules": [{"rule_id": "r1", "action": "audit"}]}
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch("pathlib.Path.home", return_value=tmp_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+        patch.object(g, "_req", return_value=fake_policy),
+        patch.object(g, "_save_policy") as mock_save_policy,
+    ):
+        m.cmd_switch(args)
+
+    out = capsys.readouterr().out
+    assert "Marketing" in out
+    assert "ab1b2c3d" in out   # first 8 chars of the new workspace id
+
+    updated_cfg = json.loads(cfg_path.read_text())
+    assert updated_cfg["workspace"] == "ab1b2c3d-0000-0000-0000-000000000002"
+
+    updated_guard = json.loads(guard_cfg_path.read_text())
+    assert updated_guard["workspace_id"] == "ab1b2c3d-0000-0000-0000-000000000002"
+
+    mock_save_policy.assert_called_once_with(fake_policy)
+
+
+# ---------------------------------------------------------------------------
+# cmd_switch — ambiguous partial match
+# ---------------------------------------------------------------------------
+
+def test_switch_ambiguous_exits_1(tmp_path, capsys):
+    """Partial match that hits multiple workspaces prints error and exits 1."""
+    from conduct_cli import main as m
+
+    cfg_path = tmp_path / "config.json"
+    cfg_path.write_text(json.dumps({
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_testkey",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }))
+
+    # "Eng" matches both "Engineering" and "Eng Backup"
+    args = _make_args(workspace="Eng")
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+        pytest.raises(SystemExit) as exc,
+    ):
+        m.cmd_switch(args)
+
+    assert exc.value.code == 1
+    out = capsys.readouterr().out
+    assert "Ambiguous" in out or "ambiguous" in out.lower() or "more specific" in out
+
+
+# ---------------------------------------------------------------------------
+# cmd_switch — no match exits 1
+# ---------------------------------------------------------------------------
+
+def test_switch_no_match_exits_1(tmp_path, capsys):
+    """conduct switch 'Nonexistent' exits 1 and lists available workspaces."""
+    from conduct_cli import main as m
+
+    cfg_path = tmp_path / "config.json"
+    cfg_path.write_text(json.dumps({
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_testkey",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }))
+
+    args = _make_args(workspace="Nonexistent")
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+        pytest.raises(SystemExit) as exc,
+    ):
+        m.cmd_switch(args)
+
+    assert exc.value.code == 1
+    out = capsys.readouterr().out
+    assert "Engineering" in out   # shows available list
+
+
+# ---------------------------------------------------------------------------
+# cmd_whoami — basic output
+# ---------------------------------------------------------------------------
+
+def test_whoami_prints_all_sections(tmp_path, capsys):
+    """conduct whoami prints workspace, server, api_key, Guard, and Booster lines."""
+    from conduct_cli import main as m
+
+    cfg_path = tmp_path / "conduct" / "config.json"
+    cfg_path.parent.mkdir(parents=True)
+    cfg_path.write_text(json.dumps({
+        "server":    "https://api.conductai.ai",
+        "api_key":   "cond_live_88a4longkeyxxx",
+        "workspace": "ef0a7e36-0000-0000-0000-000000000001",
+    }))
+
+    guard_dir = tmp_path / ".conductguard"
+    guard_dir.mkdir()
+    (guard_dir / "config.json").write_text(json.dumps({
+        "workspace_id": "ef0a7e36-0000-0000-0000-000000000001",
+        "user_email":   "sudhi@b2bsphere.com",
+    }))
+    (guard_dir / "policy.json").write_text(json.dumps({
+        "version": "1",
+        "rules":   [{"rule_id": "r1"}, {"rule_id": "r2"}, {"rule_id": "r3"}],
+    }))
+    # No hook.py — hook_status should say "hook missing"
+
+    args = _make_args()
+
+    def fake_home():
+        return tmp_path
+
+    with (
+        patch.object(m, "CONFIG_PATH", cfg_path),
+        patch("pathlib.Path.home", return_value=tmp_path),
+        patch.object(m.api, "req", return_value=_fake_workspaces()),
+    ):
+        m.cmd_whoami(args)
+
+    out = capsys.readouterr().out
+    assert "https://api.conductai.ai" in out
+    assert "cond_live_88" in out   # first 12 chars of the api_key
+    assert "sudhi@b2bsphere.com" in out
+    assert "3 rules" in out
+    assert "Booster" in out