conduct-cli 0.4.27__tar.gz → 0.4.28__tar.gz

{conduct_cli-0.4.27 → conduct_cli-0.4.28}/PKG-INFO

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

{conduct_cli-0.4.27 → conduct_cli-0.4.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conduct-cli"
-version = "0.4.27"
+version = "0.4.28"
 description = "CLI for Conduct AI — install agents, manage projects, run tests"
 readme = "README.md"
 license = { text = "MIT" }
@@ -31,8 +31,9 @@ Repository  = "https://github.com/sseshachala/conductai"
 "Bug Tracker" = "https://github.com/sseshachala/conductai/issues"
 
 [project.scripts]
-conduct          = "conduct_cli.main:main"
-conductguard-mcp = "conduct_cli.guardmcp:main"
+conduct           = "conduct_cli.main:main"
+conduct-mcp       = "conduct_cli.mcp_server:main"
+conductguard-mcp  = "conduct_cli.guardmcp:main"
 conductguard-post = "conduct_cli.guard:post_usage_main"
 
 [tool.setuptools.packages.find]

{conduct_cli-0.4.27 → conduct_cli-0.4.28}/src/conduct_cli/main.py

@@ -192,6 +192,81 @@ def _poll_run(server: str, workflow_id: str, run_id: str, hdrs: dict) -> bool:
 
 # ── Commands ──────────────────────────────────────────────────────────────────
 
+def _write_claude_mcp_settings() -> bool:
+    """Write conduct-mcp into ~/.claude/settings.json. Returns True if written."""
+    settings_path = Path.home() / ".claude" / "settings.json"
+    try:
+        existing = json.loads(settings_path.read_text()) if settings_path.exists() else {}
+        servers = existing.setdefault("mcpServers", {})
+        if "conduct" in servers:
+            return True  # already registered
+        servers["conduct"] = {"command": "conduct-mcp", "args": []}
+        settings_path.parent.mkdir(parents=True, exist_ok=True)
+        settings_path.write_text(json.dumps(existing, indent=2))
+        return True
+    except Exception:
+        return False
+
+
+def _write_codex_mcp_config() -> bool:
+    """Write conduct-mcp into ~/.codex/config.toml. Returns True if written."""
+    codex_dir = Path.home() / ".codex"
+    if not codex_dir.exists():
+        return False
+    config_path = codex_dir / "config.toml"
+    try:
+        content = config_path.read_text() if config_path.exists() else ""
+        if "conduct-mcp" in content:
+            return True  # already registered
+        mcp_block = '\n[[mcp_servers]]\nname = "conduct"\ncommand = "conduct-mcp"\nargs = []\n'
+        config_path.write_text(content + mcp_block)
+        return True
+    except Exception:
+        return False
+
+
+def cmd_mcp_install(args):
+    """Register conduct-mcp in Claude Code and Codex CLI."""
+    import shutil
+    import subprocess
+
+    registered = []
+
+    # --- Claude Code ---
+    if shutil.which("claude"):
+        try:
+            result = subprocess.run(
+                ["claude", "mcp", "add", "conduct", "conduct-mcp"],
+                capture_output=True, text=True, timeout=15,
+            )
+            if result.returncode == 0:
+                registered.append("Claude Code")
+            else:
+                # claude mcp add is idempotent; also try writing settings.json directly as fallback
+                _write_claude_mcp_settings()
+                registered.append("Claude Code (settings.json)")
+        except Exception:
+            _write_claude_mcp_settings()
+            registered.append("Claude Code (settings.json)")
+    else:
+        # claude CLI not found but .claude/ might exist (IDE extension)
+        written = _write_claude_mcp_settings()
+        if written:
+            registered.append("Claude Code (settings.json)")
+
+    # --- Codex CLI ---
+    written = _write_codex_mcp_config()
+    if written:
+        registered.append("Codex")
+
+    if registered:
+        print(f"{GREEN}✓ conduct-mcp registered in: {', '.join(registered)}{RESET}")
+        print(f"{GRAY}  Restart Claude Code / Codex to pick up the new MCP server.{RESET}")
+    else:
+        print(f"{YELLOW}⚠ No supported AI tools detected. Install Claude Code or Codex first.{RESET}")
+        print(f"{GRAY}  Then re-run: conduct mcp install{RESET}")
+
+
 def cmd_login(args):
     server    = args.server
     api_key   = args.api_key
@@ -254,6 +329,13 @@ def cmd_login(args):
         except Exception:
             pass  # Never block login on Guard errors
 
+    # Auto-register MCP servers in Claude Code / Codex
+    try:
+        import types
+        cmd_mcp_install(types.SimpleNamespace())
+    except Exception:
+        pass  # Never block login on MCP registration errors
+
 
 def cmd_agents(args):
     server, workspace_id, api_key, token = _require_auth(args)
@@ -1179,6 +1261,11 @@ def main():
     # conduct guard
     guard_p, _guard_sub = _guard.register_guard_parser(sub)
 
+    # conduct mcp
+    mcp_p = sub.add_parser("mcp", help="Manage the Conduct MCP server")
+    mcp_sub = mcp_p.add_subparsers(dest="mcp_command")
+    mcp_sub.add_parser("install", help="Register conduct-mcp in Claude Code and Codex")
+
     args = parser.parse_args()
 
     if args.command == "login":
@@ -1223,6 +1310,11 @@ def main():
         cmd_run(args)
     elif args.command == "guard":
         _guard.dispatch_guard(args, guard_p)
+    elif args.command == "mcp":
+        if getattr(args, "mcp_command", None) == "install":
+            cmd_mcp_install(args)
+        else:
+            mcp_p.print_help()
     else:
         parser.print_help()
 

conduct_cli-0.4.28/src/conduct_cli/mcp_server.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""
+conduct-mcp — Conduct AI MCP server.
+
+Runs as a subprocess started by Claude Code / Cursor / Windsurf via the
+mcpServers config written by `conduct mcp install`. Communicates over
+stdin/stdout using JSON-RPC 2.0 (MCP stdio transport).
+
+Exposes six tools:
+  conduct_list_agents    — list agents in the workspace
+  conduct_list_projects  — list projects in the workspace
+  conduct_list_playbooks — list available playbook templates
+  conduct_run_workflow   — trigger a workflow run
+  conduct_get_run        — get run status / result
+  conduct_guard_status   — ConductGuard policy status
+"""
+from __future__ import annotations
+
+import json
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+CONDUCT_CONFIG_PATH = Path.home() / ".conduct" / "config.json"
+GUARD_DIR           = Path.home() / ".conductguard"
+GUARD_POLICY_PATH   = GUARD_DIR / "policy.json"
+GUARD_CONFIG_PATH   = GUARD_DIR / "config.json"
+
+PROTOCOL_VERSION = "2024-11-05"
+
+_TOOLS = [
+    {
+        "name": "conduct_list_agents",
+        "description": "List all installed agents in your Conduct workspace.",
+        "inputSchema": {"type": "object", "properties": {}, "required": []},
+    },
+    {
+        "name": "conduct_list_projects",
+        "description": "List all projects in your Conduct workspace.",
+        "inputSchema": {"type": "object", "properties": {}, "required": []},
+    },
+    {
+        "name": "conduct_list_playbooks",
+        "description": "List available Conduct playbooks (workflow templates).",
+        "inputSchema": {"type": "object", "properties": {}, "required": []},
+    },
+    {
+        "name": "conduct_run_workflow",
+        "description": "Trigger a workflow run in Conduct. Returns the run ID.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "workflow_id": {
+                    "type": "string",
+                    "description": "The workflow UUID to run",
+                },
+                "payload": {
+                    "type": "object",
+                    "description": "Optional trigger payload (key-value pairs)",
+                },
+            },
+            "required": ["workflow_id"],
+        },
+    },
+    {
+        "name": "conduct_get_run",
+        "description": "Get the status and result of a workflow run.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "workflow_id": {"type": "string"},
+                "run_id":      {"type": "string"},
+            },
+            "required": ["workflow_id", "run_id"],
+        },
+    },
+    {
+        "name": "conduct_guard_status",
+        "description": (
+            "Show current ConductGuard policy status — active rules, "
+            "today's spend, and your team info."
+        ),
+        "inputSchema": {"type": "object", "properties": {}, "required": []},
+    },
+]
+
+
+# ── Config helpers ─────────────────────────────────────────────────────────────
+
+def _load_conduct_config() -> dict:
+    if CONDUCT_CONFIG_PATH.exists():
+        try:
+            return json.loads(CONDUCT_CONFIG_PATH.read_text())
+        except Exception:
+            pass
+    return {}
+
+
+def _load_guard_policy() -> dict:
+    if GUARD_POLICY_PATH.exists():
+        try:
+            return json.loads(GUARD_POLICY_PATH.read_text())
+        except Exception:
+            pass
+    return {"rules": []}
+
+
+def _load_guard_config() -> dict:
+    if GUARD_CONFIG_PATH.exists():
+        try:
+            return json.loads(GUARD_CONFIG_PATH.read_text())
+        except Exception:
+            pass
+    return {}
+
+
+# ── HTTP helpers ───────────────────────────────────────────────────────────────
+
+def _api_get(url: str, token: str | None, api_key: str | None) -> dict | list:
+    headers = {"Content-Type": "application/json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    elif api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    req = urllib.request.Request(url, headers=headers)
+    with urllib.request.urlopen(req, timeout=10) as resp:
+        return json.loads(resp.read())
+
+
+def _api_post(url: str, body: dict, token: str | None, api_key: str | None) -> dict | list:
+    headers = {"Content-Type": "application/json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    elif api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    data = json.dumps(body).encode()
+    req = urllib.request.Request(url, data=data, headers=headers, method="POST")
+    with urllib.request.urlopen(req, timeout=10) as resp:
+        return json.loads(resp.read())
+
+
+# ── Tool handlers ──────────────────────────────────────────────────────────────
+
+def _handle_list_agents(server: str, workspace_id: str, token: str | None, api_key: str | None) -> str:
+    try:
+        url    = f"{server}/agents?workspace_id={workspace_id}"
+        result = _api_get(url, token, api_key)
+        agents = [
+            {"id": a.get("id"), "name": a.get("name"), "status": a.get("status")}
+            for a in (result if isinstance(result, list) else result.get("items", []))
+        ]
+        return json.dumps(agents, indent=2)
+    except urllib.error.HTTPError as e:
+        return f"Error — HTTP {e.code}: {e.read().decode()[:200]}"
+    except Exception as e:
+        return f"Error — {e}"
+
+
+def _handle_list_projects(server: str, workspace_id: str, token: str | None, api_key: str | None) -> str:
+    try:
+        url    = f"{server}/projects?workspace_id={workspace_id}"
+        result = _api_get(url, token, api_key)
+        return json.dumps(result, indent=2)
+    except urllib.error.HTTPError as e:
+        return f"Error — HTTP {e.code}: {e.read().decode()[:200]}"
+    except Exception as e:
+        return f"Error — {e}"
+
+
+def _handle_list_playbooks(server: str, workspace_id: str, token: str | None, api_key: str | None) -> str:
+    try:
+        url    = f"{server}/playbooks?workspace_id={workspace_id}"
+        result = _api_get(url, token, api_key)
+        return json.dumps(result, indent=2)
+    except urllib.error.HTTPError as e:
+        return f"Error — HTTP {e.code}: {e.read().decode()[:200]}"
+    except Exception as e:
+        return f"Error — {e}"
+
+
+def _handle_run_workflow(
+    arguments: dict,
+    server: str,
+    workspace_id: str,
+    token: str | None,
+    api_key: str | None,
+) -> str:
+    workflow_id = arguments.get("workflow_id", "")
+    payload     = arguments.get("payload") or {}
+    if not workflow_id:
+        return "Error — workflow_id is required."
+    try:
+        url  = f"{server}/workflows/{workflow_id}/runs"
+        body = {"workspace_id": workspace_id, "payload": payload}
+        run  = _api_post(url, body, token, api_key)
+        return json.dumps({"run_id": run.get("id") or run.get("run_id"), "status": run.get("status")}, indent=2)
+    except urllib.error.HTTPError as e:
+        return f"Error — HTTP {e.code}: {e.read().decode()[:200]}"
+    except Exception as e:
+        return f"Error — {e}"
+
+
+def _handle_get_run(
+    arguments: dict,
+    server: str,
+    token: str | None,
+    api_key: str | None,
+) -> str:
+    workflow_id = arguments.get("workflow_id", "")
+    run_id      = arguments.get("run_id", "")
+    if not workflow_id or not run_id:
+        return "Error — workflow_id and run_id are both required."
+    try:
+        url = f"{server}/workflows/{workflow_id}/runs/{run_id}"
+        run = _api_get(url, token, api_key)
+        return json.dumps(
+            {
+                "status":       run.get("status"),
+                "outcome":      run.get("outcome"),
+                "started_at":   run.get("started_at"),
+                "completed_at": run.get("completed_at"),
+            },
+            indent=2,
+        )
+    except urllib.error.HTTPError as e:
+        return f"Error — HTTP {e.code}: {e.read().decode()[:200]}"
+    except Exception as e:
+        return f"Error — {e}"
+
+
+def _handle_guard_status(workspace_id: str) -> str:
+    cfg    = _load_guard_config()
+    policy = _load_guard_policy()
+    return json.dumps(
+        {
+            "workspace_id":   workspace_id,
+            "email":          cfg.get("user_email", ""),
+            "rules_active":   len(policy.get("rules", [])),
+            "policy_version": policy.get("version", ""),
+        },
+        indent=2,
+    )
+
+
+def _dispatch_tool(
+    name: str,
+    arguments: dict,
+    server: str,
+    workspace_id: str,
+    token: str | None,
+    api_key: str | None,
+) -> str:
+    if name == "conduct_list_agents":
+        return _handle_list_agents(server, workspace_id, token, api_key)
+    if name == "conduct_list_projects":
+        return _handle_list_projects(server, workspace_id, token, api_key)
+    if name == "conduct_list_playbooks":
+        return _handle_list_playbooks(server, workspace_id, token, api_key)
+    if name == "conduct_run_workflow":
+        return _handle_run_workflow(arguments, server, workspace_id, token, api_key)
+    if name == "conduct_get_run":
+        return _handle_get_run(arguments, server, token, api_key)
+    if name == "conduct_guard_status":
+        return _handle_guard_status(workspace_id)
+    return f"Unknown tool: {name}"
+
+
+# ── JSON-RPC helpers ───────────────────────────────────────────────────────────
+
+def _send(obj: dict) -> None:
+    print(json.dumps(obj), flush=True)
+
+
+def _ok(msg_id, result: dict) -> None:
+    _send({"jsonrpc": "2.0", "id": msg_id, "result": result})
+
+
+def _err(msg_id, code: int, message: str) -> None:
+    _send({"jsonrpc": "2.0", "id": msg_id, "error": {"code": code, "message": message}})
+
+
+# ── Main loop ──────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    cfg          = _load_conduct_config()
+    server       = cfg.get("server", "").rstrip("/")
+    workspace_id = cfg.get("workspace", "")
+    api_key      = cfg.get("api_key")
+    token        = cfg.get("token")
+
+    for raw in sys.stdin:
+        raw = raw.strip()
+        if not raw:
+            continue
+
+        try:
+            msg = json.loads(raw)
+        except json.JSONDecodeError:
+            continue
+
+        msg_id = msg.get("id")          # None for notifications
+        method = msg.get("method", "")
+        params = msg.get("params") or {}
+
+        if method == "initialize":
+            _ok(msg_id, {
+                "protocolVersion": PROTOCOL_VERSION,
+                "capabilities":    {"tools": {}},
+                "serverInfo":      {"name": "conduct", "version": "1.0.0"},
+            })
+
+        elif method == "notifications/initialized":
+            pass  # notification — no response
+
+        elif method == "tools/list":
+            _ok(msg_id, {"tools": _TOOLS})
+
+        elif method == "tools/call":
+            tool_name = params.get("name", "")
+            arguments = params.get("arguments") or {}
+            text      = _dispatch_tool(tool_name, arguments, server, workspace_id, token, api_key)
+            _ok(msg_id, {"content": [{"type": "text", "text": text}]})
+
+        elif method == "ping":
+            _ok(msg_id, {})
+
+        else:
+            if msg_id is not None:
+                _err(msg_id, -32601, f"Method not found: {method}")
+
+
+if __name__ == "__main__":
+    main()

{conduct_cli-0.4.27 → conduct_cli-0.4.28}/src/conduct_cli.egg-info/PKG-INFO

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

{conduct_cli-0.4.27 → conduct_cli-0.4.28}/src/conduct_cli.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/conduct_cli/api.py
 src/conduct_cli/guard.py
 src/conduct_cli/guardmcp.py
 src/conduct_cli/main.py
+src/conduct_cli/mcp_server.py
 src/conduct_cli.egg-info/PKG-INFO
 src/conduct_cli.egg-info/SOURCES.txt
 src/conduct_cli.egg-info/dependency_links.txt

{conduct_cli-0.4.27 → conduct_cli-0.4.28}/src/conduct_cli.egg-info/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
 conduct = conduct_cli.main:main
+conduct-mcp = conduct_cli.mcp_server:main
 conductguard-mcp = conduct_cli.guardmcp:main
 conductguard-post = conduct_cli.guard:post_usage_main