claude-mpm 5.6.1__py3-none-any.whl → 5.6.76__py3-none-any.whl

claude_mpm/commander/persistence/state_store.py

@@ -10,8 +10,9 @@ import logging
 import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
+from ..frameworks.base import RegisteredInstance
 from ..models import Project, ProjectState, ToolSession
 from ..registry import ProjectRegistry
 
@@ -48,6 +49,7 @@ class StateStore:
 
         self.projects_path = self.state_dir / "projects.json"
         self.sessions_path = self.state_dir / "sessions.json"
+        self.instances_path = self.state_dir / "instances.json"
 
         logger.info(f"Initialized StateStore at {self.state_dir}")
 
@@ -307,3 +309,95 @@ class StateStore:
                 else None
             ),
         )
+
+    # Instance persistence methods
+
+    def save_instances(self, instances: Dict[str, RegisteredInstance]) -> None:
+        """Save registered instances to disk.
+
+        Args:
+            instances: Dict mapping instance name to RegisteredInstance
+
+        Raises:
+            IOError: If write fails
+        """
+        data = {
+            "version": self.VERSION,
+            "saved_at": datetime.now(timezone.utc).isoformat(),
+            "instances": {name: inst.to_dict() for name, inst in instances.items()},
+        }
+        self._atomic_write(self.instances_path, data)
+        logger.info(f"Saved {len(instances)} instances to {self.instances_path}")
+
+    def load_instances(self) -> Dict[str, RegisteredInstance]:
+        """Load registered instances from disk.
+
+        Returns:
+            Dict mapping instance name to RegisteredInstance
+            (empty if file missing or corrupt)
+        """
+        if not self.instances_path.exists():
+            logger.info("No instances file found, returning empty dict")
+            return {}
+
+        try:
+            data = self._read_json(self.instances_path)
+
+            if data.get("version") != self.VERSION:
+                logger.warning(
+                    f"Version mismatch: expected {self.VERSION}, "
+                    f"got {data.get('version')}"
+                )
+
+            instances = {
+                name: RegisteredInstance.from_dict(inst_data)
+                for name, inst_data in data.get("instances", {}).items()
+            }
+
+            logger.info(f"Loaded {len(instances)} instances from {self.instances_path}")
+            return instances
+
+        except Exception as e:
+            logger.error(f"Failed to load instances: {e}", exc_info=True)
+            return {}
+
+    def register_instance(self, instance: RegisteredInstance) -> None:
+        """Register a single instance (add to existing).
+
+        Args:
+            instance: RegisteredInstance to add
+        """
+        instances = self.load_instances()
+        instances[instance.name] = instance
+        self.save_instances(instances)
+        logger.info(f"Registered instance '{instance.name}'")
+
+    def unregister_instance(self, name: str) -> bool:
+        """Remove an instance registration.
+
+        Args:
+            name: Instance name to remove
+
+        Returns:
+            True if instance was found and removed, False if not found
+        """
+        instances = self.load_instances()
+        if name in instances:
+            del instances[name]
+            self.save_instances(instances)
+            logger.info(f"Unregistered instance '{name}'")
+            return True
+        logger.warning(f"Instance '{name}' not found for unregistration")
+        return False
+
+    def get_registered_instance(self, name: str) -> Optional[RegisteredInstance]:
+        """Get a single registered instance by name.
+
+        Args:
+            name: Instance name to look up
+
+        Returns:
+            RegisteredInstance if found, None otherwise
+        """
+        instances = self.load_instances()
+        return instances.get(name)

claude_mpm/commander/registry.py

@@ -42,15 +42,18 @@ class ProjectRegistry:
         self._lock = threading.RLock()
         logger.info("Initialized ProjectRegistry")
 
-    def register(self, path: str, name: Optional[str] = None) -> Project:
+    def register(
+        self, path: str, name: Optional[str] = None, project_id: Optional[str] = None
+    ) -> Project:
         """Register a new project.
 
-        Creates a new project with unique UUID and adds it to the registry.
+        Creates a new project with unique UUID (or user-provided ID) and adds it to registry.
         Path must be a valid directory and cannot already be registered.
 
         Args:
             path: Absolute filesystem path to project directory
             name: Optional human-readable name (defaults to directory name)
+            project_id: Optional project identifier (UUID generated if omitted)
 
         Returns:
             Newly created Project instance
@@ -92,8 +95,11 @@ class ProjectRegistry:
             if name is None:
                 name = path_obj.name
 
-            # Generate unique project ID
-            project_id = str(uuid.uuid4())
+            # Generate unique project ID if not provided
+            if project_id is None:
+                project_id = str(uuid.uuid4())
+            elif project_id in self._projects:
+                raise ValueError(f"Project ID already exists: {project_id}")
 
             # Create project instance
             project = Project(

claude_mpm/commander/runtime/monitor.py

@@ -6,13 +6,16 @@ and detects events using OutputParser.
 
 import asyncio
 import logging
-from typing import Dict, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
 
 from ..events.manager import EventManager
 from ..models.events import Event
 from ..parsing.output_parser import OutputParser
 from ..tmux_orchestrator import TmuxOrchestrator
 
+if TYPE_CHECKING:
+    from ..core.block_manager import BlockManager
+
 logger = logging.getLogger(__name__)
 
 
@@ -44,6 +47,7 @@ class RuntimeMonitor:
         event_manager: EventManager,
         poll_interval: float = 2.0,
         capture_lines: int = 1000,
+        block_manager: Optional["BlockManager"] = None,
     ):
         """Initialize runtime monitor.
 
@@ -53,6 +57,7 @@ class RuntimeMonitor:
             event_manager: EventManager for emitting events
             poll_interval: Seconds between polls (default: 2.0)
             capture_lines: Number of lines to capture (default: 1000)
+            block_manager: Optional BlockManager for automatic work blocking
 
         Raises:
             ValueError: If any required parameter is None
@@ -69,15 +74,17 @@ class RuntimeMonitor:
         self.event_manager = event_manager
         self.poll_interval = poll_interval
         self.capture_lines = capture_lines
+        self.block_manager = block_manager
 
         # Track active monitors: pane_target -> (project_id, task, last_output_hash)
         self._monitors: Dict[str, tuple[str, Optional[asyncio.Task], int]] = {}
         self._running = False
 
         logger.debug(
-            "RuntimeMonitor initialized (interval: %.2fs, lines: %d)",
+            "RuntimeMonitor initialized (interval: %.2fs, lines: %d, block_manager: %s)",
             poll_interval,
             capture_lines,
+            "enabled" if block_manager else "disabled",
         )
 
     async def start_monitoring(self, pane_target: str, project_id: str) -> None:
@@ -284,6 +291,29 @@ class RuntimeMonitor:
                         pane_target,
                     )
 
+                    # Automatically block work for blocking events
+                    if self.block_manager:
+                        for parse_result in parse_results:
+                            # Get the created event from EventManager
+                            # Events are created with matching titles, so find by title
+                            pending_events = self.event_manager.get_pending(project_id)
+                            for event in pending_events:
+                                if (
+                                    event.title == parse_result.title
+                                    and event.is_blocking
+                                ):
+                                    blocked_work = (
+                                        await self.block_manager.check_and_block(event)
+                                    )
+                                    if blocked_work:
+                                        logger.info(
+                                            "Event %s blocked %d work items: %s",
+                                            event.id,
+                                            len(blocked_work),
+                                            blocked_work,
+                                        )
+                                    break
+
             except Exception as e:
                 logger.error(
                     "Error in monitor loop for pane %s: %s",

claude_mpm/commander/tmux_orchestrator.py

@@ -158,10 +158,11 @@ class TmuxOrchestrator:
         """
         logger.info(f"Creating pane '{pane_id}' in {working_dir}")
 
-        # Split window to create new pane
+        # Create new window instead of splitting pane to avoid "no space for new pane" error
+        # when tmux window is too small to split
         self._run_tmux(
             [
-                "split-window",
+                "new-window",
                 "-t",
                 self.session_name,
                 "-c",

claude_mpm/commander/work/executor.py

@@ -51,16 +51,19 @@ class WorkExecutor:
 
         logger.debug(f"Initialized WorkExecutor for project {queue.project_id}")
 
-    async def execute_next(self) -> bool:
+    async def execute_next(self, pane_target: Optional[str] = None) -> bool:
         """Execute next available work item.
 
         Gets next work from queue, starts it, and executes via RuntimeExecutor.
 
+        Args:
+            pane_target: Optional tmux pane target for execution
+
         Returns:
             True if work was executed, False if queue empty/blocked
 
         Example:
-            >>> executed = await executor.execute_next()
+            >>> executed = await executor.execute_next("%5")
             >>> if not executed:
             ...     print("No work available")
         """
@@ -71,10 +74,12 @@ class WorkExecutor:
             return False
 
         # Execute the work item
-        await self.execute(work_item)
+        await self.execute(work_item, pane_target)
         return True
 
-    async def execute(self, work_item: WorkItem) -> None:
+    async def execute(
+        self, work_item: WorkItem, pane_target: Optional[str] = None
+    ) -> None:
         """Execute a specific work item.
 
         Marks work as IN_PROGRESS and sends to RuntimeExecutor.
@@ -83,12 +88,13 @@ class WorkExecutor:
 
         Args:
             work_item: WorkItem to execute
+            pane_target: Optional tmux pane target for execution
 
         Raises:
             RuntimeError: If execution fails
 
         Example:
-            >>> await executor.execute(work_item)
+            >>> await executor.execute(work_item, "%5")
         """
         # Mark as in progress
         if not self.queue.start(work_item.id):
@@ -103,17 +109,21 @@ class WorkExecutor:
         )
 
         try:
-            # Send work content to runtime
-            # Note: In actual implementation, this would integrate with
-            # ProjectSession which manages the pane_target
-            # For now, we assume runtime has active session
-            # This will be properly integrated when wiring with ProjectSession
+            # Send work content to runtime if pane target provided
+            if pane_target:
+                await self.runtime.send_message(pane_target, work_item.content)
+                logger.info(
+                    f"Work item {work_item.id} sent to pane {pane_target} for execution"
+                )
+            else:
+                logger.warning(
+                    f"No pane target provided for work item {work_item.id}, "
+                    f"work marked as in-progress but not sent to runtime"
+                )
 
             # Store work item ID in metadata for callback tracking
             work_item.metadata["execution_started"] = True
 
-            logger.info(f"Work item {work_item.id} sent to runtime for execution")
-
         except Exception as e:
             logger.error(f"Failed to execute work item {work_item.id}: {e}")
             await self.handle_failure(work_item.id, str(e))
@@ -155,7 +165,7 @@ class WorkExecutor:
         else:
             logger.warning(f"Failed to mark work item {work_id} as failed")
 
-    async def handle_block(self, work_id: str, reason: str) -> None:
+    async def handle_block(self, work_id: str, reason: str) -> bool:
         """Handle work being blocked by an event.
 
         Called when RuntimeMonitor detects a blocking event.
@@ -164,15 +174,19 @@ class WorkExecutor:
             work_id: Work item ID that is blocked
             reason: Reason for blocking (e.g., "Waiting for approval")
 
+        Returns:
+            True if work was successfully blocked, False otherwise
+
         Example:
-            >>> await executor.handle_block("work-123", "Decision needed")
+            >>> success = await executor.handle_block("work-123", "Decision needed")
         """
         if self.queue.block(work_id, reason):
             logger.info(f"Work item {work_id} blocked: {reason}")
-        else:
-            logger.warning(f"Failed to mark work item {work_id} as blocked")
+            return True
+        logger.warning(f"Failed to mark work item {work_id} as blocked")
+        return False
 
-    async def handle_unblock(self, work_id: str) -> None:
+    async def handle_unblock(self, work_id: str) -> bool:
         """Handle work being unblocked after event resolution.
 
         Called when EventHandler resolves a blocking event.
@@ -180,10 +194,14 @@ class WorkExecutor:
         Args:
             work_id: Work item ID to unblock
 
+        Returns:
+            True if work was successfully unblocked, False otherwise
+
         Example:
-            >>> await executor.handle_unblock("work-123")
+            >>> success = await executor.handle_unblock("work-123")
         """
         if self.queue.unblock(work_id):
             logger.info(f"Work item {work_id} unblocked, resuming execution")
-        else:
-            logger.warning(f"Failed to unblock work item {work_id}")
+            return True
+        logger.warning(f"Failed to unblock work item {work_id}")
+        return False

claude_mpm/commander/workflow/event_handler.py

@@ -5,12 +5,15 @@ user input and coordinates session pause/resume.
 """
 
 import logging
-from typing import Dict, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
 
 from ..inbox import Inbox
 from ..models.events import BLOCKING_EVENTS, Event, EventStatus
 from ..project_session import ProjectSession
 
+if TYPE_CHECKING:
+    from ..core.block_manager import BlockManager
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,13 +35,17 @@ class EventHandler:
     """
 
     def __init__(
-        self, inbox: Inbox, session_manager: Dict[str, ProjectSession]
+        self,
+        inbox: Inbox,
+        session_manager: Dict[str, ProjectSession],
+        block_manager: Optional["BlockManager"] = None,
     ) -> None:
         """Initialize event handler.
 
         Args:
             inbox: Inbox instance for event access
             session_manager: Dict mapping project_id -> ProjectSession
+            block_manager: Optional BlockManager for automatic work unblocking
 
         Raises:
             ValueError: If inbox or session_manager is None
@@ -51,8 +58,12 @@ class EventHandler:
         self.inbox = inbox
         self.session_manager = session_manager
         self._event_manager = inbox.events
+        self.block_manager = block_manager
 
-        logger.debug("EventHandler initialized")
+        logger.debug(
+            "EventHandler initialized (block_manager: %s)",
+            "enabled" if block_manager else "disabled",
+        )
 
     async def process_event(self, event: Event) -> None:
         """Process an event - pause session if blocking.
@@ -137,6 +148,17 @@ class EventHandler:
         # Mark event as resolved
         self._event_manager.respond(event_id, response)
 
+        # Automatically unblock work items if BlockManager is available
+        if self.block_manager and was_blocking:
+            unblocked_work = await self.block_manager.check_and_unblock(event_id)
+            if unblocked_work:
+                logger.info(
+                    "Event %s resolution unblocked %d work items: %s",
+                    event_id,
+                    len(unblocked_work),
+                    unblocked_work,
+                )
+
         # If event was NOT blocking, no need to resume
         if not was_blocking:
             logger.debug("Event %s was non-blocking, no resume needed", event_id)

claude_mpm/config/skill_sources.py

@@ -54,6 +54,7 @@ class SkillSource:
         branch: Git branch to use (default: "main")
         priority: Priority for skill resolution (lower = higher precedence)
         enabled: Whether this source should be synced
+        token: Optional GitHub token or env var reference (e.g., "$MY_TOKEN")
 
     Priority System:
         - 0: Reserved for system repository (highest precedence)
@@ -61,6 +62,12 @@ class SkillSource:
         - 100-999: Normal priority custom sources
         - 1000+: Low priority custom sources
 
+    Token Authentication:
+        - Direct token: "ghp_xxxxx" (stored in config, not recommended)
+        - Env var reference: "$PRIVATE_REPO_TOKEN" (resolved at runtime)
+        - If None, falls back to GITHUB_TOKEN or GH_TOKEN env vars
+        - Priority: source.token > GITHUB_TOKEN > GH_TOKEN
+
     Example:
         >>> source = SkillSource(
         ...     id="system",
@@ -70,6 +77,12 @@ class SkillSource:
         ... )
         >>> source.validate()
         []
+        >>> private_source = SkillSource(
+        ...     id="private",
+        ...     type="git",
+        ...     url="https://github.com/myorg/private-skills",
+        ...     token="$PRIVATE_REPO_TOKEN"
+        ... )
     """
 
     id: str
@@ -78,6 +91,7 @@ class SkillSource:
     branch: str = "main"
     priority: int = 100
     enabled: bool = True
+    token: Optional[str] = None
 
     def __post_init__(self):
         """Validate skill source configuration after initialization.
@@ -262,6 +276,7 @@ class SkillSourceConfiguration:
                         branch=source_data.get("branch", "main"),
                         priority=source_data.get("priority", 100),
                         enabled=source_data.get("enabled", True),
+                        token=source_data.get("token"),
                     )
                     sources.append(source)
                 except (KeyError, ValueError) as e:
@@ -326,6 +341,7 @@ class SkillSourceConfiguration:
                     "branch": source.branch,
                     "priority": source.priority,
                     "enabled": source.enabled,
+                    **({"token": source.token} if source.token else {}),
                 }
                 for source in sources
             ]

claude_mpm/constants.py

@@ -46,6 +46,7 @@ class CLICommands(str, Enum):
     DASHBOARD = "dashboard"
     UPGRADE = "upgrade"
     SKILLS = "skills"
+    OAUTH = "oauth"
 
     def with_prefix(self, prefix: CLIPrefix = CLIPrefix.MPM) -> str:
         """Get command with prefix."""
@@ -143,6 +144,10 @@ class MCPCommands(str, Enum):
     CONFIG = "config"
     SERVER = "server"
     EXTERNAL = "external"
+    # Service management commands
+    ENABLE = "enable"
+    DISABLE = "disable"
+    LIST = "list"
 
 
 class TicketCommands(str, Enum):