devs-webhook 1.2.0__tar.gz → 2.0.0__tar.gz

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devs-webhook
-Version: 1.2.0
+Version: 2.0.0
 Summary: GitHub webhook handler for automated devcontainer operations with Claude Code
 Author: Dan Lester
 License-Expression: MIT

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/devs_webhook/config.py

@@ -3,7 +3,7 @@
 import os
 from pathlib import Path
 from functools import lru_cache
-from typing import List, Optional
+from typing import Dict, List, Optional
 try:
     from pydantic_settings import BaseSettings, SettingsConfigDict
 except ImportError:
@@ -84,6 +84,12 @@ class WebhookConfig(BaseSettings, BaseConfig):
         default=60,
         description="How often to check for idle/old containers (in seconds)"
     )
+    stop_container_after_task: bool = Field(
+        default=True,
+        description="Stop container after each task completes. "
+                    "This ensures only one running container per dev name at any time, "
+                    "reducing RAM usage when multiple repos are in play."
+    )
     max_concurrent_tasks: int = Field(default=3, description="Maximum concurrent tasks")
     
     # Repository settings
@@ -181,7 +187,14 @@ class WebhookConfig(BaseSettings, BaseConfig):
             if self.log_format == "json":
                 self.log_format = "console"
         return self
-    
+
+    @property
+    def container_labels(self) -> Dict[str, str]:
+        """Standard labels applied to containers created by webhook."""
+        labels = super().container_labels
+        labels["devs.source"] = "webhook"
+        return labels
+
     # Configuration for Pydantic Settings
     # Note: .env files are optional - environment variables are the primary source
     if SettingsConfigDict:

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/devs_webhook/core/claude_dispatcher.py

@@ -236,15 +236,22 @@ Always remember to PUSH your work to origin!
                 pr_closing_instruction = ""
                 if not is_pr:
                     pr_closing_instruction = " (mention that it closes an issue number if it does)"
-                
+
+                # Add draft PR instruction if enabled in DEVS.yml
+                draft_pr_instruction = ""
+                if devs_options and devs_options.draft_prs:
+                    draft_pr_instruction = """
+IMPORTANT: Create pull requests as DRAFTS using `gh pr create --draft`. Keep PRs in draft status until the user explicitly instructs you to mark them ready for review.
+"""
+
                 # Build unified prompt with variable parts
-                prompt = f"""You are an AI developer helping build a software project in a GitHub repository. 
+                prompt = f"""You are an AI developer helping build a software project in a GitHub repository.
 You have been mentioned in a {event_type_full} and need to take action.
 
-You should ensure you're on the latest commits in the repo's default branch. 
-Generally work on feature branches for changes. 
+You should ensure you're on the latest commits in the repo's default branch.
+Generally work on feature branches for changes.
 Submit any changes as a pull request when done{pr_closing_instruction}.
-
+{draft_pr_instruction}
 IMPORTANT: Do not close the issue unless the user explicitly instructs you to do so. Even if you implement a solution, leave the issue open for the user to review and close when they're satisfied.
 
 If you need to ask for clarification, or if only asked for your thoughts, please respond with a comment on the {event_type}.

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/devs_webhook/core/container_pool.py

@@ -837,10 +837,35 @@ class ContainerPool:
             # Task execution failed, but we've logged it - don't re-raise
 
         finally:
-            # Update last_used timestamp after task completes (success or failure)
+            # Handle container cleanup after task completes (success or failure)
             async with self._lock:
                 if dev_name in self.running_containers:
-                    self.running_containers[dev_name]["last_used"] = datetime.now(tz=timezone.utc)
+                    if self.config.stop_container_after_task:
+                        # Stop container immediately after task completes
+                        # This ensures only one running container per dev name queue
+                        # Don't remove the container or workspace - just stop it so it can restart quickly
+                        info = self.running_containers[dev_name]
+                        logger.info("Stopping container after task completion",
+                                   container=dev_name,
+                                   repo_path=str(info["repo_path"]),
+                                   stop_container_after_task=True)
+                        try:
+                            await self._cleanup_container(
+                                dev_name,
+                                info["repo_path"],
+                                remove_workspace=False,
+                                remove_container=False
+                            )
+                            del self.running_containers[dev_name]
+                            logger.info("Container stopped successfully after task",
+                                       container=dev_name)
+                        except Exception as cleanup_error:
+                            logger.error("Failed to stop container after task",
+                                        container=dev_name,
+                                        error=str(cleanup_error))
+                    else:
+                        # Just update last_used timestamp (legacy behavior)
+                        self.running_containers[dev_name]["last_used"] = datetime.now(tz=timezone.utc)
 
     async def _checkout_default_branch(self, repo_name: str, repo_path: Path) -> None:
         """Checkout the default branch to ensure devcontainer files are from the right branch.
@@ -876,6 +901,8 @@ class ContainerPool:
             logger.info("Checked out default branch",
                        repo=repo_name,
                        branch=default_branch)
+            # Clean untracked files after checkout
+            await self._clean_untracked_files(repo_path)
         elif default_branch == "dev":
             # dev branch doesn't exist, try main
             logger.info("Branch 'dev' not found, trying 'main'",
@@ -891,6 +918,8 @@ class ContainerPool:
             if process.returncode == 0:
                 logger.info("Checked out main branch",
                            repo=repo_name)
+                # Clean untracked files after checkout
+                await self._clean_untracked_files(repo_path)
             else:
                 # Both failed, stay on current branch (probably master or main after clone)
                 logger.warning("Could not checkout dev or main branch, staying on current branch",
@@ -903,6 +932,31 @@ class ContainerPool:
                           branch=default_branch,
                           stderr=stderr.decode()[:200] if stderr else "")
 
+    async def _clean_untracked_files(self, repo_path: Path) -> None:
+        """Remove untracked files and directories from repository.
+
+        Important for reusing repocache between tasks to avoid leftover files
+        from previous runs affecting the next task.
+
+        Args:
+            repo_path: Path to the repository
+        """
+        clean_cmd = ["git", "-C", str(repo_path), "clean", "-fd"]
+        process = await asyncio.create_subprocess_exec(
+            *clean_cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await process.communicate()
+
+        if process.returncode == 0:
+            logger.info("Cleaned untracked files from repository",
+                       repo_path=str(repo_path))
+        else:
+            logger.warning("Could not clean untracked files",
+                          repo_path=str(repo_path),
+                          stderr=stderr.decode()[:200] if stderr else "")
+
     async def _ensure_repository_cloned(
         self,
         repo_name: str,
@@ -1211,6 +1265,7 @@ Please check the webhook handler logs for more details, or try mentioning me aga
                     "idle_timeout_minutes": self.config.container_timeout_minutes,
                     "max_age_hours": self.config.container_max_age_hours,
                     "check_interval_seconds": self.config.cleanup_check_interval_seconds,
+                    "stop_container_after_task": self.config.stop_container_after_task,
                 },
             }
 
@@ -1367,36 +1422,54 @@ Please check the webhook handler logs for more details, or try mentioning me aga
                 logger.error("Error in idle cleanup worker", error=str(e))
     
     
-    async def _cleanup_container(self, dev_name: str, repo_path: Path) -> None:
+    async def _cleanup_container(
+        self,
+        dev_name: str,
+        repo_path: Path,
+        remove_workspace: bool = True,
+        remove_container: bool = True
+    ) -> None:
         """Clean up a container after use.
-        
+
         Args:
             dev_name: Name of container to clean up
             repo_path: Path to repository on host
+            remove_workspace: If True (default), also remove the workspace.
+                If False, only stop the container but keep the workspace
+                for faster reuse on restart.
+            remove_container: If True (default), remove the container after stopping.
+                If False, only stop the container (it can be restarted quickly).
         """
         try:
             # Create project and managers for cleanup
             project = Project(repo_path)
-            
+
             # Use the same config as the rest of the webhook handler
             workspace_manager = WorkspaceManager(project, self.config)
             container_manager = ContainerManager(project, self.config)
-            
-            # Stop container
-            logger.info("Starting container stop", container=dev_name)
-            stop_success = container_manager.stop_container(dev_name)
-            logger.info("Container stop result", container=dev_name, success=stop_success)
-            
-            # Remove workspace
-            logger.info("Starting workspace removal", container=dev_name)
-            workspace_success = workspace_manager.remove_workspace(dev_name)
-            logger.info("Workspace removal result", container=dev_name, success=workspace_success)
-            
-            logger.info("Container cleanup complete", 
+
+            # Stop container (and optionally remove it)
+            logger.info("Starting container stop", container=dev_name, remove=remove_container)
+            stop_success = container_manager.stop_container(dev_name, remove=remove_container)
+            logger.info("Container stop result", container=dev_name, success=stop_success, removed=remove_container)
+
+            # Remove workspace only if requested
+            workspace_success = True
+            if remove_workspace:
+                logger.info("Starting workspace removal", container=dev_name)
+                workspace_success = workspace_manager.remove_workspace(dev_name)
+                logger.info("Workspace removal result", container=dev_name, success=workspace_success)
+            else:
+                logger.info("Keeping workspace for faster reuse",
+                           container=dev_name,
+                           workspace_path=str(workspace_manager.get_workspace_dir(dev_name)))
+
+            logger.info("Container cleanup complete",
                        container=dev_name,
                        container_stopped=stop_success,
-                       workspace_removed=workspace_success)
-            
+                       container_removed=remove_container,
+                       workspace_removed=workspace_success if remove_workspace else "skipped")
+
         except Exception as e:
             logger.error("Container cleanup failed",
                         container=dev_name,

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/devs_webhook/github/models.py

@@ -61,6 +61,7 @@ class GitHubPullRequest(BaseModel):
     title: str
     body: Optional[str] = None
     state: str
+    draft: bool = False
     user: GitHubUser
     assignee: Optional[GitHubUser] = None
     html_url: str

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/devs_webhook/github/parser.py

@@ -290,15 +290,22 @@ class WebhookParser:
         
         # Handle pull request events for CI
         if isinstance(event, PullRequestEvent):
+            # Skip draft PRs - they shouldn't trigger CI runs
+            if event.pull_request.draft:
+                logger.info("Skipping CI for draft PR",
+                           pr_number=event.pull_request.number,
+                           repo=event.repository.full_name)
+                return False
+
             # Process PR opened, synchronize (new commits), reopened
             ci_pr_actions = ["opened", "synchronize", "reopened"]
             should_process = event.action in ci_pr_actions
-            
+
             logger.info("PR event CI check",
                        action=event.action,
                        ci_pr_actions=ci_pr_actions,
                        should_process=should_process)
-            
+
             return should_process
         
         # Handle push events for CI

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/devs_webhook/main_cli.py

@@ -448,23 +448,25 @@ def test(prompt: str, repo: str, host: str, port: int, username: str, password:
 
 
 @cli.command()
-@click.option('--all', 'cleanup_all', is_flag=True, help='Clean up all managed containers (not just idle ones)')
+@click.option('--all', 'cleanup_all', is_flag=True, help='Clean up all webhook containers (not just idle ones)')
 @click.option('--max-age-hours', default=None, type=int, help='Override max age threshold (default: from config or 10)')
 @click.option('--idle-minutes', default=None, type=int, help='Override idle timeout (default: from config or 60)')
 @click.option('--dry-run', is_flag=True, help='Show what would be cleaned up without actually doing it')
 def cleanup(cleanup_all: bool, max_age_hours: int, idle_minutes: int, dry_run: bool):
-    """Clean up idle and old containers.
+    """Clean up idle and old webhook containers.
 
-    This command finds containers managed by devs-webhook and cleans up those that
+    This command finds containers created by devs-webhook and cleans up those that
     are idle (exited, or running but not processing) and either:
     - Idle for longer than the idle timeout
     - Older than the max age threshold
 
+    Only cleans up webhook-created containers (not CLI-created ones).
+
     Use this after burst mode processing completes, or via cron for periodic cleanup.
 
     Examples:
         devs-webhook cleanup                    # Clean up idle containers exceeding thresholds
-        devs-webhook cleanup --all              # Clean up ALL managed containers
+        devs-webhook cleanup --all              # Clean up ALL webhook containers
         devs-webhook cleanup --dry-run          # Show what would be cleaned up
         devs-webhook cleanup --max-age-hours 2  # Override max age to 2 hours
     """
@@ -487,7 +489,7 @@ def cleanup(cleanup_all: bool, max_age_hours: int, idle_minutes: int, dry_run: b
     click.echo(f"   Max age: {max_age.total_seconds() / 3600:.1f} hours")
     click.echo(f"   Idle timeout: {idle_timeout.total_seconds() / 60:.0f} minutes")
     if cleanup_all:
-        click.echo("   Mode: Clean ALL managed containers")
+        click.echo("   Mode: Clean ALL webhook containers")
     if dry_run:
         click.echo("   Mode: DRY RUN (no changes will be made)")
     click.echo()
@@ -498,18 +500,21 @@ def cleanup(cleanup_all: bool, max_age_hours: int, idle_minutes: int, dry_run: b
         click.echo(f"❌ Failed to connect to Docker: {e}")
         return
 
-    # Find all devs-managed containers
+    # Find webhook-created containers only
     try:
-        containers = docker.find_containers_by_labels({"devs.managed": "true"})
+        containers = docker.find_containers_by_labels({
+            "devs.managed": "true",
+            "devs.source": "webhook"
+        })
     except Exception as e:
         click.echo(f"❌ Failed to list containers: {e}")
         return
 
     if not containers:
-        click.echo("✅ No managed containers found")
+        click.echo("✅ No webhook containers found")
         return
 
-    click.echo(f"Found {len(containers)} managed container(s)")
+    click.echo(f"Found {len(containers)} webhook container(s)")
 
     now = datetime.now(tz=timezone.utc)
     cleaned = 0

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/devs_webhook.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devs-webhook
-Version: 1.2.0
+Version: 2.0.0
 Summary: GitHub webhook handler for automated devcontainer operations with Claude Code
 Author: Dan Lester
 License-Expression: MIT

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/devs_webhook.egg-info/SOURCES.txt

@@ -43,7 +43,9 @@ tests/test_allowlist.py
 tests/test_authentication.py
 tests/test_authorized_users.py
 tests/test_ci_container_pool.py
+tests/test_cleanup_mode.py
 tests/test_container_logs.py
 tests/test_single_queue.py
 tests/test_sqs_burst.py
+tests/test_stop_container_after_task.py
 tests/test_webhook_parser.py

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devs-webhook"
-version = "1.2.0"
+version = "2.0.0"
 description = "GitHub webhook handler for automated devcontainer operations with Claude Code"
 readme = "README.md"
 requires-python = ">=3.8"

devs_webhook-2.0.0/tests/test_cleanup_mode.py

@@ -0,0 +1,165 @@
+"""Tests for container cleanup behavior.
+
+The cleanup behavior supports two modes:
+- remove_workspace=True (default): Full cleanup - stops container AND removes workspace
+- remove_workspace=False: Stop-only cleanup - stops container but keeps workspace for faster reuse
+
+The stop-only mode is useful for the stop-after-task workflow where containers are
+stopped after each task but need to restart quickly for the next task on the same repository.
+"""
+
+import asyncio
+import pytest
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from unittest.mock import MagicMock, patch, AsyncMock
+
+from devs_webhook.core.container_pool import ContainerPool
+
+
+@pytest.fixture
+def mock_config():
+    """Create a mock configuration for cleanup tests."""
+    config = MagicMock()
+    config.get_container_pool_list.return_value = ["eamonn", "harry"]
+    config.get_ci_container_pool_list.return_value = ["eamonn", "harry"]
+    config.has_separate_ci_pool.return_value = False
+    config.github_token = "test-token-1234567890"
+    config.container_timeout_minutes = 60
+    config.container_max_age_hours = 10
+    config.cleanup_check_interval_seconds = 60
+    config.worker_logs_enabled = False
+    temp_dir = tempfile.mkdtemp()
+    config.repo_cache_dir = Path(temp_dir)
+    return config
+
+
+class TestCleanupContainerPool:
+    """Tests for cleanup behavior in ContainerPool."""
+
+    @pytest.mark.asyncio
+    async def test_cleanup_default_removes_workspace(self, mock_config):
+        """Test that _cleanup_container by default stops container AND removes workspace."""
+        with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config):
+            pool = ContainerPool()
+
+            # Cancel workers to avoid background task issues
+            for worker in pool.container_workers.values():
+                worker.cancel()
+            if pool.cleanup_worker:
+                pool.cleanup_worker.cancel()
+
+            # Mock the managers
+            mock_container_manager = MagicMock()
+            mock_container_manager.stop_container.return_value = True
+            mock_workspace_manager = MagicMock()
+            mock_workspace_manager.remove_workspace.return_value = True
+
+            with patch('devs_webhook.core.container_pool.ContainerManager', return_value=mock_container_manager), \
+                 patch('devs_webhook.core.container_pool.WorkspaceManager', return_value=mock_workspace_manager), \
+                 patch('devs_webhook.core.container_pool.Project'):
+
+                await pool._cleanup_container("eamonn", Path("/tmp/test-repo"))
+
+                # Verify container was stopped AND removed (default: remove=True)
+                mock_container_manager.stop_container.assert_called_once_with("eamonn", remove=True)
+                # Verify workspace WAS removed (default behavior)
+                mock_workspace_manager.remove_workspace.assert_called_once_with("eamonn")
+
+    @pytest.mark.asyncio
+    async def test_cleanup_stop_only_keeps_workspace(self, mock_config):
+        """Test that _cleanup_container with remove_workspace=False and remove_container=False keeps both."""
+        with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config):
+            pool = ContainerPool()
+
+            # Cancel workers to avoid background task issues
+            for worker in pool.container_workers.values():
+                worker.cancel()
+            if pool.cleanup_worker:
+                pool.cleanup_worker.cancel()
+
+            # Mock the managers
+            mock_container_manager = MagicMock()
+            mock_container_manager.stop_container.return_value = True
+            mock_workspace_manager = MagicMock()
+            mock_workspace_manager.get_workspace_dir.return_value = Path("/tmp/workspace/eamonn")
+
+            with patch('devs_webhook.core.container_pool.ContainerManager', return_value=mock_container_manager), \
+                 patch('devs_webhook.core.container_pool.WorkspaceManager', return_value=mock_workspace_manager), \
+                 patch('devs_webhook.core.container_pool.Project'):
+
+                await pool._cleanup_container("eamonn", Path("/tmp/test-repo"), remove_workspace=False, remove_container=False)
+
+                # Verify container was stopped but NOT removed (remove=False)
+                mock_container_manager.stop_container.assert_called_once_with("eamonn", remove=False)
+                # Verify workspace was NOT removed (kept for reuse)
+                mock_workspace_manager.remove_workspace.assert_not_called()
+                # Verify get_workspace_dir was called for logging
+                mock_workspace_manager.get_workspace_dir.assert_called_once_with("eamonn")
+
+    @pytest.mark.asyncio
+    async def test_cleanup_preserves_workspace_for_reuse(self, mock_config):
+        """Test that workspace and container are preserved across multiple cleanups with stop-only mode."""
+        with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config):
+            pool = ContainerPool()
+
+            # Cancel workers
+            for worker in pool.container_workers.values():
+                worker.cancel()
+            if pool.cleanup_worker:
+                pool.cleanup_worker.cancel()
+
+            dev_name = "eamonn"
+            repo_path = Path("/tmp/test-repo")
+
+            # Mock the managers
+            mock_container_manager = MagicMock()
+            mock_container_manager.stop_container.return_value = True
+            mock_workspace_manager = MagicMock()
+            mock_workspace_manager.get_workspace_dir.return_value = Path("/tmp/workspace/eamonn")
+
+            with patch('devs_webhook.core.container_pool.ContainerManager', return_value=mock_container_manager), \
+                 patch('devs_webhook.core.container_pool.WorkspaceManager', return_value=mock_workspace_manager), \
+                 patch('devs_webhook.core.container_pool.Project'):
+
+                # First cleanup with stop-only (don't remove container or workspace)
+                await pool._cleanup_container(dev_name, repo_path, remove_workspace=False, remove_container=False)
+
+                # Verify container stopped (but not removed) and workspace kept
+                mock_container_manager.stop_container.assert_called_with(dev_name, remove=False)
+                assert mock_container_manager.stop_container.call_count == 1
+                assert mock_workspace_manager.remove_workspace.call_count == 0
+
+                # Reset mocks for second cleanup
+                mock_container_manager.reset_mock()
+                mock_workspace_manager.reset_mock()
+
+                # Second cleanup (simulating another task on same container)
+                await pool._cleanup_container(dev_name, repo_path, remove_workspace=False, remove_container=False)
+
+                # Again, container stopped (not removed) and workspace still kept
+                mock_container_manager.stop_container.assert_called_with(dev_name, remove=False)
+                assert mock_container_manager.stop_container.call_count == 1
+                assert mock_workspace_manager.remove_workspace.call_count == 0
+
+    @pytest.mark.asyncio
+    async def test_status_includes_cleanup_settings(self, mock_config):
+        """Test that status endpoint includes cleanup settings."""
+        with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config):
+            pool = ContainerPool()
+
+            # Cancel workers to avoid background task issues
+            for worker in pool.container_workers.values():
+                worker.cancel()
+            if pool.cleanup_worker:
+                pool.cleanup_worker.cancel()
+
+            status = await pool.get_status()
+
+            assert "cleanup_settings" in status
+            assert "idle_timeout_minutes" in status["cleanup_settings"]
+            assert "max_age_hours" in status["cleanup_settings"]
+            assert "check_interval_seconds" in status["cleanup_settings"]
+            assert status["cleanup_settings"]["idle_timeout_minutes"] == 60
+            assert status["cleanup_settings"]["max_age_hours"] == 10

devs_webhook-2.0.0/tests/test_stop_container_after_task.py

@@ -0,0 +1,348 @@
+"""Tests for stop_container_after_task functionality."""
+
+import asyncio
+import pytest
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from unittest.mock import MagicMock, patch, AsyncMock
+
+from devs_webhook.core.container_pool import ContainerPool, QueuedTask
+from devs_webhook.github.models import (
+    WebhookEvent, GitHubRepository, GitHubUser, IssueEvent, GitHubIssue
+)
+from devs_common.devs_config import DevsOptions
+
+
+@pytest.fixture
+def mock_config_stop_after_task():
+    """Create a mock configuration with stop_container_after_task enabled."""
+    config = MagicMock()
+    config.get_container_pool_list.return_value = ["eamonn", "harry"]
+    config.get_ci_container_pool_list.return_value = ["eamonn", "harry"]
+    config.has_separate_ci_pool.return_value = False
+    config.github_token = "test-token-1234567890"
+    config.container_timeout_minutes = 60
+    config.container_max_age_hours = 10
+    config.cleanup_check_interval_seconds = 60
+    config.stop_container_after_task = True  # Enabled
+    config.worker_logs_enabled = False
+    temp_dir = tempfile.mkdtemp()
+    config.repo_cache_dir = Path(temp_dir)
+    return config
+
+
+@pytest.fixture
+def mock_config_no_stop_after_task():
+    """Create a mock configuration with stop_container_after_task disabled."""
+    config = MagicMock()
+    config.get_container_pool_list.return_value = ["eamonn", "harry"]
+    config.get_ci_container_pool_list.return_value = ["eamonn", "harry"]
+    config.has_separate_ci_pool.return_value = False
+    config.github_token = "test-token-1234567890"
+    config.container_timeout_minutes = 60
+    config.container_max_age_hours = 10
+    config.cleanup_check_interval_seconds = 60
+    config.stop_container_after_task = False  # Disabled (legacy behavior)
+    config.worker_logs_enabled = False
+    temp_dir = tempfile.mkdtemp()
+    config.repo_cache_dir = Path(temp_dir)
+    return config
+
+
+@pytest.fixture
+def mock_event():
+    """Create a mock webhook event."""
+    return IssueEvent(
+        action="opened",
+        repository=GitHubRepository(
+            id=1,
+            name="test-repo",
+            full_name="test-org/test-repo",
+            owner=GitHubUser(
+                login="test-org",
+                id=1,
+                avatar_url="https://example.com/avatar",
+                html_url="https://example.com/user"
+            ),
+            html_url="https://github.com/test-org/test-repo",
+            clone_url="https://github.com/test-org/test-repo.git",
+            ssh_url="git@github.com:test-org/test-repo.git",
+            default_branch="main"
+        ),
+        sender=GitHubUser(
+            login="sender",
+            id=2,
+            avatar_url="https://example.com/avatar2",
+            html_url="https://example.com/user2"
+        ),
+        issue=GitHubIssue(
+            id=1,
+            number=42,
+            title="Test Issue",
+            body="Test body",
+            state="open",
+            user=GitHubUser(
+                login="sender",
+                id=2,
+                avatar_url="https://example.com/avatar2",
+                html_url="https://example.com/user2"
+            ),
+            html_url="https://github.com/test-org/test-repo/issues/42",
+            created_at="2024-01-01T00:00:00Z",
+            updated_at="2024-01-01T00:00:00Z"
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_status_includes_stop_container_after_task(mock_config_stop_after_task):
+    """Test that status endpoint includes stop_container_after_task setting."""
+    with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config_stop_after_task):
+        pool = ContainerPool()
+
+        # Cancel workers
+        for worker in pool.container_workers.values():
+            worker.cancel()
+        if pool.cleanup_worker:
+            pool.cleanup_worker.cancel()
+
+        status = await pool.get_status()
+
+        assert "cleanup_settings" in status
+        assert "stop_container_after_task" in status["cleanup_settings"]
+        assert status["cleanup_settings"]["stop_container_after_task"] is True
+
+
+@pytest.mark.asyncio
+async def test_status_includes_stop_container_after_task_disabled(mock_config_no_stop_after_task):
+    """Test that status shows stop_container_after_task as false when disabled."""
+    with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config_no_stop_after_task):
+        pool = ContainerPool()
+
+        # Cancel workers
+        for worker in pool.container_workers.values():
+            worker.cancel()
+        if pool.cleanup_worker:
+            pool.cleanup_worker.cancel()
+
+        status = await pool.get_status()
+
+        assert status["cleanup_settings"]["stop_container_after_task"] is False
+
+
+@pytest.mark.asyncio
+async def test_container_stopped_after_task_when_enabled(mock_config_stop_after_task):
+    """Test that container is stopped after task when stop_container_after_task is enabled."""
+    with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config_stop_after_task):
+        pool = ContainerPool()
+
+        # Cancel workers to prevent actual task processing
+        for worker in pool.container_workers.values():
+            worker.cancel()
+        if pool.cleanup_worker:
+            pool.cleanup_worker.cancel()
+
+        # Simulate a running container being tracked
+        dev_name = "eamonn"
+        repo_path = Path("/tmp/test-repo")
+        now = datetime.now(tz=timezone.utc)
+        pool.running_containers[dev_name] = {
+            "repo_path": repo_path,
+            "started_at": now,
+            "last_used": now,
+        }
+
+        # Mock the _cleanup_container method
+        pool._cleanup_container = AsyncMock()
+
+        # Simulate the finally block logic from _process_task_subprocess
+        async with pool._lock:
+            if dev_name in pool.running_containers:
+                if pool.config.stop_container_after_task:
+                    info = pool.running_containers[dev_name]
+                    # When stop_container_after_task=True, we stop but don't remove
+                    # container or workspace for faster restart
+                    await pool._cleanup_container(
+                        dev_name,
+                        info["repo_path"],
+                        remove_workspace=False,
+                        remove_container=False
+                    )
+                    del pool.running_containers[dev_name]
+
+        # Verify cleanup was called with stop-only parameters
+        pool._cleanup_container.assert_called_once_with(
+            dev_name, repo_path, remove_workspace=False, remove_container=False
+        )
+        # Verify container was removed from tracking
+        assert dev_name not in pool.running_containers
+
+
+@pytest.mark.asyncio
+async def test_container_not_stopped_when_disabled(mock_config_no_stop_after_task):
+    """Test that container is NOT stopped after task when stop_container_after_task is disabled."""
+    with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config_no_stop_after_task):
+        pool = ContainerPool()
+
+        # Cancel workers
+        for worker in pool.container_workers.values():
+            worker.cancel()
+        if pool.cleanup_worker:
+            pool.cleanup_worker.cancel()
+
+        # Simulate a running container being tracked
+        dev_name = "eamonn"
+        repo_path = Path("/tmp/test-repo")
+        initial_time = datetime.now(tz=timezone.utc)
+        pool.running_containers[dev_name] = {
+            "repo_path": repo_path,
+            "started_at": initial_time,
+            "last_used": initial_time,
+        }
+
+        # Mock the _cleanup_container method
+        pool._cleanup_container = AsyncMock()
+
+        # Simulate the finally block logic from _process_task_subprocess
+        async with pool._lock:
+            if dev_name in pool.running_containers:
+                if pool.config.stop_container_after_task:
+                    info = pool.running_containers[dev_name]
+                    await pool._cleanup_container(dev_name, info["repo_path"])
+                    del pool.running_containers[dev_name]
+                else:
+                    # Just update last_used timestamp (legacy behavior)
+                    pool.running_containers[dev_name]["last_used"] = datetime.now(tz=timezone.utc)
+
+        # Verify cleanup was NOT called
+        pool._cleanup_container.assert_not_called()
+        # Verify container is still being tracked
+        assert dev_name in pool.running_containers
+        # Verify last_used was updated
+        assert pool.running_containers[dev_name]["last_used"] > initial_time
+
+
+@pytest.mark.asyncio
+async def test_only_one_running_container_per_dev_name(mock_config_stop_after_task):
+    """Test that stop_container_after_task ensures only one container per dev name.
+
+    When enabled, after each task completes the container is stopped, so the next
+    task in the same queue will start a fresh container.
+    """
+    with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config_stop_after_task):
+        pool = ContainerPool()
+
+        # Cancel workers
+        for worker in pool.container_workers.values():
+            worker.cancel()
+        if pool.cleanup_worker:
+            pool.cleanup_worker.cancel()
+
+        dev_name = "eamonn"
+        repo_path_1 = Path("/tmp/test-repo-1")
+        repo_path_2 = Path("/tmp/test-repo-2")
+
+        # Mock cleanup
+        pool._cleanup_container = AsyncMock()
+
+        # Simulate first task starting
+        now = datetime.now(tz=timezone.utc)
+        pool.running_containers[dev_name] = {
+            "repo_path": repo_path_1,
+            "started_at": now,
+            "last_used": now,
+        }
+
+        # Simulate first task completing (with stop after task)
+        async with pool._lock:
+            if dev_name in pool.running_containers and pool.config.stop_container_after_task:
+                await pool._cleanup_container(
+                    dev_name,
+                    pool.running_containers[dev_name]["repo_path"],
+                    remove_workspace=False,
+                    remove_container=False
+                )
+                del pool.running_containers[dev_name]
+
+        # Container should be stopped
+        assert dev_name not in pool.running_containers
+        pool._cleanup_container.assert_called_once_with(
+            dev_name, repo_path_1, remove_workspace=False, remove_container=False
+        )
+
+        # Reset mock
+        pool._cleanup_container.reset_mock()
+
+        # Simulate second task starting (different repo)
+        now = datetime.now(tz=timezone.utc)
+        pool.running_containers[dev_name] = {
+            "repo_path": repo_path_2,
+            "started_at": now,
+            "last_used": now,
+        }
+
+        # Simulate second task completing
+        async with pool._lock:
+            if dev_name in pool.running_containers and pool.config.stop_container_after_task:
+                await pool._cleanup_container(
+                    dev_name,
+                    pool.running_containers[dev_name]["repo_path"],
+                    remove_workspace=False,
+                    remove_container=False
+                )
+                del pool.running_containers[dev_name]
+
+        # Container should be stopped again
+        assert dev_name not in pool.running_containers
+        pool._cleanup_container.assert_called_once_with(
+            dev_name, repo_path_2, remove_workspace=False, remove_container=False
+        )
+
+
+@pytest.mark.asyncio
+async def test_cleanup_error_handling(mock_config_stop_after_task):
+    """Test that cleanup errors are handled gracefully and don't crash the pool."""
+    with patch('devs_webhook.core.container_pool.get_config', return_value=mock_config_stop_after_task):
+        pool = ContainerPool()
+
+        # Cancel workers
+        for worker in pool.container_workers.values():
+            worker.cancel()
+        if pool.cleanup_worker:
+            pool.cleanup_worker.cancel()
+
+        dev_name = "eamonn"
+        repo_path = Path("/tmp/test-repo")
+        now = datetime.now(tz=timezone.utc)
+        pool.running_containers[dev_name] = {
+            "repo_path": repo_path,
+            "started_at": now,
+            "last_used": now,
+        }
+
+        # Mock cleanup to raise an exception
+        pool._cleanup_container = AsyncMock(side_effect=Exception("Cleanup failed"))
+
+        # Simulate the finally block - should not raise
+        try:
+            async with pool._lock:
+                if dev_name in pool.running_containers:
+                    if pool.config.stop_container_after_task:
+                        info = pool.running_containers[dev_name]
+                        try:
+                            await pool._cleanup_container(
+                                dev_name,
+                                info["repo_path"],
+                                remove_workspace=False,
+                                remove_container=False
+                            )
+                            del pool.running_containers[dev_name]
+                        except Exception:
+                            # Error is logged but not re-raised
+                            pass
+        except Exception as e:
+            pytest.fail(f"Cleanup error should be handled gracefully, but got: {e}")
+
+        # Container should still be tracked since cleanup failed
+        assert dev_name in pool.running_containers

{devs_webhook-1.2.0 → devs_webhook-2.0.0}/tests/test_webhook_parser.py

@@ -3,7 +3,8 @@
 import json
 import pytest
 from devs_webhook.github.parser import WebhookParser
-from devs_webhook.github.models import IssueEvent, CommentEvent
+from devs_webhook.github.models import IssueEvent, CommentEvent, PullRequestEvent
+from devs_common.devs_config import DevsOptions
 
 
 class TestWebhookParser:
@@ -172,7 +173,123 @@ class TestWebhookParser:
         payload = {"action": "test"}
         headers = {"x-github-event": "unsupported"}
         payload_bytes = json.dumps(payload).encode()
-        
+
         event = WebhookParser.parse_webhook(headers, payload_bytes)
         assert event is None
-    
+
+
+class TestCIProcessing:
+    """Test CI processing functionality."""
+
+    def _create_pr_payload(self, draft: bool = False, action: str = "opened"):
+        """Helper to create a PR payload."""
+        return {
+            "action": action,
+            "pull_request": {
+                "id": 1,
+                "number": 42,
+                "title": "Test PR",
+                "body": "Test PR description",
+                "state": "open",
+                "draft": draft,
+                "user": {
+                    "login": "developer",
+                    "id": 123,
+                    "avatar_url": "https://github.com/avatar.jpg",
+                    "html_url": "https://github.com/developer"
+                },
+                "assignee": None,
+                "html_url": "https://github.com/test/repo/pull/42",
+                "head": {"ref": "feature-branch", "sha": "abc123"},
+                "base": {"ref": "main", "sha": "def456"},
+                "created_at": "2023-01-01T00:00:00Z",
+                "updated_at": "2023-01-01T00:00:00Z"
+            },
+            "repository": {
+                "id": 789,
+                "name": "repo",
+                "full_name": "test/repo",
+                "owner": {
+                    "login": "test",
+                    "id": 111,
+                    "avatar_url": "https://github.com/avatar.jpg",
+                    "html_url": "https://github.com/test"
+                },
+                "html_url": "https://github.com/test/repo",
+                "clone_url": "https://github.com/test/repo.git",
+                "ssh_url": "git@github.com:test/repo.git",
+                "default_branch": "main"
+            },
+            "sender": {
+                "login": "developer",
+                "id": 123,
+                "avatar_url": "https://github.com/avatar.jpg",
+                "html_url": "https://github.com/developer"
+            }
+        }
+
+    def test_ci_skipped_for_draft_pr(self):
+        """Test that CI is skipped for draft PRs."""
+        payload = self._create_pr_payload(draft=True, action="opened")
+        headers = {"x-github-event": "pull_request"}
+        payload_bytes = json.dumps(payload).encode()
+
+        event = WebhookParser.parse_webhook(headers, payload_bytes)
+        devs_options = DevsOptions(ci_enabled=True)
+
+        should_process = WebhookParser.should_process_event_for_ci(event, devs_options)
+
+        assert should_process is False
+
+    def test_ci_runs_for_non_draft_pr(self):
+        """Test that CI runs for non-draft PRs."""
+        payload = self._create_pr_payload(draft=False, action="opened")
+        headers = {"x-github-event": "pull_request"}
+        payload_bytes = json.dumps(payload).encode()
+
+        event = WebhookParser.parse_webhook(headers, payload_bytes)
+        devs_options = DevsOptions(ci_enabled=True)
+
+        should_process = WebhookParser.should_process_event_for_ci(event, devs_options)
+
+        assert should_process is True
+
+    def test_ci_skipped_for_draft_pr_synchronize(self):
+        """Test that CI is skipped for draft PRs on synchronize action."""
+        payload = self._create_pr_payload(draft=True, action="synchronize")
+        headers = {"x-github-event": "pull_request"}
+        payload_bytes = json.dumps(payload).encode()
+
+        event = WebhookParser.parse_webhook(headers, payload_bytes)
+        devs_options = DevsOptions(ci_enabled=True)
+
+        should_process = WebhookParser.should_process_event_for_ci(event, devs_options)
+
+        assert should_process is False
+
+    def test_ci_runs_for_non_draft_pr_synchronize(self):
+        """Test that CI runs for non-draft PRs on synchronize action."""
+        payload = self._create_pr_payload(draft=False, action="synchronize")
+        headers = {"x-github-event": "pull_request"}
+        payload_bytes = json.dumps(payload).encode()
+
+        event = WebhookParser.parse_webhook(headers, payload_bytes)
+        devs_options = DevsOptions(ci_enabled=True)
+
+        should_process = WebhookParser.should_process_event_for_ci(event, devs_options)
+
+        assert should_process is True
+
+    def test_ci_not_processed_when_disabled(self):
+        """Test that CI is not processed when ci_enabled is False."""
+        payload = self._create_pr_payload(draft=False, action="opened")
+        headers = {"x-github-event": "pull_request"}
+        payload_bytes = json.dumps(payload).encode()
+
+        event = WebhookParser.parse_webhook(headers, payload_bytes)
+        devs_options = DevsOptions(ci_enabled=False)
+
+        should_process = WebhookParser.should_process_event_for_ci(event, devs_options)
+
+        assert should_process is False
+