claude-team-mcp 0.3.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

claude_team_mcp/schemas/codex.py

@@ -0,0 +1,267 @@
+"""Codex CLI JSONL schema for parsing headless mode output.
+
+Schema derived from Codex rust-v0.77.0 (git 112f40e91c12af0f7146d7e03f20283516a8af0b).
+Ported from takopi/src/takopi/schemas/codex.py.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal, TypeAlias
+
+import msgspec
+
+# Status type aliases for various item types
+CommandExecutionStatus: TypeAlias = Literal[
+    "in_progress",
+    "completed",
+    "failed",
+    "declined",
+]
+
+PatchApplyStatus: TypeAlias = Literal[
+    "in_progress",
+    "completed",
+    "failed",
+]
+
+PatchChangeKind: TypeAlias = Literal[
+    "add",
+    "delete",
+    "update",
+]
+
+McpToolCallStatus: TypeAlias = Literal[
+    "in_progress",
+    "completed",
+    "failed",
+]
+
+
+# --- Core structs ---
+
+
+class Usage(msgspec.Struct, kw_only=True):
+    """Token usage statistics for a turn."""
+
+    input_tokens: int
+    cached_input_tokens: int
+    output_tokens: int
+
+
+class ThreadError(msgspec.Struct, kw_only=True):
+    """Error information for failed turns."""
+
+    message: str
+
+
+# --- Thread lifecycle events ---
+
+
+class ThreadStarted(msgspec.Struct, tag="thread.started", kw_only=True):
+    """Emitted when a new Codex thread begins. Contains thread_id for session tracking."""
+
+    thread_id: str
+
+
+class TurnStarted(msgspec.Struct, tag="turn.started", kw_only=True):
+    """Emitted when a new turn begins within a thread."""
+
+    pass
+
+
+class TurnCompleted(msgspec.Struct, tag="turn.completed", kw_only=True):
+    """Emitted when a turn completes successfully. Contains usage statistics."""
+
+    usage: Usage
+
+
+class TurnFailed(msgspec.Struct, tag="turn.failed", kw_only=True):
+    """Emitted when a turn fails. Contains error details."""
+
+    error: ThreadError
+
+
+class StreamError(msgspec.Struct, tag="error", kw_only=True):
+    """Emitted for stream-level errors (e.g., reconnection attempts)."""
+
+    message: str
+
+
+# --- Item types (tools, messages, etc.) ---
+
+
+class AgentMessageItem(msgspec.Struct, tag="agent_message", kw_only=True):
+    """Text message from the agent."""
+
+    id: str
+    text: str
+
+
+class ReasoningItem(msgspec.Struct, tag="reasoning", kw_only=True):
+    """Reasoning/thinking output from the agent."""
+
+    id: str
+    text: str
+
+
+class CommandExecutionItem(msgspec.Struct, tag="command_execution", kw_only=True):
+    """Shell command execution."""
+
+    id: str
+    command: str
+    aggregated_output: str
+    exit_code: int | None
+    status: CommandExecutionStatus
+
+
+class FileUpdateChange(msgspec.Struct, kw_only=True):
+    """A single file change within a patch."""
+
+    path: str
+    kind: PatchChangeKind
+
+
+class FileChangeItem(msgspec.Struct, tag="file_change", kw_only=True):
+    """File modification/patch operation."""
+
+    id: str
+    changes: list[FileUpdateChange]
+    status: PatchApplyStatus
+
+
+class McpToolCallItemResult(msgspec.Struct, kw_only=True):
+    """Result of an MCP tool call."""
+
+    content: list[dict[str, Any]]
+    structured_content: Any
+
+
+class McpToolCallItemError(msgspec.Struct, kw_only=True):
+    """Error from an MCP tool call."""
+
+    message: str
+
+
+class McpToolCallItem(msgspec.Struct, tag="mcp_tool_call", kw_only=True):
+    """MCP tool invocation."""
+
+    id: str
+    server: str
+    tool: str
+    arguments: Any
+    result: McpToolCallItemResult | None
+    error: McpToolCallItemError | None
+    status: McpToolCallStatus
+
+
+class WebSearchItem(msgspec.Struct, tag="web_search", kw_only=True):
+    """Web search operation."""
+
+    id: str
+    query: str
+
+
+class ErrorItem(msgspec.Struct, tag="error", kw_only=True):
+    """Error item (distinct from StreamError - this is an item in the thread)."""
+
+    id: str
+    message: str
+
+
+class TodoItem(msgspec.Struct, kw_only=True):
+    """A single todo item."""
+
+    text: str
+    completed: bool
+
+
+class TodoListItem(msgspec.Struct, tag="todo_list", kw_only=True):
+    """Todo list from the agent."""
+
+    id: str
+    items: list[TodoItem]
+
+
+# Union of all possible thread items
+ThreadItem: TypeAlias = (
+    AgentMessageItem
+    | ReasoningItem
+    | CommandExecutionItem
+    | FileChangeItem
+    | McpToolCallItem
+    | WebSearchItem
+    | TodoListItem
+    | ErrorItem
+)
+
+
+# --- Item lifecycle events ---
+
+
+class ItemStarted(msgspec.Struct, tag="item.started", kw_only=True):
+    """Emitted when an item (tool use, message, etc.) starts."""
+
+    item: ThreadItem
+
+
+class ItemUpdated(msgspec.Struct, tag="item.updated", kw_only=True):
+    """Emitted when an item is updated (streaming content)."""
+
+    item: ThreadItem
+
+
+class ItemCompleted(msgspec.Struct, tag="item.completed", kw_only=True):
+    """Emitted when an item finishes."""
+
+    item: ThreadItem
+
+
+# Union of all possible thread events
+ThreadEvent: TypeAlias = (
+    ThreadStarted
+    | TurnStarted
+    | TurnCompleted
+    | TurnFailed
+    | ItemStarted
+    | ItemUpdated
+    | ItemCompleted
+    | StreamError
+)
+
+# Pre-constructed decoder for efficient parsing
+_DECODER = msgspec.json.Decoder(ThreadEvent)
+
+
+def decode_event(data: bytes | str) -> ThreadEvent:
+    """Decode a single JSONL line into a ThreadEvent.
+
+    Args:
+        data: Raw JSON bytes or string from Codex JSONL output
+
+    Returns:
+        Parsed ThreadEvent (one of the union member types)
+
+    Raises:
+        msgspec.DecodeError: If the JSON is malformed or doesn't match schema
+    """
+    return _DECODER.decode(data)
+
+
+# --- Helper functions for common operations ---
+
+
+def is_turn_complete(event: ThreadEvent) -> bool:
+    """Check if the event indicates a turn has finished (success or failure)."""
+    return isinstance(event, (TurnCompleted, TurnFailed))
+
+
+def is_turn_successful(event: ThreadEvent) -> bool:
+    """Check if the event is a successful turn completion."""
+    return isinstance(event, TurnCompleted)
+
+
+def get_thread_id(event: ThreadEvent) -> str | None:
+    """Extract thread_id from a ThreadStarted event, or None for other events."""
+    if isinstance(event, ThreadStarted):
+        return event.thread_id
+    return None

claude_team_mcp/server.py

@@ -26,10 +26,17 @@ from .utils import error_response, HINTS
 
 # Configure logging
 logging.basicConfig(
-    level=logging.INFO,
+    level=logging.DEBUG,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
 )
 logger = logging.getLogger("claude-team-mcp")
+# Add file handler for debugging
+_fh = logging.FileHandler("/tmp/claude-team-debug.log")
+_fh.setLevel(logging.DEBUG)
+_fh.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+logger.addHandler(_fh)
+logging.getLogger().addHandler(_fh)  # Also capture root logger
+logger.info("=== Claude Team MCP Server Starting ===")
 
 
 # =============================================================================

claude_team_mcp/session_state.py

@@ -629,6 +629,220 @@ def parse_session(jsonl_path: Path) -> SessionState:
     )
 
 
+# =============================================================================
+# Codex Session Parsing
+# =============================================================================
+
+
+def parse_codex_session(jsonl_path: Path) -> SessionState:
+    """
+    Parse a Codex session JSONL file into a SessionState object.
+
+    Codex has a different JSONL format than Claude Code:
+    - Interactive mode uses event_msg and response_item wrappers
+    - Exec mode uses direct ThreadEvent types (item.completed, etc.)
+
+    Args:
+        jsonl_path: Path to the Codex JSONL file
+
+    Returns:
+        Parsed SessionState object with messages extracted
+    """
+    messages = []
+    session_id = jsonl_path.stem
+
+    try:
+        with open(jsonl_path, "r") as f:
+            for line_num, line in enumerate(f):
+                line = line.strip()
+                if not line:
+                    continue
+
+                try:
+                    data = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                msg = _parse_codex_event(data, line_num)
+                if msg:
+                    messages.append(msg)
+
+    except FileNotFoundError:
+        pass
+
+    return SessionState(
+        session_id=session_id,
+        project_path="",  # Codex doesn't have project path in the same way
+        jsonl_path=jsonl_path,
+        messages=messages,
+        last_modified=jsonl_path.stat().st_mtime if jsonl_path.exists() else 0,
+    )
+
+
+def _parse_codex_event(data: dict, line_num: int) -> Optional[Message]:
+    """
+    Parse a single Codex JSONL event into a Message if applicable.
+
+    Handles both interactive mode format (wrapped events) and exec mode format
+    (direct ThreadEvent types).
+
+    Args:
+        data: Parsed JSON dict from JSONL line
+        line_num: Line number for UUID generation
+
+    Returns:
+        Message object if this event represents a message, None otherwise
+    """
+    event_type = data.get("type", "")
+    now = datetime.now()
+
+    # Interactive mode: event_msg wrapper
+    if event_type == "event_msg":
+        payload = data.get("payload", {})
+        payload_type = payload.get("type")
+
+        if payload_type == "agent_message":
+            # Agent response message
+            text = payload.get("text", "")
+            if text:
+                return Message(
+                    uuid=payload.get("id", f"codex-{line_num}"),
+                    parent_uuid=None,
+                    role="assistant",
+                    content=text,
+                    timestamp=now,
+                )
+
+        elif payload_type == "user_message":
+            # User input message
+            text = payload.get("text", "")
+            if text:
+                return Message(
+                    uuid=payload.get("id", f"codex-user-{line_num}"),
+                    parent_uuid=None,
+                    role="user",
+                    content=text,
+                    timestamp=now,
+                )
+
+    # Interactive mode: response_item wrapper
+    elif event_type == "response_item":
+        payload = data.get("payload", {})
+        payload_type = payload.get("type")
+        role = payload.get("role", "")
+
+        if payload_type == "message":
+            # Extract content from the message
+            content_list = payload.get("content", [])
+            text_parts = []
+            for item in content_list:
+                if isinstance(item, dict) and item.get("type") == "output_text":
+                    text_parts.append(item.get("text", ""))
+                elif isinstance(item, dict) and item.get("type") == "input_text":
+                    text_parts.append(item.get("text", ""))
+                elif isinstance(item, dict) and item.get("type") == "text":
+                    text_parts.append(item.get("text", ""))
+
+            text = "".join(text_parts)
+            if text:
+                return Message(
+                    uuid=payload.get("id", f"codex-resp-{line_num}"),
+                    parent_uuid=None,
+                    role=role if role else "assistant",
+                    content=text,
+                    timestamp=now,
+                )
+
+        elif payload_type == "agent_message":
+            # Direct agent_message in payload
+            text = payload.get("text", "")
+            if text:
+                return Message(
+                    uuid=payload.get("id", f"codex-agent-{line_num}"),
+                    parent_uuid=None,
+                    role="assistant",
+                    content=text,
+                    timestamp=now,
+                )
+
+    # Exec mode: item.completed events
+    elif event_type == "item.completed":
+        item = data.get("item", {})
+        item_type = item.get("type")
+
+        if item_type == "agent_message":
+            text = item.get("text", "")
+            if text:
+                return Message(
+                    uuid=item.get("id", f"codex-exec-{line_num}"),
+                    parent_uuid=None,
+                    role="assistant",
+                    content=text,
+                    timestamp=now,
+                )
+
+        elif item_type == "reasoning":
+            # Reasoning/thinking block
+            text = item.get("text", "")
+            if text:
+                return Message(
+                    uuid=item.get("id", f"codex-think-{line_num}"),
+                    parent_uuid=None,
+                    role="assistant",
+                    content="",  # Put reasoning in thinking field instead
+                    timestamp=now,
+                    thinking=text,
+                )
+
+        elif item_type == "command_execution":
+            # Shell command execution
+            cmd = item.get("command", "")
+            output = item.get("aggregated_output", "")
+            exit_code = item.get("exit_code")
+            status = item.get("status", "")
+            if cmd:
+                content = f"Command: {cmd}\n"
+                if output:
+                    content += f"Output:\n{output}\n"
+                if exit_code is not None:
+                    content += f"Exit code: {exit_code}"
+                return Message(
+                    uuid=item.get("id", f"codex-cmd-{line_num}"),
+                    parent_uuid=None,
+                    role="assistant",
+                    content=content,
+                    timestamp=now,
+                    tool_uses=[{
+                        "name": "command_execution",
+                        "input": {"command": cmd, "status": status},
+                    }],
+                )
+
+        elif item_type == "file_change":
+            # File modification
+            changes = item.get("changes", [])
+            if changes:
+                change_lines = []
+                for c in changes:
+                    path = c.get("path", "")
+                    kind = c.get("kind", "")
+                    change_lines.append(f"  {kind}: {path}")
+                content = "File changes:\n" + "\n".join(change_lines)
+                return Message(
+                    uuid=item.get("id", f"codex-file-{line_num}"),
+                    parent_uuid=None,
+                    role="assistant",
+                    content=content,
+                    timestamp=now,
+                    tool_uses=[{
+                        "name": "file_change",
+                        "input": {"changes": changes},
+                    }],
+                )
+
+    return None
+
+
 # =============================================================================
 # Stop Hook Detection
 # =============================================================================

claude_team_mcp/tools/message_workers.py

@@ -19,13 +19,80 @@ from ..idle_detection import (
     wait_for_any_idle as wait_for_any_idle_impl,
     SessionInfo,
 )
-from ..iterm_utils import send_prompt
+from ..iterm_utils import send_prompt_for_agent
 from ..registry import SessionStatus
 from ..utils import error_response, HINTS, WORKER_MESSAGE_HINT
 
 logger = logging.getLogger("claude-team-mcp")
 
 
+async def _wait_for_sessions_idle(
+    sessions: list[tuple[str, object]],
+    mode: str,
+    timeout: float,
+    poll_interval: float = 2.0,
+) -> dict:
+    """
+    Wait for sessions to become idle using session.is_idle().
+
+    This unified waiting function works for both Claude and Codex sessions
+    by calling session.is_idle() which internally handles agent-specific
+    idle detection.
+
+    Args:
+        sessions: List of (session_id, ManagedSession) tuples
+        mode: "any" or "all"
+        timeout: Maximum seconds to wait
+        poll_interval: Seconds between checks
+
+    Returns:
+        Dict with idle_session_ids, all_idle, timed_out
+    """
+    import time
+
+    start = time.time()
+
+    while time.time() - start < timeout:
+        idle_sessions = []
+        working_sessions = []
+
+        for sid, session in sessions:
+            if session.is_idle():
+                idle_sessions.append(sid)
+            else:
+                working_sessions.append(sid)
+
+        if mode == "any" and idle_sessions:
+            return {
+                "idle_session_ids": idle_sessions,
+                "all_idle": len(working_sessions) == 0,
+                "timed_out": False,
+            }
+        elif mode == "all" and not working_sessions:
+            return {
+                "idle_session_ids": idle_sessions,
+                "all_idle": True,
+                "timed_out": False,
+            }
+
+        await asyncio.sleep(poll_interval)
+
+    # Timeout - return final state
+    idle_sessions = []
+    working_sessions = []
+    for sid, session in sessions:
+        if session.is_idle():
+            idle_sessions.append(sid)
+        else:
+            working_sessions.append(sid)
+
+    return {
+        "idle_session_ids": idle_sessions,
+        "all_idle": len(working_sessions) == 0,
+        "timed_out": True,
+    }
+
+
 def register_tools(mcp: FastMCP) -> None:
     """Register message_workers tool on the MCP server."""
 
@@ -123,8 +190,14 @@ def register_tools(mcp: FastMCP) -> None:
                 # Append hint about bd_help tool to help workers understand beads
                 message_with_hint = message + WORKER_MESSAGE_HINT
 
-                # Send the message to the terminal
-                await send_prompt(session.iterm_session, message_with_hint, submit=True)
+                # Send the message using agent-specific input handling.
+                # Codex needs a longer pre-Enter delay than Claude.
+                await send_prompt_for_agent(
+                    session.iterm_session,
+                    message_with_hint,
+                    agent_type=session.agent_type,
+                    submit=True,
+                )
 
                 return (sid, {
                     "success": True,
@@ -171,17 +244,38 @@ def register_tools(mcp: FastMCP) -> None:
             # appears idle from the previous stop hook, causing us to return prematurely.
             await asyncio.sleep(0.5)
 
-            # Get session infos for idle detection
-            session_infos = []
+            # Separate sessions by agent type for different idle detection methods
+            claude_sessions = []
+            codex_sessions = []
             for sid, session in valid_sessions:
-                jsonl_path = session.get_jsonl_path()
-                if jsonl_path:
-                    session_infos.append(SessionInfo(
-                        jsonl_path=jsonl_path,
-                        session_id=session.session_id,
-                    ))
-
-            if session_infos:
+                if session.agent_type == "codex":
+                    codex_sessions.append((sid, session))
+                else:
+                    # Claude sessions use JSONL-based SessionInfo
+                    jsonl_path = session.get_jsonl_path()
+                    if jsonl_path:
+                        claude_sessions.append((sid, session, jsonl_path))
+
+            # Build session infos for Claude sessions
+            session_infos = [
+                SessionInfo(jsonl_path=jsonl_path, session_id=sid)
+                for sid, session, jsonl_path in claude_sessions
+            ]
+
+            # For mixed sessions, use unified polling via session.is_idle()
+            if codex_sessions or not session_infos:
+                # Use session.is_idle() which handles both Claude and Codex
+                idle_result = await _wait_for_sessions_idle(
+                    sessions=[(sid, session) for sid, session in valid_sessions],
+                    mode=wait_mode,
+                    timeout=timeout,
+                    poll_interval=2.0,
+                )
+                result["idle_session_ids"] = idle_result.get("idle_session_ids", [])
+                result["all_idle"] = idle_result.get("all_idle", False)
+                result["timed_out"] = idle_result.get("timed_out", False)
+            elif session_infos:
+                # Pure Claude sessions - use optimized Claude-specific waiting
                 if wait_mode == "any":
                     idle_result = await wait_for_any_idle_impl(
                         sessions=session_infos,
@@ -205,9 +299,9 @@ def register_tools(mcp: FastMCP) -> None:
                     result["all_idle"] = idle_result.get("all_idle", False)
                     result["timed_out"] = idle_result.get("timed_out", False)
 
-                # Update status for idle sessions
-                for sid in result.get("idle_session_ids", []):
-                    registry.update_status(sid, SessionStatus.READY)
+            # Update status for idle sessions (applies to both paths)
+            for sid in result.get("idle_session_ids", []):
+                registry.update_status(sid, SessionStatus.READY)
         else:
             # No waiting - mark sessions as ready immediately
             for sid, session in valid_sessions: