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

claude_mpm/commander/api/routes/messages.py

@@ -7,7 +7,7 @@ conversation threads for projects.
 import uuid
 from typing import List
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Request
 
 from ...models import ThreadMessage
 from ..errors import ProjectNotFoundError
@@ -16,13 +16,11 @@ from ..schemas import MessageResponse, SendMessageRequest
 router = APIRouter()
 
 
-def _get_registry():
-    """Get registry instance from app global."""
-    from ..app import registry
-
-    if registry is None:
+def _get_registry(request: Request):
+    """Get registry instance from app.state."""
+    if not hasattr(request.app.state, "registry") or request.app.state.registry is None:
         raise RuntimeError("Registry not initialized")
-    return registry
+    return request.app.state.registry
 
 
 def _message_to_response(message: ThreadMessage) -> MessageResponse:
@@ -44,7 +42,7 @@ def _message_to_response(message: ThreadMessage) -> MessageResponse:
 
 
 @router.get("/projects/{project_id}/thread", response_model=List[MessageResponse])
-async def get_thread(project_id: str) -> List[MessageResponse]:
+async def get_thread(request: Request, project_id: str) -> List[MessageResponse]:
     """Get conversation thread for a project.
 
     Returns all messages in chronological order.
@@ -77,7 +75,7 @@ async def get_thread(project_id: str) -> List[MessageResponse]:
             }
         ]
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:
@@ -90,7 +88,9 @@ async def get_thread(project_id: str) -> List[MessageResponse]:
 @router.post(
     "/projects/{project_id}/messages", response_model=MessageResponse, status_code=201
 )
-async def send_message(project_id: str, req: SendMessageRequest) -> MessageResponse:
+async def send_message(
+    request: Request, project_id: str, req: SendMessageRequest
+) -> MessageResponse:
     """Send a message to a project's active session.
 
     Adds message to conversation thread and sends to specified or active session.
@@ -119,7 +119,7 @@ async def send_message(project_id: str, req: SendMessageRequest) -> MessageRespo
             "timestamp": "2025-01-12T10:00:00Z"
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:

claude_mpm/commander/api/routes/projects.py

@@ -7,7 +7,7 @@ projects in the MPM Commander.
 from pathlib import Path
 from typing import List
 
-from fastapi import APIRouter, Response
+from fastapi import APIRouter, Request, Response
 
 from ...models import ProjectState
 from ..errors import InvalidPathError, ProjectAlreadyExistsError, ProjectNotFoundError
@@ -16,13 +16,11 @@ from ..schemas import ProjectResponse, RegisterProjectRequest, SessionResponse
 router = APIRouter()
 
 
-def _get_registry():
-    """Get registry instance from app global."""
-    from ..app import registry
-
-    if registry is None:
+def _get_registry(request: Request):
+    """Get registry instance from app.state."""
+    if not hasattr(request.app.state, "registry") or request.app.state.registry is None:
         raise RuntimeError("Registry not initialized")
-    return registry
+    return request.app.state.registry
 
 
 def _project_to_response(project) -> ProjectResponse:
@@ -61,7 +59,7 @@ def _project_to_response(project) -> ProjectResponse:
 
 
 @router.get("/projects", response_model=List[ProjectResponse])
-async def list_projects() -> List[ProjectResponse]:
+async def list_projects(request: Request) -> List[ProjectResponse]:
     """List all registered projects.
 
     Returns:
@@ -83,13 +81,13 @@ async def list_projects() -> List[ProjectResponse]:
             }
         ]
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     projects = registry.list_all()
     return [_project_to_response(p) for p in projects]
 
 
 @router.get("/projects/{project_id}", response_model=ProjectResponse)
-async def get_project(project_id: str) -> ProjectResponse:
+async def get_project(request: Request, project_id: str) -> ProjectResponse:
     """Get project details by ID.
 
     Args:
@@ -111,7 +109,7 @@ async def get_project(project_id: str) -> ProjectResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:
@@ -121,7 +119,9 @@ async def get_project(project_id: str) -> ProjectResponse:
 
 
 @router.post("/projects", response_model=ProjectResponse, status_code=201)
-async def register_project(req: RegisterProjectRequest) -> ProjectResponse:
+async def register_project(
+    request: Request, req: RegisterProjectRequest
+) -> ProjectResponse:
     """Register a new project.
 
     Args:
@@ -148,7 +148,7 @@ async def register_project(req: RegisterProjectRequest) -> ProjectResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
 
     # Validate path exists and is directory
     path_obj = Path(req.path)
@@ -156,7 +156,7 @@ async def register_project(req: RegisterProjectRequest) -> ProjectResponse:
         raise InvalidPathError(req.path)
 
     try:
-        project = registry.register(req.path, req.name)
+        project = registry.register(req.path, req.name, req.project_id)
         return _project_to_response(project)
     except ValueError as e:
         # Registry raises ValueError for duplicate registration
@@ -168,7 +168,7 @@ async def register_project(req: RegisterProjectRequest) -> ProjectResponse:
 
 
 @router.delete("/projects/{project_id}", status_code=204)
-async def unregister_project(project_id: str) -> Response:
+async def unregister_project(request: Request, project_id: str) -> Response:
     """Unregister a project.
 
     Args:
@@ -184,7 +184,7 @@ async def unregister_project(project_id: str) -> Response:
         DELETE /api/projects/abc-123
         Response: 204 No Content
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
 
     try:
         registry.unregister(project_id)
@@ -194,7 +194,7 @@ async def unregister_project(project_id: str) -> Response:
 
 
 @router.post("/projects/{project_id}/pause", response_model=ProjectResponse)
-async def pause_project(project_id: str) -> ProjectResponse:
+async def pause_project(request: Request, project_id: str) -> ProjectResponse:
     """Pause a project.
 
     Sets project state to PAUSED to prevent automatic work processing.
@@ -217,7 +217,7 @@ async def pause_project(project_id: str) -> ProjectResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:
@@ -233,7 +233,7 @@ async def pause_project(project_id: str) -> ProjectResponse:
 
 
 @router.post("/projects/{project_id}/resume", response_model=ProjectResponse)
-async def resume_project(project_id: str) -> ProjectResponse:
+async def resume_project(request: Request, project_id: str) -> ProjectResponse:
     """Resume a paused project.
 
     Sets project state back to IDLE to allow work processing.
@@ -256,7 +256,7 @@ async def resume_project(project_id: str) -> ProjectResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:

claude_mpm/commander/api/routes/sessions.py

@@ -5,13 +5,19 @@ This module implements REST endpoints for creating and managing tool sessions
 """
 
 import logging
+import subprocess  # nosec B404 - needed for tmux error handling
 import uuid
 from typing import List
 
-from fastapi import APIRouter, Response
+from fastapi import APIRouter, Request, Response
 
 from ...models import ToolSession
-from ..errors import InvalidRuntimeError, ProjectNotFoundError, SessionNotFoundError
+from ..errors import (
+    InvalidRuntimeError,
+    ProjectNotFoundError,
+    SessionNotFoundError,
+    TmuxNoSpaceError,
+)
 from ..schemas import CreateSessionRequest, SessionResponse
 
 router = APIRouter()
@@ -21,22 +27,18 @@ logger = logging.getLogger(__name__)
 VALID_RUNTIMES = {"claude-code"}
 
 
-def _get_registry():
-    """Get registry instance from app global."""
-    from ..app import registry
-
-    if registry is None:
+def _get_registry(request: Request):
+    """Get registry instance from app.state."""
+    if not hasattr(request.app.state, "registry") or request.app.state.registry is None:
         raise RuntimeError("Registry not initialized")
-    return registry
-
+    return request.app.state.registry
 
-def _get_tmux():
-    """Get tmux orchestrator instance from app global."""
-    from ..app import tmux
 
-    if tmux is None:
+def _get_tmux(request: Request):
+    """Get tmux orchestrator instance from app.state."""
+    if not hasattr(request.app.state, "tmux") or request.app.state.tmux is None:
         raise RuntimeError("Tmux orchestrator not initialized")
-    return tmux
+    return request.app.state.tmux
 
 
 def _session_to_response(session: ToolSession) -> SessionResponse:
@@ -59,7 +61,7 @@ def _session_to_response(session: ToolSession) -> SessionResponse:
 
 
 @router.get("/projects/{project_id}/sessions", response_model=List[SessionResponse])
-async def list_sessions(project_id: str) -> List[SessionResponse]:
+async def list_sessions(request: Request, project_id: str) -> List[SessionResponse]:
     """List all sessions for a project.
 
     Args:
@@ -84,7 +86,7 @@ async def list_sessions(project_id: str) -> List[SessionResponse]:
             }
         ]
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:
@@ -97,7 +99,9 @@ async def list_sessions(project_id: str) -> List[SessionResponse]:
 @router.post(
     "/projects/{project_id}/sessions", response_model=SessionResponse, status_code=201
 )
-async def create_session(project_id: str, req: CreateSessionRequest) -> SessionResponse:
+async def create_session(
+    request: Request, project_id: str, req: CreateSessionRequest
+) -> SessionResponse:
     """Create a new session for a project.
 
     Creates a new tmux pane and initializes the specified runtime adapter.
@@ -112,6 +116,7 @@ async def create_session(project_id: str, req: CreateSessionRequest) -> SessionR
     Raises:
         ProjectNotFoundError: If project_id doesn't exist
         InvalidRuntimeError: If runtime is not supported
+        TmuxNoSpaceError: If tmux has no space for new pane
 
     Example:
         POST /api/projects/abc-123/sessions
@@ -128,8 +133,8 @@ async def create_session(project_id: str, req: CreateSessionRequest) -> SessionR
             "created_at": "2025-01-12T10:00:00Z"
         }
     """
-    registry = _get_registry()
-    tmux_orch = _get_tmux()
+    registry = _get_registry(request)
+    tmux_orch = _get_tmux(request)
 
     # Validate project exists
     project = registry.get(project_id)
@@ -144,10 +149,16 @@ async def create_session(project_id: str, req: CreateSessionRequest) -> SessionR
     session_id = str(uuid.uuid4())
 
     # Create tmux pane for session
-    tmux_target = tmux_orch.create_pane(
-        pane_id=f"{project.name}-{req.runtime}",
-        working_dir=project.path,
-    )
+    try:
+        tmux_target = tmux_orch.create_pane(
+            pane_id=f"{project.name}-{req.runtime}",
+            working_dir=project.path,
+        )
+    except subprocess.CalledProcessError as e:
+        stderr = e.stderr.decode() if e.stderr else ""
+        if "no space for new pane" in stderr.lower():
+            raise TmuxNoSpaceError() from None
+        raise  # Re-raise other subprocess errors
 
     # Create session object
     session = ToolSession(
@@ -168,7 +179,7 @@ async def create_session(project_id: str, req: CreateSessionRequest) -> SessionR
 
 
 @router.delete("/sessions/{session_id}", status_code=204)
-async def stop_session(session_id: str) -> Response:
+async def stop_session(request: Request, session_id: str) -> Response:
     """Stop and remove a session.
 
     Kills the tmux pane and removes the session from its project.
@@ -186,8 +197,8 @@ async def stop_session(session_id: str) -> Response:
         DELETE /api/sessions/sess-456
         Response: 204 No Content
     """
-    registry = _get_registry()
-    tmux_orch = _get_tmux()
+    registry = _get_registry(request)
+    tmux_orch = _get_tmux(request)
 
     # Find session across all projects
     session = None

claude_mpm/commander/api/routes/work.py

@@ -4,25 +4,39 @@ This module implements REST endpoints for managing work items
 in project work queues.
 """
 
-from typing import List, Optional
+from typing import Dict, List, Optional
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, HTTPException, Query, Request
 
 from ...models.work import WorkPriority, WorkState
 from ...work import WorkQueue
-from ..errors import ProjectNotFoundError
 from ..schemas import CreateWorkRequest, WorkItemResponse
 
 router = APIRouter()
 
 
-def _get_registry():
-    """Get registry instance from app global."""
-    from ..app import registry
-
-    if registry is None:
+def _get_registry(request: Request):
+    """Get registry instance from app.state."""
+    if not hasattr(request.app.state, "registry") or request.app.state.registry is None:
         raise RuntimeError("Registry not initialized")
-    return registry
+    return request.app.state.registry
+
+
+def _get_work_queues(request: Request) -> Dict:
+    """Get work queues dict from app.state (shared with daemon)."""
+    if (
+        not hasattr(request.app.state, "work_queues")
+        or request.app.state.work_queues is None
+    ):
+        raise RuntimeError("Work queues not initialized")
+    return request.app.state.work_queues
+
+
+def _get_daemon(request: Request):
+    """Get daemon instance from app.state."""
+    if not hasattr(request.app.state, "daemon_instance"):
+        return None
+    return request.app.state.daemon_instance
 
 
 def _work_item_to_response(work_item) -> WorkItemResponse:
@@ -51,10 +65,13 @@ def _work_item_to_response(work_item) -> WorkItemResponse:
 
 
 @router.post("/projects/{project_id}/work", response_model=WorkItemResponse)
-async def add_work(project_id: str, work: CreateWorkRequest) -> WorkItemResponse:
+async def add_work(
+    request: Request, project_id: str, work: CreateWorkRequest
+) -> WorkItemResponse:
     """Add work item to project queue.
 
     Args:
+        request: FastAPI request (for accessing app.state)
         project_id: Project identifier
         work: Work item creation request
 
@@ -80,22 +97,29 @@ async def add_work(project_id: str, work: CreateWorkRequest) -> WorkItemResponse
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
+    work_queues = _get_work_queues(request)
+    daemon = _get_daemon(request)
 
     # Get project
-    try:
-        project = registry.get(project_id)
-    except ProjectNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e)) from e
+    project = registry.get(project_id)
+    if project is None:
+        raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
 
-    # Get or create work queue for project
-    # Note: In full implementation, this would be managed by ProjectSession
-    # For now, we'll need to integrate with project's work queue
-    # Access or create work queue
-    if not hasattr(project, "_work_queue"):
-        project._work_queue = WorkQueue(project_id)
+    # Get or create work queue (shared with daemon)
+    import logging
 
-    queue = project._work_queue
+    logger = logging.getLogger(__name__)
+    logger.info(
+        f"work_queues dict id: {id(work_queues)}, keys: {list(work_queues.keys())}"
+    )
+
+    if project_id not in work_queues:
+        logger.info(f"Creating new work queue for {project_id}")
+        work_queues[project_id] = WorkQueue(project_id)
+        logger.info(f"After creation, work_queues keys: {list(work_queues.keys())}")
+
+    queue = work_queues[project_id]
 
     # Convert priority int to enum
     priority = WorkPriority(work.priority)
@@ -105,16 +129,25 @@ async def add_work(project_id: str, work: CreateWorkRequest) -> WorkItemResponse
         content=work.content, priority=priority, depends_on=work.depends_on
     )
 
+    # Ensure daemon has a session for this project (creates if needed)
+    if daemon and not daemon.sessions.get(project_id):
+        # Session creation will be handled by daemon's main loop
+        # when it detects work in the queue
+        pass
+
     return _work_item_to_response(work_item)
 
 
 @router.get("/projects/{project_id}/work", response_model=List[WorkItemResponse])
 async def list_work(
-    project_id: str, state: Optional[str] = Query(None, description="Filter by state")
+    request: Request,
+    project_id: str,
+    state: Optional[str] = Query(None, description="Filter by state"),
 ) -> List[WorkItemResponse]:
     """List work items for project.
 
     Args:
+        request: FastAPI request (for accessing app.state)
         project_id: Project identifier
         state: Optional state filter (pending, queued, in_progress, etc.)
 
@@ -136,19 +169,20 @@ async def list_work(
             {"id": "work-1", "state": "queued", ...}
         ]
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
+    work_queues = _get_work_queues(request)
 
     # Get project
-    try:
-        project = registry.get(project_id)
-    except ProjectNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e)) from e
+    project = registry.get(project_id)
+    if project is None:
+        raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
 
-    # Get work queue
-    if not hasattr(project, "_work_queue"):
-        project._work_queue = WorkQueue(project_id)
+    # Get work queue (shared with daemon)
+    if project_id not in work_queues:
+        # Return empty list if no work queue exists yet
+        return []
 
-    queue = project._work_queue
+    queue = work_queues[project_id]
 
     # Parse state filter
     state_filter = None
@@ -169,10 +203,11 @@ async def list_work(
 
 
 @router.get("/projects/{project_id}/work/{work_id}", response_model=WorkItemResponse)
-async def get_work(project_id: str, work_id: str) -> WorkItemResponse:
+async def get_work(request: Request, project_id: str, work_id: str) -> WorkItemResponse:
     """Get work item details.
 
     Args:
+        request: FastAPI request (for accessing app.state)
         project_id: Project identifier
         work_id: Work item identifier
 
@@ -191,19 +226,19 @@ async def get_work(project_id: str, work_id: str) -> WorkItemResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
+    work_queues = _get_work_queues(request)
 
     # Get project
-    try:
-        project = registry.get(project_id)
-    except ProjectNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e)) from e
+    project = registry.get(project_id)
+    if project is None:
+        raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
 
-    # Get work queue
-    if not hasattr(project, "_work_queue"):
+    # Get work queue (shared with daemon)
+    if project_id not in work_queues:
         raise HTTPException(status_code=404, detail="Work queue not found")
 
-    queue = project._work_queue
+    queue = work_queues[project_id]
 
     # Get work item
     work_item = queue.get(work_id)
@@ -214,10 +249,11 @@ async def get_work(project_id: str, work_id: str) -> WorkItemResponse:
 
 
 @router.post("/projects/{project_id}/work/{work_id}/cancel")
-async def cancel_work(project_id: str, work_id: str) -> dict:
+async def cancel_work(request: Request, project_id: str, work_id: str) -> dict:
     """Cancel pending work item.
 
     Args:
+        request: FastAPI request (for accessing app.state)
         project_id: Project identifier
         work_id: Work item identifier
 
@@ -231,19 +267,19 @@ async def cancel_work(project_id: str, work_id: str) -> dict:
         POST /api/projects/proj-123/work/work-xyz/cancel
         Response: {"status": "cancelled", "id": "work-xyz"}
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
+    work_queues = _get_work_queues(request)
 
     # Get project
-    try:
-        project = registry.get(project_id)
-    except ProjectNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e)) from e
+    project = registry.get(project_id)
+    if project is None:
+        raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
 
-    # Get work queue
-    if not hasattr(project, "_work_queue"):
+    # Get work queue (shared with daemon)
+    if project_id not in work_queues:
         raise HTTPException(status_code=404, detail="Work queue not found")
 
-    queue = project._work_queue
+    queue = work_queues[project_id]
 
     # Cancel work item
     if not queue.cancel(work_id):

claude_mpm/commander/api/schemas.py

@@ -17,10 +17,14 @@ class RegisterProjectRequest(BaseModel):
 
     Attributes:
         path: Filesystem path to project directory
+        project_id: Optional project identifier (UUID generated if omitted)
         name: Optional display name (derived from path if omitted)
     """
 
     path: str = Field(..., description="Filesystem path to project")
+    project_id: Optional[str] = Field(
+        None, description="Project identifier (UUID generated if omitted)"
+    )
     name: Optional[str] = Field(
         None, description="Display name (derived from path if omitted)"
     )