mcp-ticketer 0.1.30__py3-none-any.whl → 1.2.11__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,11 +109,44 @@ 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
-            cmd = [sys.executable, "-m", "mcp_ticketer.queue.run_worker"]
+            # Start worker in subprocess using the same Python executable as the CLI
+            # This ensures the worker can import mcp_ticketer modules
+            # 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
+            # Ensure the subprocess gets the same environment as the parent
+            subprocess_env = os.environ.copy()
+
+            # Explicitly load environment variables from .env.local if it exists
+            env_file = Path.cwd() / ".env.local"
+            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"
+                )
 
             # Start as background process
             process = subprocess.Popen(
@@ -108,25 +154,49 @@ class WorkerManager:
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
                 start_new_session=True,
+                env=subprocess_env,  # Pass environment explicitly
+                cwd=str(Path.cwd()),  # Ensure correct working directory
             )
 
             # 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()
@@ -217,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:
@@ -240,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:
@@ -256,7 +326,7 @@ class WorkerManager:
         except (OSError, ValueError):
             return None
 
-    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:

mcp_ticketer/queue/run_worker.py

@@ -13,9 +13,14 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 
-def main():
+def main() -> None:
     """Run the worker process."""
+    import os
+
     logger.info("Starting standalone worker process")
+    logger.info(f"Worker Python executable: {sys.executable}")
+    logger.info(f"Worker working directory: {os.getcwd()}")
+    logger.info(f"Worker Python path: {sys.path[:3]}...")  # Show first 3 entries
 
     try:
         # Create queue and worker