roadmap-cli 0.1.1__py3-none-any.whl

roadmap/infrastructure/security/credentials.py

@@ -0,0 +1,489 @@
+"""Secure credential management for GitHub tokens."""
+
+import os
+import platform
+import subprocess
+
+from roadmap.common.errors import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class CredentialManagerError(Exception):
+    """Exception raised for credential manager errors."""
+
+    pass
+
+
+class CredentialManager:
+    """Cross-platform secure credential manager."""
+
+    SERVICE_NAME = "roadmap-cli"
+    ACCOUNT_NAME = "github-token"
+
+    def __init__(self):
+        """Initialize credential manager."""
+        self.system = platform.system().lower()
+
+    @safe_operation(OperationType.SAVE, "Token", include_traceback=True)
+    def store_token(self, token: str, repo_info: dict[str, str] | None = None) -> bool:
+        """Store GitHub token securely.
+
+        Args:
+            token: GitHub personal access token
+            repo_info: Optional repository information (owner, repo)
+
+        Returns:
+            True if stored successfully, False otherwise
+
+        Raises:
+            CredentialManagerError: If token storage fails
+        """
+        logger.info("storing_github_token")
+        try:
+            if self.system == "darwin":
+                result = self._store_token_keychain(token, repo_info)
+            elif self.system == "windows":
+                result = self._store_token_wincred(token, repo_info)
+            elif self.system == "linux":
+                result = self._store_token_secretservice(token, repo_info)
+            else:
+                # Fallback for unsupported systems
+                result = self._store_token_fallback(token, repo_info)
+
+            logger.info("github_token_stored", system=self.system)
+            return result
+        except Exception as e:
+            logger.error(
+                "github_token_store_failed",
+                error=str(e),
+                system=self.system,
+                severity="config_error",
+            )
+            raise CredentialManagerError(f"Failed to store token: {e}") from e
+
+    def get_token(self) -> str | None:
+        """Retrieve GitHub token securely.
+
+        Returns:
+            GitHub token if found, None otherwise
+        """
+        try:
+            # Always check environment variable first
+            env_token = os.getenv("GITHUB_TOKEN")
+            if env_token:
+                logger.debug("github_token_retrieved_from_env")
+                return env_token
+
+            if self.system == "darwin":
+                token = self._get_token_keychain()
+            elif self.system == "windows":
+                token = self._get_token_wincred()
+            elif self.system == "linux":
+                token = self._get_token_secretservice()
+            else:
+                # Fallback for unsupported systems
+                token = self._get_token_fallback()
+
+            if token:
+                logger.debug("github_token_retrieved", system=self.system)
+            else:
+                logger.debug("github_token_not_found", system=self.system)
+
+            return token
+        except Exception as e:
+            # Silently fail and return None - credential retrieval should be non-blocking
+            logger.warning(
+                "github_token_retrieval_failed",
+                error=str(e),
+                system=self.system,
+                severity="operational",
+            )
+            return None
+
+    @safe_operation(OperationType.DELETE, "Token")
+    def delete_token(self) -> bool:
+        """Delete stored GitHub token.
+
+        Returns:
+            True if deleted successfully, False otherwise
+
+        Raises:
+            CredentialManagerError: If token deletion fails
+        """
+        logger.info("deleting_github_token")
+        try:
+            if self.system == "darwin":
+                result = self._delete_token_keychain()
+            elif self.system == "windows":
+                result = self._delete_token_wincred()
+            elif self.system == "linux":
+                result = self._delete_token_secretservice()
+            else:
+                # Fallback for unsupported systems
+                result = self._delete_token_fallback()
+
+            logger.info("github_token_deleted", system=self.system, success=result)
+            return result
+        except Exception as e:
+            logger.error(
+                "github_token_deletion_failed",
+                error=str(e),
+                system=self.system,
+                severity="config_error",
+            )
+            raise CredentialManagerError(f"Failed to delete token: {e}") from e
+
+    def is_available(self) -> bool:
+        """Check if credential manager is available on this system.
+
+        Returns:
+            True if credential manager is available, False otherwise
+        """
+        try:
+            if self.system == "darwin":
+                return self._check_keychain_available()
+            elif self.system == "windows":
+                return self._check_wincred_available()
+            elif self.system == "linux":
+                return self._check_secretservice_available()
+            else:
+                return False
+        except Exception as e:
+            logger.debug("secretservice_availability_check_failed", error=str(e))
+            return False
+
+    # macOS Keychain implementation
+    def _store_token_keychain(
+        self, token: str, repo_info: dict[str, str] | None = None
+    ) -> bool:
+        """Store token in macOS Keychain."""
+        cmd = [
+            "security",
+            "add-generic-password",
+            "-s",
+            self.SERVICE_NAME,
+            "-a",
+            self.ACCOUNT_NAME,
+            "-w",
+            token,
+            "-U",  # Update if exists
+        ]
+
+        if repo_info:
+            # Add repository info as a comment
+            comment = f"GitHub token for {repo_info.get('owner', '')}/{repo_info.get('repo', '')}"
+            cmd.extend(["-j", comment])
+
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        return result.returncode == 0
+
+    def _get_token_keychain(self) -> str | None:
+        """Get token from macOS Keychain."""
+        cmd = [
+            "security",
+            "find-generic-password",
+            "-s",
+            self.SERVICE_NAME,
+            "-a",
+            self.ACCOUNT_NAME,
+            "-w",  # Output password only
+        ]
+
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+
+    def _delete_token_keychain(self) -> bool:
+        """Delete token from macOS Keychain."""
+        cmd = [
+            "security",
+            "delete-generic-password",
+            "-s",
+            self.SERVICE_NAME,
+            "-a",
+            self.ACCOUNT_NAME,
+        ]
+
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        return result.returncode == 0
+
+    def _check_keychain_available(self) -> bool:
+        """Check if macOS Keychain is available."""
+        try:
+            result = subprocess.run(["security", "-h"], capture_output=True, text=True)
+            return result.returncode == 0
+        except FileNotFoundError as e:
+            logger.debug("security_command_not_found", error=str(e))
+            return False
+
+    # Windows Credential Manager implementation
+    def _store_token_wincred(
+        self, token: str, repo_info: dict[str, str] | None = None
+    ) -> bool:
+        """Store token in Windows Credential Manager."""
+        try:
+            import keyring
+
+            try:
+                from keyring.errors import NoKeyringError
+            except Exception:
+                NoKeyringError = None
+
+            target_name = f"{self.SERVICE_NAME}:{self.ACCOUNT_NAME}"
+            if repo_info:
+                target_name += (
+                    f":{repo_info.get('owner', '')}/{repo_info.get('repo', '')}"
+                )
+
+            try:
+                keyring.set_password(self.SERVICE_NAME, target_name, token)
+                return True
+            except Exception as e:
+                if NoKeyringError and isinstance(e, NoKeyringError):
+                    logger.debug("keyring_no_backend_store_wincred", error=str(e))
+                    return self._store_token_cmdkey(token, repo_info)
+                logger.debug("keyring_store_wincred_failed", error=str(e))
+                return False
+        except ImportError as e:
+            logger.debug("keyring_import_failed_keychain", error=str(e))
+            # Fallback to cmdkey if keyring not available
+            return self._store_token_cmdkey(token, repo_info)
+
+    def _get_token_wincred(self) -> str | None:
+        """Get token from Windows Credential Manager."""
+        try:
+            import keyring
+
+            try:
+                from keyring.errors import NoKeyringError
+            except Exception:
+                NoKeyringError = None
+
+            target_name = f"{self.SERVICE_NAME}:{self.ACCOUNT_NAME}"
+            try:
+                return keyring.get_password(self.SERVICE_NAME, target_name)
+            except Exception as e:
+                if NoKeyringError and isinstance(e, NoKeyringError):
+                    logger.debug("keyring_no_backend_get_wincred", error=str(e))
+                    return self._get_token_cmdkey()
+                logger.debug("keyring_get_wincred_failed", error=str(e))
+                return None
+        except ImportError as e:
+            logger.debug("keyring_import_failed_get_wincred", error=str(e))
+            # Fallback to cmdkey if keyring not available
+            return self._get_token_cmdkey()
+
+    def _delete_token_wincred(self) -> bool:
+        """Delete token from Windows Credential Manager."""
+        try:
+            import keyring
+
+            try:
+                from keyring.errors import NoKeyringError
+            except Exception:
+                NoKeyringError = None
+
+            target_name = f"{self.SERVICE_NAME}:{self.ACCOUNT_NAME}"
+            try:
+                keyring.delete_password(self.SERVICE_NAME, target_name)
+                return True
+            except Exception as e:
+                if NoKeyringError and isinstance(e, NoKeyringError):
+                    logger.debug("keyring_no_backend_delete_wincred", error=str(e))
+                    return self._delete_token_cmdkey()
+                logger.debug("keyring_delete_wincred_failed", error=str(e))
+                return False
+        except ImportError as e:
+            logger.debug("keyring_import_failed_delete_wincred", error=str(e))
+            # Fallback to cmdkey if keyring not available
+            return self._delete_token_cmdkey()
+        except Exception as e:
+            logger.error(
+                "wincred_token_deletion_failed", error=str(e), severity="config_error"
+            )
+            return False
+
+    def _check_wincred_available(self) -> bool:
+        """Check if Windows Credential Manager is available."""
+        try:
+            return True
+        except ImportError as e:
+            logger.debug("keyring_import_failed_check_wincred", error=str(e))
+            try:
+                result = subprocess.run(
+                    ["cmdkey", "/?"], capture_output=True, text=True
+                )
+                return result.returncode == 0
+            except FileNotFoundError as e:
+                logger.debug("cmdkey_not_found", error=str(e))
+                return False
+
+    def _store_token_cmdkey(
+        self, token: str, repo_info: dict[str, str] | None = None
+    ) -> bool:
+        """Store token using Windows cmdkey."""
+        target_name = self.SERVICE_NAME
+        if repo_info:
+            target_name += f":{repo_info.get('owner', '')}/{repo_info.get('repo', '')}"
+
+        cmd = [
+            "cmdkey",
+            f"/generic:{target_name}",
+            f"/user:{self.ACCOUNT_NAME}",
+            f"/pass:{token}",
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        return result.returncode == 0
+
+    def _get_token_cmdkey(self) -> str | None:
+        """Get token using Windows cmdkey (limited functionality)."""
+        # cmdkey doesn't provide a way to retrieve passwords, only store/delete
+        # This is a limitation of the cmdkey approach
+        return None
+
+    def _delete_token_cmdkey(self) -> bool:
+        """Delete token using Windows cmdkey."""
+        cmd = ["cmdkey", f"/delete:{self.SERVICE_NAME}"]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        return result.returncode == 0
+
+    # Linux Secret Service implementation
+    def _store_token_secretservice(
+        self, token: str, repo_info: dict[str, str] | None = None
+    ) -> bool:
+        """Store token in Linux Secret Service."""
+        try:
+            import keyring
+
+            try:
+                from keyring.errors import NoKeyringError
+            except Exception:
+                NoKeyringError = None
+
+            target_name = f"{self.SERVICE_NAME}:{self.ACCOUNT_NAME}"
+            if repo_info:
+                target_name += (
+                    f":{repo_info.get('owner', '')}/{repo_info.get('repo', '')}"
+                )
+
+            try:
+                keyring.set_password(self.SERVICE_NAME, target_name, token)
+                return True
+            except Exception as e:
+                if NoKeyringError and isinstance(e, NoKeyringError):
+                    logger.debug("keyring_no_backend_store_secretservice", error=str(e))
+                    return self._store_token_fallback(token, repo_info)
+                logger.debug("keyring_store_secretservice_failed", error=str(e))
+                return False
+        except ImportError as e:
+            logger.debug("keyring_import_failed_store_secretservice", error=str(e))
+            # Fallback if keyring not available
+            return self._store_token_fallback(token, repo_info)
+
+    def _get_token_secretservice(self) -> str | None:
+        """Get token from Linux Secret Service."""
+        try:
+            import keyring
+
+            try:
+                from keyring.errors import NoKeyringError
+            except Exception:
+                NoKeyringError = None
+
+            target_name = f"{self.SERVICE_NAME}:{self.ACCOUNT_NAME}"
+            try:
+                return keyring.get_password(self.SERVICE_NAME, target_name)
+            except Exception as e:
+                if NoKeyringError and isinstance(e, NoKeyringError):
+                    logger.debug("keyring_no_backend_get_secretservice", error=str(e))
+                    return self._get_token_fallback()
+                logger.debug("keyring_get_secretservice_failed", error=str(e))
+                return None
+        except ImportError as e:
+            logger.debug("keyring_import_failed_get_secretservice", error=str(e))
+            # Fallback if keyring not available
+            return self._get_token_fallback()
+
+    def _delete_token_secretservice(self) -> bool:
+        """Delete token from Linux Secret Service."""
+        try:
+            import keyring
+
+            try:
+                from keyring.errors import NoKeyringError
+            except Exception:
+                NoKeyringError = None
+
+            target_name = f"{self.SERVICE_NAME}:{self.ACCOUNT_NAME}"
+            try:
+                keyring.delete_password(self.SERVICE_NAME, target_name)
+                return True
+            except Exception as e:
+                if NoKeyringError and isinstance(e, NoKeyringError):
+                    logger.debug(
+                        "keyring_no_backend_delete_secretservice", error=str(e)
+                    )
+                    return self._delete_token_fallback()
+                logger.debug("keyring_delete_secretservice_failed", error=str(e))
+                return False
+        except ImportError as e:
+            logger.debug("keyring_import_failed_delete_token", error=str(e))
+            # Fallback if keyring not available
+            return self._delete_token_fallback()
+        except Exception as e:
+            logger.debug("delete_token_secretservice_failed", error=str(e))
+            return False
+
+    def _check_secretservice_available(self) -> bool:
+        """Check if Linux Secret Service is available."""
+        try:
+            import keyring
+
+            # Try to access the keyring to see if it's functional
+            keyring.get_keyring()
+            return True
+        except ImportError as e:
+            logger.debug("keyring_import_failed_check_available", error=str(e))
+            return False
+        except Exception as e:
+            logger.debug("check_secretservice_available_failed", error=str(e))
+            return False
+
+    # Fallback implementation for unsupported systems
+    def _store_token_fallback(
+        self, token: str, repo_info: dict[str, str] | None = None
+    ) -> bool:
+        """Fallback token storage (warns user to use environment variable)."""
+        # Don't actually store - just return False to indicate secure storage unavailable
+        return False
+
+    def _get_token_fallback(self) -> str | None:
+        """Fallback token retrieval (environment variable only)."""
+        return os.getenv("GITHUB_TOKEN")
+
+    def _delete_token_fallback(self) -> bool:
+        """Fallback token deletion (no-op)."""
+        return True
+
+
+def get_credential_manager() -> CredentialManager:
+    """Get a credential manager instance."""
+    return CredentialManager()
+
+
+def mask_token(token: str) -> str:
+    """Mask a token for display purposes.
+
+    Args:
+        token: Token to mask
+
+    Returns:
+        Masked token showing only last 4 characters
+    """
+    if not token or len(token) < 8:
+        return "****"
+
+    return f"****{token[-4:]}"

roadmap/infrastructure/sync_gateway.py

@@ -0,0 +1,94 @@
+"""Gateway to sync adapter layer for core services.
+
+This module mediates all core service access to sync adapter implementations,
+ensuring proper layer separation between Core and Adapters layers.
+
+All imports from roadmap.adapters.sync are localized to this module.
+Core services import from this gateway instead of directly from adapters.
+"""
+
+from typing import Any, Literal
+
+
+class SyncGateway:
+    """Gateway for sync adapter operations.
+
+    Provides a centralized interface for core services to access sync
+    backend and orchestration functionality without direct adapter imports.
+    """
+
+    @staticmethod
+    def get_sync_backend(
+        backend_type: Literal["github", "git"], core: Any, config: Any
+    ) -> Any:
+        """Get a sync backend for the specified type.
+
+        Args:
+            backend_type: Type of backend (e.g., "github", "git")
+            core: Core context object
+            config: Configuration for the backend
+
+        Returns:
+            Backend instance or None if not available
+        """
+        from roadmap.adapters.sync.backend_factory import get_sync_backend
+
+        return get_sync_backend(backend_type, core, config)
+
+    @staticmethod
+    def create_sync_cache_orchestrator(
+        core: Any,
+        backend: Any,
+        conflict_resolver: Any = None,
+        state_comparator: Any = None,
+        show_progress: bool = True,
+        **kwargs: Any,
+    ) -> Any:
+        """Create a sync cache orchestrator for three-way merge sync operations.
+
+        Args:
+            core: Core context object
+            backend: Sync backend instance
+            conflict_resolver: Resolver for sync conflicts (optional)
+            state_comparator: Comparator for sync states (optional)
+            show_progress: Whether to show progress during sync (default: True)
+            **kwargs: Additional keyword arguments passed to orchestrator
+
+        Returns:
+            SyncCacheOrchestrator instance
+        """
+        from roadmap.adapters.sync.sync_cache_orchestrator import (
+            SyncCacheOrchestrator,
+        )
+
+        return SyncCacheOrchestrator(
+            core,
+            backend,
+            conflict_resolver=conflict_resolver,
+            state_comparator=state_comparator,
+            show_progress=show_progress,
+            **kwargs,
+        )
+
+    @staticmethod
+    def link_issue_in_database(
+        repo: Any, local_id: str, backend: Any, remote_id: str
+    ) -> bool:
+        """Link an issue in the database for sync tracking.
+
+        Args:
+            repo: Database repository
+            local_id: Local issue identifier
+            backend: Sync backend
+            remote_id: Remote issue identifier
+
+        Returns:
+            True if linking was successful
+        """
+        from roadmap.adapters.sync.services.sync_linking_service import (
+            SyncLinkingService,
+        )
+
+        return SyncLinkingService.link_issue_in_database(
+            repo, local_id, backend, remote_id
+        )

roadmap/infrastructure/validation/__init__.py

@@ -0,0 +1,7 @@
+"""Validation layer - Data and configuration validation.
+
+This module provides:
+- GitHub validators: GitHub API client and assignee validation
+- Validators: Assignee, assignee pool, and milestone consistency validation
+- File enumeration: Directory and file structure validation
+"""