claude-team-mcp 0.6.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

claude_team_mcp/issue_tracker/__init__.py

@@ -9,10 +9,16 @@ from __future__ import annotations
 import logging
 import os
 from dataclasses import dataclass, field
-from typing import Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from claude_team_mcp.config import ClaudeTeamConfig
 
 logger = logging.getLogger("claude-team-mcp")
 
+# Environment variable for explicit tracker override (highest priority).
+ISSUE_TRACKER_ENV_VAR = "CLAUDE_TEAM_ISSUE_TRACKER"
+
 
 @runtime_checkable
 class IssueTrackerBackend(Protocol):
@@ -86,16 +92,74 @@ BACKEND_REGISTRY: dict[str, IssueTrackerBackend] = {
 }
 
 
-def detect_issue_tracker(project_path: str) -> IssueTrackerBackend | None:
+def detect_issue_tracker(
+    project_path: str,
+    config: ClaudeTeamConfig | None = None,
+) -> IssueTrackerBackend | None:
     """
     Detect the issue tracker backend for the given project path.
 
+    Resolution order (highest to lowest priority):
+      1. CLAUDE_TEAM_ISSUE_TRACKER environment variable
+      2. config.issue_tracker.override setting
+      3. Marker directory detection (.pebbles, .beads)
+
     Args:
         project_path: Absolute or relative path to the project root.
+        config: Optional config object. If None, config is loaded from disk.
 
     Returns:
-        The detected IssueTrackerBackend, or None if no markers are present.
+        The detected IssueTrackerBackend, or None if no tracker is configured
+        or detected.
     """
+    # Priority 1: Environment variable override.
+    env_override = os.environ.get(ISSUE_TRACKER_ENV_VAR)
+    if env_override:
+        backend = BACKEND_REGISTRY.get(env_override.lower())
+        if backend:
+            logger.debug(
+                "Using issue tracker '%s' from %s env var",
+                backend.name,
+                ISSUE_TRACKER_ENV_VAR,
+            )
+            return backend
+        logger.warning(
+            "Unknown issue tracker '%s' in %s; ignoring",
+            env_override,
+            ISSUE_TRACKER_ENV_VAR,
+        )
+
+    # Priority 2: Config file override.
+    if config is None:
+        # Lazy import to avoid circular dependency at module load time.
+        try:
+            from claude_team_mcp.config import ConfigError, load_config
+
+            config = load_config()
+        except ConfigError as exc:
+            logger.warning("Invalid config file; ignoring overrides: %s", exc)
+            config = None
+
+    if config and config.issue_tracker.override:
+        backend = BACKEND_REGISTRY.get(config.issue_tracker.override)
+        if backend:
+            logger.debug(
+                "Using issue tracker '%s' from config override",
+                backend.name,
+            )
+            return backend
+        # Config validation should prevent this, but handle gracefully.
+        logger.warning(
+            "Unknown issue tracker '%s' in config; ignoring",
+            config.issue_tracker.override,
+        )
+
+    # Priority 3: Marker directory detection.
+    return _detect_from_markers(project_path)
+
+
+def _detect_from_markers(project_path: str) -> IssueTrackerBackend | None:
+    """Detect issue tracker by checking for marker directories."""
     beads_marker = os.path.join(project_path, BEADS_BACKEND.marker_dir)
     pebbles_marker = os.path.join(project_path, PEBBLES_BACKEND.marker_dir)
 
@@ -128,5 +192,6 @@ __all__ = [
     "BEADS_BACKEND",
     "PEBBLES_BACKEND",
     "BACKEND_REGISTRY",
+    "ISSUE_TRACKER_ENV_VAR",
     "detect_issue_tracker",
 ]

claude_team_mcp/iterm_utils.py

@@ -705,75 +705,6 @@ async def start_agent_in_session(
         )
 
 
-async def start_claude_in_session(
-    session: "ItermSession",
-    project_path: str,
-    dangerously_skip_permissions: bool = False,
-    env: Optional[dict[str, str]] = None,
-    shell_ready_timeout: float = 10.0,
-    claude_ready_timeout: float = 30.0,
-    stop_hook_marker_id: Optional[str] = None,
-) -> None:
-    """
-    Start Claude Code in an existing iTerm2 session.
-
-    Convenience wrapper around start_agent_in_session() for Claude.
-    Changes to the project directory and launches Claude Code in a single
-    atomic command (cd && claude). Waits for shell readiness before sending
-    the command, then waits for Claude's startup banner to appear.
-
-    The command used to launch Claude Code can be overridden by setting
-    the CLAUDE_TEAM_COMMAND environment variable (defaults to "claude").
-    This is useful for running alternative Claude CLI implementations
-    like "happy" or for testing purposes.
-
-    Args:
-        session: iTerm2 session to use
-        project_path: Directory to run Claude in
-        dangerously_skip_permissions: If True, start with --dangerously-skip-permissions
-        env: Optional dict of environment variables to set before running claude
-        shell_ready_timeout: Max seconds to wait for shell prompt
-        claude_ready_timeout: Max seconds to wait for Claude to start and show banner
-        stop_hook_marker_id: If provided, inject a Stop hook that logs this marker
-            to the JSONL for completion detection
-
-    Raises:
-        RuntimeError: If shell not ready or Claude fails to start within timeout
-    """
-    from .cli_backends import claude_cli
-
-    await start_agent_in_session(
-        session=session,
-        cli=claude_cli,
-        project_path=project_path,
-        dangerously_skip_permissions=dangerously_skip_permissions,
-        env=env,
-        shell_ready_timeout=shell_ready_timeout,
-        agent_ready_timeout=claude_ready_timeout,
-        stop_hook_marker_id=stop_hook_marker_id,
-    )
-
-
-# Legacy alias for backward compatibility with Claude-specific code
-# that checks for banner patterns. Uses wait_for_agent_ready with claude_cli.
-async def _wait_for_claude_ready_via_agent(
-    session: "ItermSession",
-    timeout_seconds: float = 15.0,
-    poll_interval: float = 0.2,
-    stable_count: int = 2,
-) -> bool:
-    """Internal helper - uses wait_for_agent_ready with Claude CLI."""
-    from .cli_backends import claude_cli
-
-    return await wait_for_agent_ready(
-        session=session,
-        cli=claude_cli,
-        timeout_seconds=timeout_seconds,
-        poll_interval=poll_interval,
-        stable_count=stable_count,
-    )
-
-
 # =============================================================================
 # Multi-Pane Layouts
 # =============================================================================
@@ -983,15 +914,17 @@ async def create_multi_claude_layout(
         profile_customizations=profile_customizations,
     )
 
+    from .cli_backends import claude_cli
+
     # Start Claude in all panes in parallel.
-    # Each start_claude_in_session call uses wait_for_shell_ready() internally
-    # which provides proper readiness detection, so no sleeps between starts needed.
+    # start_agent_in_session uses wait_for_shell_ready() internally, so no sleeps needed.
     async def start_claude_for_pane(pane_name: str, project_path: str) -> None:
         session = panes[pane_name]
         pane_env = project_envs.get(pane_name) if project_envs else None
         marker_id = pane_marker_ids.get(pane_name) if pane_marker_ids else None
-        await start_claude_in_session(
+        await start_agent_in_session(
             session=session,
+            cli=claude_cli,
             project_path=project_path,
             dangerously_skip_permissions=skip_permissions,
             env=pane_env,
@@ -1116,4 +1049,3 @@ async def get_window_for_session(
                     return window
     return None
 
-

claude_team_mcp/registry.py

@@ -2,7 +2,7 @@
 Session Registry for Claude Team MCP
 
 Tracks all spawned Claude Code sessions, maintaining the mapping between
-our session IDs, iTerm2 session objects, and Claude JSONL session IDs.
+our session IDs, terminal session handles, and Claude JSONL session IDs.
 """
 
 import uuid
@@ -10,12 +10,14 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import TYPE_CHECKING, Literal, Optional
+from typing import Literal, Optional
 
-if TYPE_CHECKING:
-    from iterm2.session import Session as ItermSession
-
-from .session_state import get_project_dir, parse_session
+from .session_state import (
+    find_codex_session_by_internal_id,
+    get_project_dir,
+    parse_session,
+)
+from .terminal_backends import TerminalSession
 
 # Type alias for supported agent types
 AgentType = Literal["claude", "codex"]
@@ -31,16 +33,16 @@ class TerminalId:
     tools to accept terminal IDs directly for recovery scenarios.
 
     Attributes:
-        terminal_type: Terminal emulator type ("iterm", "zed", "vscode", etc.)
+        backend_id: Terminal backend identifier ("iterm", "tmux", "zed", etc.)
         native_id: Terminal's native session ID (e.g., iTerm's UUID)
     """
 
-    terminal_type: str
+    backend_id: str
     native_id: str
 
     def __str__(self) -> str:
         """For display: 'iterm:DB29DB03-...'"""
-        return f"{self.terminal_type}:{self.native_id}"
+        return f"{self.backend_id}:{self.native_id}"
 
     @classmethod
     def from_string(cls, s: str) -> "TerminalId":
@@ -50,9 +52,8 @@ class TerminalId:
         Falls back to treating bare IDs as iTerm for backwards compatibility.
         """
         if ":" in s:
-            terminal_type, native_id = s.split(":", 1)
-            return cls(terminal_type, native_id)
-        # Assume bare ID is iTerm for backwards compatibility
+            backend_id, native_id = s.split(":", 1)
+            return cls(backend_id, native_id)
         return cls("iterm", s)
 
 
@@ -69,12 +70,12 @@ class ManagedSession:
     """
     Represents a spawned Claude Code session.
 
-    Tracks the iTerm2 session object, project path, and Claude session ID
+    Tracks terminal session metadata, project path, and Claude session ID
     discovered from the JSONL file.
     """
 
     session_id: str  # Our assigned ID (e.g., "worker-1")
-    iterm_session: "ItermSession"
+    terminal_session: TerminalSession
     project_path: str
     claude_session_id: Optional[str] = None  # Discovered from JSONL
     name: Optional[str] = None  # Optional friendly name
@@ -87,16 +88,19 @@ class ManagedSession:
     worktree_path: Optional[Path] = None  # Path to worker's git worktree if any
     main_repo_path: Optional[Path] = None  # Path to main git repo (for worktree cleanup)
 
-    # Terminal-agnostic identifier (auto-populated from iterm_session if not set)
+    # Terminal-agnostic identifier (auto-populated from terminal_session if not set)
     terminal_id: Optional[TerminalId] = None
 
     # Agent type: "claude" (default) or "codex"
     agent_type: AgentType = "claude"
 
     def __post_init__(self):
-        """Auto-populate terminal_id from iterm_session if not set."""
-        if self.terminal_id is None and self.iterm_session is not None:
-            self.terminal_id = TerminalId("iterm", self.iterm_session.session_id)
+        """Auto-populate terminal_id from terminal_session if not set."""
+        if self.terminal_id is None:
+            self.terminal_id = TerminalId(
+                self.terminal_session.backend_id,
+                self.terminal_session.native_id,
+            )
 
     def to_dict(self) -> dict:
         """Convert to dictionary for MCP tool responses."""
@@ -148,15 +152,21 @@ class ManagedSession:
         Get the path to this session's JSONL file.
 
         For Claude workers: uses marker-based discovery in ~/.claude/projects/.
-        For Codex workers: searches ~/.codex/sessions/ for matching session files.
+        For Codex workers: uses marker-based discovery in ~/.codex/sessions/.
 
         Returns:
             Path object, or None if session cannot be discovered
         """
         if self.agent_type == "codex":
-            # For Codex, search the sessions directory
             from .idle_detection import find_codex_session_file
 
+            # Prefer marker-based match, fall back to most recent for legacy sessions.
+            match = find_codex_session_by_internal_id(
+                self.session_id,
+                max_age_seconds=600,
+            )
+            if match:
+                return match.jsonl_path
             return find_codex_session_file(max_age_seconds=600)
         else:
             # For Claude, use marker-based discovery
@@ -205,8 +215,14 @@ class ManagedSession:
         if self.agent_type == "codex":
             from .idle_detection import find_codex_session_file, is_codex_idle
 
-            # Find the session file (will be discovered from ~/.codex/sessions/)
-            session_file = find_codex_session_file(max_age_seconds=600)
+            # Prefer marker-based match, fall back to most recent for legacy sessions.
+            match = find_codex_session_by_internal_id(
+                self.session_id,
+                max_age_seconds=600,
+            )
+            session_file = match.jsonl_path if match else None
+            if not session_file:
+                session_file = find_codex_session_file(max_age_seconds=600)
             if not session_file:
                 return False
             return is_codex_idle(session_file)
@@ -269,7 +285,7 @@ class SessionRegistry:
 
     def add(
         self,
-        iterm_session: "ItermSession",
+        terminal_session: TerminalSession,
         project_path: str,
         name: Optional[str] = None,
         session_id: Optional[str] = None,
@@ -278,7 +294,7 @@ class SessionRegistry:
         Add a new session to the registry.
 
         Args:
-            iterm_session: iTerm2 session object
+            terminal_session: Backend-agnostic terminal session handle
             project_path: Directory where Claude is running
             name: Optional friendly name
             session_id: Optional specific ID (auto-generated if not provided)
@@ -291,7 +307,7 @@ class SessionRegistry:
 
         session = ManagedSession(
             session_id=session_id,
-            iterm_session=iterm_session,
+            terminal_session=terminal_session,
             project_path=project_path,
             name=name,
         )
@@ -331,7 +347,8 @@ class SessionRegistry:
 
         Lookup order (most specific first):
         1. Internal session_id (e.g., "d875b833")
-        2. Terminal native ID (e.g., "DB29DB03-AA52-4FBF-879A-4DA2C5F9F823")
+        2. Terminal ID with backend prefix (e.g., "iterm:DB29DB03-..."),
+           or a bare iTerm ID for backwards compatibility
         3. Session name
 
         After MCP restart, internal IDs are lost until import. This method