aiagent-runner 0.1.3__py3-none-any.whl

aiagent_runner/coordinator_config.py

@@ -0,0 +1,203 @@
+# src/aiagent_runner/coordinator_config.py
+# Coordinator configuration management
+# Reference: docs/plan/PHASE4_COORDINATOR_ARCHITECTURE.md
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+@dataclass
+class AIProviderConfig:
+    """AI provider configuration."""
+    cli_command: str
+    cli_args: list[str] = field(default_factory=list)
+
+
+@dataclass
+class AgentConfig:
+    """Agent configuration (passkey only, other info from MCP)."""
+    passkey: str
+
+
+@dataclass
+class CoordinatorConfig:
+    """Coordinator configuration.
+
+    The Coordinator is a single orchestrator that:
+    1. Polls MCP server for active projects and their assigned agents
+    2. Calls get_agent_action(agent_id, project_id) for each pair
+    3. Spawns Agent Instances (Claude Code processes) as needed
+
+    Unlike the old Runner which was tied to a single (agent_id, project_id),
+    the Coordinator manages ALL agent-project combinations dynamically.
+
+    Multi-device operation:
+    - When root_agent_id is set, the Coordinator authenticates as that human agent
+    - This enables per-agent working directory resolution for remote operation
+    - See: docs/design/MULTI_DEVICE_IMPLEMENTATION_PLAN.md
+    """
+    # Polling settings
+    polling_interval: int = 10
+    max_concurrent: int = 3
+
+    # MCP connection (Unix socket or HTTP URL - used by both Coordinator and Agent Instances)
+    # Unix socket: ~/Library/Application Support/AIAgentPM/mcp.sock
+    # HTTP URL: http://hostname:port/mcp
+    mcp_socket_path: Optional[str] = None
+
+    # Phase 5: Coordinator token for Coordinator-only API authorization
+    # Reference: Sources/MCPServer/Authorization/ToolAuthorization.swift
+    coordinator_token: Optional[str] = None
+
+    # Multi-device: Root agent ID for authentication
+    # When set, Coordinator authenticates as this human agent to get proper working directories
+    root_agent_id: Optional[str] = None
+
+    # AI providers (how to launch each AI type)
+    ai_providers: dict[str, AIProviderConfig] = field(default_factory=dict)
+
+    # Agents (passkey only - ai_type, system_prompt come from MCP)
+    agents: dict[str, AgentConfig] = field(default_factory=dict)
+
+    # Logging
+    log_directory: Optional[str] = None
+
+    # Debug mode (adds --verbose to CLI commands)
+    debug_mode: bool = True
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if self.polling_interval <= 0:
+            raise ValueError("polling_interval must be positive")
+        if self.max_concurrent <= 0:
+            raise ValueError("max_concurrent must be positive")
+
+        # Set default MCP socket path if not specified
+        if self.mcp_socket_path is None:
+            self.mcp_socket_path = os.path.expanduser(
+                "~/Library/Application Support/AIAgentPM/mcp.sock"
+            )
+
+        # Phase 5: Set coordinator token from environment if not specified
+        if self.coordinator_token is None:
+            self.coordinator_token = os.environ.get("MCP_COORDINATOR_TOKEN")
+
+        # Ensure default Claude provider exists
+        if "claude" not in self.ai_providers:
+            self.ai_providers["claude"] = AIProviderConfig(
+                cli_command="claude",
+                cli_args=["--dangerously-skip-permissions"]
+            )
+
+    @classmethod
+    def from_yaml(cls, path: Path) -> "CoordinatorConfig":
+        """Load configuration from YAML file.
+
+        Example YAML:
+        ```yaml
+        polling_interval: 10
+        max_concurrent: 3
+
+        # MCP connection: Unix socket (local) or HTTP URL (remote)
+        # Local: ~/Library/Application Support/AIAgentPM/mcp.sock
+        # Remote: http://192.168.1.100:8080/mcp
+        mcp_socket_path: ~/Library/Application Support/AIAgentPM/mcp.sock
+
+        # Phase 5: Coordinator token for Coordinator-only API calls
+        # Can also be set via MCP_COORDINATOR_TOKEN environment variable
+        coordinator_token: ${MCP_COORDINATOR_TOKEN}
+
+        # Multi-device operation: Root agent for authentication
+        # When set, Coordinator authenticates as this human agent
+        # This enables per-agent working directory resolution
+        root_agent_id: human-frontend-lead
+
+        ai_providers:
+          claude:
+            cli_command: claude
+            cli_args: ["--dangerously-skip-permissions"]
+          gemini:
+            cli_command: gemini-cli
+            cli_args: ["--project", "my-project"]
+
+        agents:
+          agt_developer:
+            passkey: secret123
+          agt_reviewer:
+            passkey: secret456
+        ```
+
+        Args:
+            path: Path to YAML configuration file
+
+        Returns:
+            CoordinatorConfig instance
+        """
+        with open(path) as f:
+            data = yaml.safe_load(f)
+
+        # Parse AI providers
+        ai_providers = {}
+        for name, provider_data in data.get("ai_providers", {}).items():
+            cli_args = provider_data.get("cli_args", [])
+            if isinstance(cli_args, str):
+                cli_args = cli_args.split()
+            ai_providers[name] = AIProviderConfig(
+                cli_command=provider_data.get("cli_command", name),
+                cli_args=cli_args
+            )
+
+        # Parse agents
+        agents = {}
+        for agent_id, agent_data in data.get("agents", {}).items():
+            passkey = agent_data.get("passkey", "")
+            # Support environment variable expansion
+            if passkey.startswith("${") and passkey.endswith("}"):
+                env_var = passkey[2:-1]
+                passkey = os.environ.get(env_var, "")
+            agents[agent_id] = AgentConfig(passkey=passkey)
+
+        # Parse coordinator_token (supports environment variable expansion)
+        coordinator_token = data.get("coordinator_token")
+        if coordinator_token and coordinator_token.startswith("${") and coordinator_token.endswith("}"):
+            env_var = coordinator_token[2:-1]
+            coordinator_token = os.environ.get(env_var)
+
+        return cls(
+            polling_interval=data.get("polling_interval", 10),
+            max_concurrent=data.get("max_concurrent", 3),
+            mcp_socket_path=data.get("mcp_socket_path"),
+            coordinator_token=coordinator_token,
+            root_agent_id=data.get("root_agent_id"),
+            ai_providers=ai_providers,
+            agents=agents,
+            log_directory=data.get("log_directory"),
+            debug_mode=data.get("debug_mode", True),
+        )
+
+    def get_provider(self, ai_type: str) -> AIProviderConfig:
+        """Get AI provider configuration.
+
+        Args:
+            ai_type: AI type (e.g., "claude", "gemini")
+
+        Returns:
+            AIProviderConfig for the specified type, or default Claude config
+        """
+        return self.ai_providers.get(ai_type, self.ai_providers.get("claude"))
+
+    def get_agent_passkey(self, agent_id: str) -> Optional[str]:
+        """Get passkey for an agent.
+
+        Args:
+            agent_id: Agent ID
+
+        Returns:
+            Passkey if configured, None otherwise
+        """
+        agent = self.agents.get(agent_id)
+        return agent.passkey if agent else None

aiagent_runner/executor.py

@@ -0,0 +1,99 @@
+# src/aiagent_runner/executor.py
+# CLI executor for running AI assistants
+# Reference: docs/plan/PHASE3_PULL_ARCHITECTURE.md - Phase 3-5
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class ExecutionResult:
+    """Result of CLI execution."""
+    exit_code: int
+    duration_seconds: float
+    log_file: str
+
+
+class CLIExecutor:
+    """Executes CLI tools (claude, gemini, etc.) with prompts."""
+
+    def __init__(
+        self,
+        cli_command: str = "claude",
+        cli_args: Optional[list[str]] = None
+    ):
+        """Initialize CLI executor.
+
+        Args:
+            cli_command: CLI command to run (claude, gemini, etc.)
+            cli_args: Additional arguments for the CLI
+        """
+        self.cli_command = cli_command
+        self.cli_args = cli_args or ["--dangerously-skip-permissions"]
+
+    def execute(
+        self,
+        prompt: str,
+        working_directory: str,
+        log_file: str
+    ) -> ExecutionResult:
+        """Execute CLI with the given prompt.
+
+        Args:
+            prompt: Prompt string to pass to CLI
+            working_directory: Directory to run CLI in
+            log_file: Path to log file for output
+
+        Returns:
+            ExecutionResult with exit code, duration, and log path
+        """
+        # Ensure log directory exists
+        Path(log_file).parent.mkdir(parents=True, exist_ok=True)
+
+        # Build command
+        cmd = [self.cli_command] + self.cli_args + ["-p", prompt]
+
+        start_time = time.time()
+
+        try:
+            with open(log_file, "w") as log:
+                # Write prompt to log for reference
+                log.write(f"=== PROMPT ===\n{prompt}\n\n=== OUTPUT ===\n")
+                log.flush()
+
+                result = subprocess.run(
+                    cmd,
+                    cwd=working_directory,
+                    stdout=log,
+                    stderr=subprocess.STDOUT,
+                    text=True
+                )
+        except FileNotFoundError:
+            # CLI command not found
+            with open(log_file, "a") as log:
+                log.write(f"\nERROR: Command '{self.cli_command}' not found\n")
+            return ExecutionResult(
+                exit_code=127,
+                duration_seconds=time.time() - start_time,
+                log_file=log_file
+            )
+        except Exception as e:
+            # Other execution error
+            with open(log_file, "a") as log:
+                log.write(f"\nERROR: {e}\n")
+            return ExecutionResult(
+                exit_code=1,
+                duration_seconds=time.time() - start_time,
+                log_file=log_file
+            )
+
+        end_time = time.time()
+
+        return ExecutionResult(
+            exit_code=result.returncode,
+            duration_seconds=end_time - start_time,
+            log_file=log_file
+        )