mcp-ticketer 0.2.0__py3-none-any.whl → 2.2.9__py3-none-any.whl

mcp_ticketer/queue/manager.py

@@ -4,14 +4,14 @@ import fcntl
 import logging
 import os
 import subprocess
-import sys
 import time
 from pathlib import Path
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import psutil
 
-from .queue import Queue
+if TYPE_CHECKING:
+    pass
 
 logger = logging.getLogger(__name__)
 
@@ -19,8 +19,11 @@ logger = logging.getLogger(__name__)
 class WorkerManager:
     """Manages worker process with file-based locking."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize worker manager."""
+        # Lazy import to avoid circular dependency
+        from .queue import Queue
+
         self.lock_file = Path.home() / ".mcp-ticketer" / "worker.lock"
         self.pid_file = Path.home() / ".mcp-ticketer" / "worker.pid"
         self.lock_file.parent.mkdir(parents=True, exist_ok=True)
@@ -51,7 +54,7 @@ class WorkerManager:
             # Lock already held
             return False
 
-    def _release_lock(self):
+    def _release_lock(self) -> None:
         """Release worker lock."""
         if hasattr(self, "lock_fd"):
             fcntl.lockf(self.lock_fd, fcntl.LOCK_UN)
@@ -81,12 +84,22 @@ class WorkerManager:
         # Try to start worker
         return self.start()
 
-    def start(self) -> bool:
+    def start(self, timeout: float = 30.0) -> bool:
         """Start the worker process.
 
+        Args:
+            timeout: Maximum seconds to wait for worker to become fully operational (default: 30)
+
         Returns:
             True if started successfully, False otherwise
 
+        Raises:
+            TimeoutError: If worker doesn't start within timeout period
+
+        Note:
+            If timeout occurs, a worker may already be running in another process.
+            Check for stale lock files or processes using `get_status()`.
+
         """
         # Check if already running
         if self.is_running():
@@ -96,12 +109,27 @@ class WorkerManager:
         # Try to acquire lock
         if not self._acquire_lock():
             logger.warning("Could not acquire lock - another worker may be running")
-            return False
+            # Wait briefly to see if worker becomes operational
+            start_time = time.time()
+            while time.time() - start_time < timeout:
+                if self.is_running():
+                    logger.info("Worker started by another process")
+                    return True
+                time.sleep(1)
+
+            raise TimeoutError(
+                f"Worker start timed out after {timeout}s. "
+                f"Lock is held but worker is not running. "
+                f"Check for stale lock files or zombie processes."
+            )
 
         try:
             # Start worker in subprocess using the same Python executable as the CLI
             # This ensures the worker can import mcp_ticketer modules
-            python_executable = self._get_python_executable()
+            # Lazy import to avoid circular dependency
+            from ..cli.python_detection import get_mcp_ticketer_python
+
+            python_executable = get_mcp_ticketer_python()
             cmd = [python_executable, "-m", "mcp_ticketer.queue.run_worker"]
 
             # Prepare environment for subprocess
@@ -113,9 +141,12 @@ class WorkerManager:
             if env_file.exists():
                 logger.debug(f"Loading environment from {env_file} for subprocess")
                 from dotenv import dotenv_values
+
                 env_vars = dotenv_values(env_file)
                 subprocess_env.update(env_vars)
-                logger.debug(f"Added {len(env_vars)} environment variables from .env.local")
+                logger.debug(
+                    f"Added {len(env_vars)} environment variables from .env.local"
+                )
 
             # Start as background process
             process = subprocess.Popen(
@@ -130,20 +161,42 @@ class WorkerManager:
             # Save PID
             self.pid_file.write_text(str(process.pid))
 
-            # Give the process a moment to start
-            import time
-
-            time.sleep(0.5)
-
-            # Verify process is running
-            if not psutil.pid_exists(process.pid):
-                logger.error("Worker process died immediately after starting")
-                self._cleanup()
-                return False
-
-            logger.info(f"Started worker process with PID {process.pid}")
-            return True
+            # Wait for worker to become fully operational with timeout
+            start_time = time.time()
+            while time.time() - start_time < timeout:
+                # Check if process exists
+                if not psutil.pid_exists(process.pid):
+                    logger.error("Worker process died during startup")
+                    self._cleanup()
+                    return False
+
+                # Check if worker is fully running (not just process exists)
+                if self.is_running():
+                    elapsed = time.time() - start_time
+                    logger.info(
+                        f"Worker started successfully in {elapsed:.1f}s with PID {process.pid}"
+                    )
+                    return True
+
+                # Log progress for long startups
+                elapsed = time.time() - start_time
+                if elapsed > 5 and int(elapsed) % 5 == 0:
+                    logger.debug(
+                        f"Waiting for worker to start, elapsed: {elapsed:.1f}s"
+                    )
+
+                time.sleep(0.5)
+
+            # Timeout reached
+            raise TimeoutError(
+                f"Worker start timed out after {timeout}s. "
+                f"Process spawned (PID {process.pid}) but worker did not become operational. "
+                f"Check worker logs for startup errors."
+            )
 
+        except TimeoutError:
+            # Re-raise timeout errors with context preserved
+            raise
         except Exception as e:
             logger.error(f"Failed to start worker: {e}")
             self._release_lock()
@@ -234,7 +287,7 @@ class WorkerManager:
         is_running = self.is_running()
         pid = self._get_pid() if is_running else None
 
-        status = {"running": is_running, "pid": pid}
+        status: dict[str, Any] = {"running": is_running, "pid": pid}
 
         # Add process info if running
         if is_running and pid:
@@ -257,7 +310,7 @@ class WorkerManager:
 
         return status
 
-    def _get_pid(self) -> Optional[int]:
+    def _get_pid(self) -> int | None:
         """Get worker PID from file.
 
         Returns:
@@ -273,45 +326,7 @@ class WorkerManager:
         except (OSError, ValueError):
             return None
 
-    def _get_python_executable(self) -> str:
-        """Get the correct Python executable for the worker subprocess.
-
-        This ensures the worker uses the same Python environment as the CLI,
-        which is critical for module imports to work correctly.
-
-        Returns:
-            Path to Python executable
-        """
-        # First, try to detect if we're running in a pipx environment
-        # by checking if the current executable is in a pipx venv
-        current_executable = sys.executable
-
-        # Check if we're in a pipx venv (path contains /pipx/venvs/)
-        if "/pipx/venvs/" in current_executable:
-            logger.debug(f"Using pipx Python executable: {current_executable}")
-            return current_executable
-
-        # Check if we can find the mcp-ticketer executable and extract its Python
-        import shutil
-        mcp_ticketer_path = shutil.which("mcp-ticketer")
-        if mcp_ticketer_path:
-            try:
-                # Read the shebang line to get the Python executable
-                with open(mcp_ticketer_path, 'r') as f:
-                    first_line = f.readline().strip()
-                    if first_line.startswith("#!") and "python" in first_line:
-                        python_path = first_line[2:].strip()
-                        if os.path.exists(python_path):
-                            logger.debug(f"Using Python from mcp-ticketer shebang: {python_path}")
-                            return python_path
-            except (OSError, IOError):
-                pass
-
-        # Fallback to sys.executable
-        logger.debug(f"Using sys.executable as fallback: {current_executable}")
-        return current_executable
-
-    def _cleanup(self):
+    def _cleanup(self) -> None:
         """Clean up lock and PID files."""
         self._release_lock()
         if self.pid_file.exists():

mcp_ticketer/queue/queue.py

@@ -8,7 +8,7 @@ from dataclasses import asdict, dataclass
 from datetime import datetime, timedelta
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 
 class QueueStatus(str, Enum):
@@ -30,11 +30,12 @@ class QueueItem:
     operation: str
     status: QueueStatus
     created_at: datetime
-    processed_at: Optional[datetime] = None
-    error_message: Optional[str] = None
+    processed_at: datetime | None = None
+    error_message: str | None = None
     retry_count: int = 0
-    result: Optional[dict[str, Any]] = None
-    project_dir: Optional[str] = None
+    result: dict[str, Any] | None = None
+    project_dir: str | None = None
+    adapter_config: dict[str, Any] | None = None  # Adapter configuration
 
     def to_dict(self) -> dict:
         """Convert to dictionary for storage."""
@@ -59,13 +60,14 @@ class QueueItem:
             retry_count=row[8],
             result=json.loads(row[9]) if row[9] else None,
             project_dir=row[10] if len(row) > 10 else None,
+            adapter_config=json.loads(row[11]) if len(row) > 11 and row[11] else None,
         )
 
 
 class Queue:
     """Thread-safe SQLite queue for ticket operations."""
 
-    def __init__(self, db_path: Optional[Path] = None):
+    def __init__(self, db_path: Path | None = None):
         """Initialize queue with database connection.
 
         Args:
@@ -81,7 +83,7 @@ class Queue:
         self._lock = threading.Lock()
         self._init_database()
 
-    def _init_database(self):
+    def _init_database(self) -> None:
         """Initialize database schema."""
         with sqlite3.connect(self.db_path) as conn:
             conn.execute(
@@ -127,6 +129,8 @@ class Queue:
             columns = [row[1] for row in cursor.fetchall()]
             if "project_dir" not in columns:
                 conn.execute("ALTER TABLE queue ADD COLUMN project_dir TEXT")
+            if "adapter_config" not in columns:
+                conn.execute("ALTER TABLE queue ADD COLUMN adapter_config TEXT")
 
             conn.commit()
 
@@ -135,7 +139,8 @@ class Queue:
         ticket_data: dict[str, Any],
         adapter: str,
         operation: str,
-        project_dir: Optional[str] = None,
+        project_dir: str | None = None,
+        adapter_config: dict[str, Any] | None = None,
     ) -> str:
         """Add item to queue.
 
@@ -144,6 +149,7 @@ class Queue:
             adapter: Name of the adapter to use
             operation: Operation to perform (create, update, delete, etc.)
             project_dir: Project directory for config resolution (defaults to current directory)
+            adapter_config: Adapter configuration to use (optional, for explicit config passing)
 
         Returns:
             Queue ID for tracking
@@ -161,8 +167,8 @@ class Queue:
                     """
                     INSERT INTO queue (
                         id, ticket_data, adapter, operation,
-                        status, created_at, retry_count, project_dir
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                        status, created_at, retry_count, project_dir, adapter_config
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                     (
                         queue_id,
@@ -173,13 +179,14 @@ class Queue:
                         datetime.now().isoformat(),
                         0,
                         project_dir,
+                        json.dumps(adapter_config) if adapter_config else None,
                     ),
                 )
                 conn.commit()
 
         return queue_id
 
-    def get_next_pending(self) -> Optional[QueueItem]:
+    def get_next_pending(self) -> QueueItem | None:
         """Get next pending item from queue atomically.
 
         Returns:
@@ -211,7 +218,12 @@ class Queue:
                             SET status = ?, processed_at = ?
                             WHERE id = ? AND status = ?
                         """,
-                            (QueueStatus.PROCESSING.value, datetime.now().isoformat(), row[0], QueueStatus.PENDING.value),
+                            (
+                                QueueStatus.PROCESSING.value,
+                                datetime.now().isoformat(),
+                                row[0],
+                                QueueStatus.PENDING.value,
+                            ),
                         )
 
                         # Check if update was successful (prevents race conditions)
@@ -239,9 +251,9 @@ class Queue:
         self,
         queue_id: str,
         status: QueueStatus,
-        error_message: Optional[str] = None,
-        result: Optional[dict[str, Any]] = None,
-        expected_status: Optional[QueueStatus] = None,
+        error_message: str | None = None,
+        result: dict[str, Any] | None = None,
+        expected_status: QueueStatus | None = None,
     ) -> bool:
         """Update queue item status atomically.
 
@@ -254,6 +266,7 @@ class Queue:
 
         Returns:
             True if update was successful, False if item was in unexpected state
+
         """
         with self._lock:
             with sqlite3.connect(self.db_path) as conn:
@@ -314,7 +327,9 @@ class Queue:
                     conn.rollback()
                     raise
 
-    def increment_retry(self, queue_id: str, expected_status: Optional[QueueStatus] = None) -> int:
+    def increment_retry(
+        self, queue_id: str, expected_status: QueueStatus | None = None
+    ) -> int:
         """Increment retry count and reset to pending atomically.
 
         Args:
@@ -340,7 +355,11 @@ class Queue:
                             WHERE id = ? AND status = ?
                             RETURNING retry_count
                         """,
-                            (QueueStatus.PENDING.value, queue_id, expected_status.value),
+                            (
+                                QueueStatus.PENDING.value,
+                                queue_id,
+                                expected_status.value,
+                            ),
                         )
                     else:
                         # Regular increment
@@ -368,7 +387,7 @@ class Queue:
                     conn.rollback()
                     raise
 
-    def get_item(self, queue_id: str) -> Optional[QueueItem]:
+    def get_item(self, queue_id: str) -> QueueItem | None:
         """Get specific queue item by ID.
 
         Args:
@@ -390,7 +409,7 @@ class Queue:
             return QueueItem.from_row(row) if row else None
 
     def list_items(
-        self, status: Optional[QueueStatus] = None, limit: int = 50
+        self, status: QueueStatus | None = None, limit: int = 50
     ) -> list[QueueItem]:
         """List queue items.
 
@@ -443,7 +462,7 @@ class Queue:
 
             return cursor.fetchone()[0]
 
-    def cleanup_old(self, days: int = 7):
+    def cleanup_old(self, days: int = 7) -> None:
         """Clean up old completed/failed items.
 
         Args:
@@ -468,7 +487,7 @@ class Queue:
                 )
                 conn.commit()
 
-    def reset_stuck_items(self, timeout_minutes: int = 30):
+    def reset_stuck_items(self, timeout_minutes: int = 30) -> None:
         """Reset items stuck in processing state.
 
         Args:
@@ -516,3 +535,71 @@ class Queue:
                 stats[status] = count
 
             return stats
+
+    def poll_until_complete(
+        self,
+        queue_id: str,
+        timeout: float = 30.0,
+        poll_interval: float = 0.5,
+    ) -> QueueItem:
+        """Poll queue item until completion or timeout.
+
+        This enables synchronous waiting for queue operations, useful for:
+        - CLI commands that need immediate results
+        - Testing that requires actual ticket IDs
+        - GitHub adapter operations requiring ticket numbers
+
+        Args:
+            queue_id: Queue ID to poll (e.g., "Q-9E7B5050")
+            timeout: Maximum seconds to wait (default: 30.0)
+            poll_interval: Seconds between polls (default: 0.5)
+
+        Returns:
+            Completed QueueItem with result data
+
+        Raises:
+            TimeoutError: If operation doesn't complete within timeout
+            RuntimeError: If operation fails or queue item not found
+
+        Example:
+            >>> queue = Queue()
+            >>> queue_id = queue.add(ticket_data={...}, adapter="github", operation="create")
+            >>> # Start worker to process the queue
+            >>> completed_item = queue.poll_until_complete(queue_id, timeout=30)
+            >>> ticket_id = completed_item.result["id"]
+
+        """
+        import time
+
+        start_time = time.time()
+        elapsed = 0.0
+
+        while elapsed < timeout:
+            item = self.get_item(queue_id)
+
+            if item is None:
+                raise RuntimeError(f"Queue item not found: {queue_id}")
+
+            if item.status == QueueStatus.COMPLETED:
+                if item.result is None:
+                    raise RuntimeError(
+                        f"Queue operation completed but has no result data: {queue_id}"
+                    )
+                return item
+
+            elif item.status == QueueStatus.FAILED:
+                error_msg = item.error_message or "Unknown error"
+                raise RuntimeError(
+                    f"Queue operation failed: {error_msg} (queue_id: {queue_id})"
+                )
+
+            # Still pending or processing - wait and retry
+            time.sleep(poll_interval)
+            elapsed = time.time() - start_time
+
+        # Timeout reached
+        final_item = self.get_item(queue_id)
+        final_status = final_item.status.value if final_item else "UNKNOWN"
+        raise TimeoutError(
+            f"Queue operation timed out after {timeout}s (status: {final_status}, queue_id: {queue_id})"
+        )

mcp_ticketer/queue/run_worker.py

@@ -13,10 +13,10 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 
-def main():
+def main() -> None:
     """Run the worker process."""
-    import sys
     import os
+
     logger.info("Starting standalone worker process")
     logger.info(f"Worker Python executable: {sys.executable}")
     logger.info(f"Worker working directory: {os.getcwd()}")