Skip to content

πŸ™Œ OpenHands: AI-Driven Development

Add V1 git routes with pagination for installations and repositories (#13790)

Tim O'Farrell4e68f578075e
diff --git a/enterprise/server/routes/user.py b/enterprise/server/routes/user.py
index f98f73f4b8..c88878f5d4 100644
--- a/enterprise/server/routes/user.py
+++ b/enterprise/server/routes/user.py
@@ -45,7 +45,12 @@ saas_user_router = APIRouter(prefix='/api/user', dependencies=get_dependencies()
token_manager = TokenManager()
-@saas_user_router.get('/installations', response_model=list[str])
+@saas_user_router.get(
+ '/installations',
+ response_model=list[str],
+ deprecated=True,
+ description='Deprecated: Use `/api/v1/git/installations` instead.',
+)
async def saas_get_user_installations(
provider: ProviderType,
provider_tokens: PROVIDER_TOKEN_TYPE | None = Depends(get_provider_tokens),
@@ -115,7 +120,12 @@ async def saas_get_user_git_organizations(
}
-@saas_user_router.get('/repositories', response_model=list[Repository])
+@saas_user_router.get(
+ '/repositories',
+ response_model=list[Repository],
+ deprecated=True,
+ description='Deprecated: Use `/api/v1/git/repositories` instead.',
+)
async def saas_get_user_repositories(
sort: str = 'pushed',
selected_provider: ProviderType | None = None,
diff --git a/openhands/app_server/git/git_models.py b/openhands/app_server/git/git_models.py
new file mode 100644
index 0000000000..6f35ae3bde
--- /dev/null
+++ b/openhands/app_server/git/git_models.py
@@ -0,0 +1,29 @@
+"""Git-related models for V1 API pagination responses."""
+
+from pydantic import BaseModel
+
+from openhands.integrations.service_types import Repository
+
+
+class InstallationPage(BaseModel):
+ """Paginated response for installations.
+
+ Attributes:
+ items: List of installation IDs.
+ next_page_id: ID for the next page, or None if there are no more pages.
+ """
+
+ items: list[str]
+ next_page_id: str | None = None
+
+
+class RepositoryPage(BaseModel):
+ """Paginated response for repositories.
+
+ Attributes:
+ items: List of repositories in the current page.
+ next_page_id: ID for the next page, or None if there are no more pages.
+ """
+
+ items: list[Repository]
+ next_page_id: str | None = None
diff --git a/openhands/app_server/git/git_router.py b/openhands/app_server/git/git_router.py
new file mode 100644
index 0000000000..f848b386a6
--- /dev/null
+++ b/openhands/app_server/git/git_router.py
@@ -0,0 +1,147 @@
+"""Git router for OpenHands App Server V1 API.
+
+This module provides V1 API endpoints for Git operations (installations, repositories)
+with pagination support. These endpoints are designed to replace the legacy V0 endpoints
+in openhands/server/routes/git.py.
+"""
+
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Annotated
+
+from fastapi import APIRouter, HTTPException, Query, status
+
+from openhands.app_server.config import depends_user_context, get_global_config
+from openhands.app_server.git.git_models import (
+ InstallationPage,
+ RepositoryPage,
+)
+from openhands.app_server.user.user_context import UserContext
+from openhands.app_server.utils.dependencies import get_dependencies
+from openhands.app_server.utils.paging_utils import (
+ decode_page_id,
+ encode_page_id,
+ paginate_results,
+)
+from openhands.integrations.provider import ProviderHandler
+from openhands.integrations.service_types import ProviderType
+
+if TYPE_CHECKING:
+ from openhands.integrations.provider import PROVIDER_TOKEN_TYPE
+
+# We use the get_dependencies method here to signal to the OpenAPI docs that this endpoint
+# is protected. The actual protection is provided by SetAuthCookieMiddleware
+router = APIRouter(
+ prefix='/git',
+ tags=['Git'],
+ dependencies=get_dependencies(),
+)
+user_context_dependency = depends_user_context()
+
+
[email protected]('/installations')
+async def get_user_installations(
+ provider: ProviderType,
+ page_id: Annotated[
+ str | None,
+ Query(title='Optional next_page_id from the previously returned page'),
+ ] = None,
+ limit: Annotated[
+ int,
+ Query(title='The max number of results in the page', gt=0, le=100),
+ ] = 100,
+ user_context: UserContext = user_context_dependency,
+) -> InstallationPage:
+ """Get user installations (GitHub apps) or equivalent for other providers.
+
+ Returns a paginated list of installation IDs or workspace IDs depending on the provider.
+ """
+ # Get provider tokens from user context
+ provider_tokens = await user_context.get_provider_tokens()
+ if not provider_tokens:
+ raise HTTPException(
+ status_code=status.HTTP_401_UNAUTHORIZED,
+ detail='Git provider token required (such as GitHub).',
+ )
+
+ user_id = await user_context.get_user_id()
+ # Wrap in MappingProxyType as required by ProviderHandler
+ # Type ignore: we validated provider_tokens exists, but mypy can't narrow the union type
+ client = ProviderHandler(
+ provider_tokens=MappingProxyType(provider_tokens), # type: ignore[arg-type]
+ external_auth_id=user_id,
+ )
+
+ if provider == ProviderType.GITHUB:
+ installations = await client.get_github_installations()
+ elif provider == ProviderType.BITBUCKET:
+ installations = await client.get_bitbucket_workspaces()
+ elif provider == ProviderType.BITBUCKET_DATA_CENTER:
+ installations = await client.get_bitbucket_dc_projects()
+ elif provider == ProviderType.AZURE_DEVOPS:
+ installations = await client.get_azure_devops_organizations()
+ else:
+ raise HTTPException(
+ status_code=status.HTTP_400_BAD_REQUEST,
+ detail=f"Provider {provider} doesn't support installations",
+ )
+
+ items, next_page_id = paginate_results(installations, page_id, limit)
+ return InstallationPage(items=items, next_page_id=next_page_id)
+
+
[email protected]('/repositories')
+async def get_user_repositories(
+ provider: ProviderType,
+ sort: str = 'pushed',
+ installation_id: str | None = None,
+ page_id: Annotated[
+ str | None,
+ Query(title='Optional next_page_id from the previously returned page'),
+ ] = None,
+ limit: Annotated[
+ int,
+ Query(title='The max number of results in the page', gt=0, le=100),
+ ] = 100,
+ user_context: UserContext = user_context_dependency,
+) -> RepositoryPage:
+ """Get user repositories.
+
+ Returns a paginated list of repositories for the authenticated user.
+ """
+ # Get provider tokens from user context
+ provider_tokens = await user_context.get_provider_tokens()
+ if not provider_tokens:
+ raise HTTPException(
+ status_code=status.HTTP_401_UNAUTHORIZED,
+ detail='Git provider token required (such as GitHub).',
+ )
+
+ user_id = await user_context.get_user_id()
+ # Cast to the expected type since we validated provider_tokens exists
+ typed_provider_tokens: PROVIDER_TOKEN_TYPE = provider_tokens # type: ignore[assignment]
+ client = ProviderHandler(
+ provider_tokens=MappingProxyType(typed_provider_tokens),
+ external_auth_id=user_id,
+ )
+
+ page = 1
+ decoded_page_id = decode_page_id(page_id)
+ if decoded_page_id is not None:
+ page = decoded_page_id
+
+ # Get repositories - we'll handle pagination ourselves
+ items = await client.get_repositories(
+ sort=sort,
+ app_mode=get_global_config().app_mode,
+ selected_provider=provider,
+ page=page,
+ per_page=limit + 1, # We'll handle pagination ourselves
+ installation_id=installation_id,
+ )
+
+ next_page_id = None
+ if len(items) > limit:
+ items = items[:-1]
+ next_page_id = encode_page_id(page + 1)
+
+ return RepositoryPage(items=items, next_page_id=next_page_id)
diff --git a/openhands/app_server/secrets/secrets_router.py b/openhands/app_server/secrets/secrets_router.py
index 75d14fd587..0da621deb9 100644
--- a/openhands/app_server/secrets/secrets_router.py
+++ b/openhands/app_server/secrets/secrets_router.py
@@ -88,7 +88,7 @@ async def check_provider_tokens(
@router.post(
'/git-providers',
- tags=['Git Providers'],
+ tags=['Git'],
)
async def store_provider_tokens(
provider_info: POSTProviderModel,
@@ -136,7 +136,7 @@ async def store_provider_tokens(
@router.delete(
'/git-providers',
- tags=['Git Providers'],
+ tags=['Git'],
)
async def unset_provider_tokens(
secrets_store: SecretsStore = Depends(get_secrets_store),
diff --git a/openhands/app_server/utils/paging_utils.py b/openhands/app_server/utils/paging_utils.py
new file mode 100644
index 0000000000..2e3e4e0db8
--- /dev/null
+++ b/openhands/app_server/utils/paging_utils.py
@@ -0,0 +1,81 @@
+"""Pagination utilities for OpenHands App Server.
+
+This module provides utilities for handling pagination in API responses.
+The page_id is designed to be an opaque token - external consumers should not
+infer details of the underlying pagination strategy (e.g., offset vs page number)
+from the page_id contents, as this may change in the future.
+"""
+
+import base64
+
+
+def encode_page_id(value: int) -> str:
+ """Encode an integer page identifier as an opaque base64 string.
+
+ This function exists to ensure that page IDs are opaque tokens that do not
+ reveal the underlying pagination strategy to API consumers. The encoding
+ format may change in the future, so consumers should treat page_id as an
+ opaque string and not attempt to parse or construct it themselves.
+
+ Args:
+ value: The integer value to encode.
+
+ Returns:
+ Base64-encoded string (URL-safe, without padding).
+ """
+ return base64.urlsafe_b64encode(str(value).encode()).decode().rstrip('=')
+
+
+def decode_page_id(page_id: str | None) -> int | None:
+ """Decode an opaque page identifier back to an integer.
+
+ This function exists to support the internal decoding of page IDs.
+ External consumers should not need to call this function directly - they
+ should pass the page_id string received from a previous response back to
+ the API to get the next page of results.
+
+ Note: The encoding format may change in the future, so this function
+ should not be used to construct page_ids externally.
+
+ Args:
+ page_id: The base64-encoded page ID string.
+
+ Returns:
+ The decoded integer value, or None if page_id is None/empty.
+ """
+ if not page_id:
+ return None
+ try:
+ # Add padding back if needed
+ padded = page_id + '=' * (4 - len(page_id) % 4)
+ decoded = base64.urlsafe_b64decode(padded.encode()).decode()
+ return int(decoded)
+ except (ValueError, Exception):
+ return None
+
+
+def paginate_results(
+ items: list, page_id: str | None, limit: int
+) -> tuple[list, str | None]:
+ """Apply pagination to a list of items.
+
+ Args:
+ items: Full list of items to paginate.
+ page_id: Optional page token from previous request.
+ limit: Maximum number of items per page.
+
+ Returns:
+ Tuple of (paginated_items, next_page_id).
+ """
+ start_offset = 0
+ decoded_page_id = decode_page_id(page_id)
+ if decoded_page_id is not None:
+ start_offset = decoded_page_id
+
+ end_offset = start_offset + limit
+ paginated_items = items[start_offset:end_offset]
+ next_page_id = None
+ if end_offset < len(items):
+ next_page_id = encode_page_id(end_offset)
+
+ return paginated_items, next_page_id
diff --git a/openhands/app_server/v1_router.py b/openhands/app_server/v1_router.py
index 8d1681173b..292b77b2e1 100644
--- a/openhands/app_server/v1_router.py
+++ b/openhands/app_server/v1_router.py
@@ -5,6 +5,7 @@ from openhands.app_server.event import event_router
from openhands.app_server.event_callback import (
webhook_router,
)
+from openhands.app_server.git.git_router import router as git_router
from openhands.app_server.pending_messages.pending_message_router import (
router as pending_message_router,
)
@@ -31,3 +32,4 @@ router.include_router(user_router.router)
router.include_router(skills_router.router)
router.include_router(webhook_router.router)
router.include_router(web_client_router.router)
+router.include_router(git_router)
diff --git a/openhands/server/routes/git.py b/openhands/server/routes/git.py
index b4a4084c57..fa344b845d 100644
--- a/openhands/server/routes/git.py
+++ b/openhands/server/routes/git.py
@@ -43,7 +43,12 @@ from openhands.server.user_auth import (
app = APIRouter(prefix='/api/user', dependencies=get_dependencies())
[email protected]('/installations', response_model=list[str])
+ '/installations',
+ response_model=list[str],
+ deprecated=True,
+ description='Deprecated: Use `/api/v1/git/installations` instead.',
+)
async def get_user_installations(
provider: ProviderType,
provider_tokens: PROVIDER_TOKEN_TYPE | None = Depends(get_provider_tokens),
@@ -74,7 +79,12 @@ async def get_user_installations(
raise AuthenticationError('Git provider token required. (such as GitHub).')
[email protected]('/repositories', response_model=list[Repository])
+ '/repositories',
+ response_model=list[Repository],
+ deprecated=True,
+ description='Deprecated: Use `/api/v1/git/repositories` instead.',
+)
async def get_user_repositories(
sort: str = 'pushed',
selected_provider: Annotated[ProviderType | None, Query()] = None,
diff --git a/tests/unit/app_server/test_git_router.py b/tests/unit/app_server/test_git_router.py
new file mode 100644
index 0000000000..b62dbcae40
--- /dev/null
+++ b/tests/unit/app_server/test_git_router.py
@@ -0,0 +1,438 @@
+"""Unit tests for the git_router endpoints.
+
+This module tests the git router endpoints,
+focusing on pagination and error handling.
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import FastAPI, status
+from fastapi.testclient import TestClient
+
+from openhands.app_server.git.git_router import (
+ get_user_installations,
+ get_user_repositories,
+ router,
+)
+from openhands.app_server.user.user_context import UserContext
+from openhands.app_server.utils.dependencies import check_session_api_key
+from openhands.app_server.utils.paging_utils import encode_page_id, paginate_results
+from openhands.integrations.provider import ProviderToken
+from openhands.integrations.service_types import ProviderType, Repository
+
+
+class TestPagination:
+ """Test suite for pagination helper function."""
+
+ def test_returns_first_page_when_no_page_id(self):
+ """Test that first page is returned when no page_id is provided."""
+ items = ['a', 'b', 'c', 'd', 'e']
+
+ result, next_page_id = paginate_results(items, None, 2)
+
+ assert result == ['a', 'b']
+ # next_page_id is base64-encoded
+ assert next_page_id == encode_page_id(2)
+
+ def test_returns_second_page_when_page_id_provided(self):
+ """Test that correct page is returned when page_id is provided."""
+ items = ['a', 'b', 'c', 'd', 'e']
+ # Use base64-encoded page_id
+ encoded_page_id = encode_page_id(2)
+
+ result, next_page_id = paginate_results(items, encoded_page_id, 2)
+
+ assert result == ['c', 'd']
+ assert next_page_id == encode_page_id(4)
+
+ def test_returns_empty_when_page_id_exceeds_length(self):
+ """Test that empty list is returned when page_id exceeds length."""
+ items = ['a', 'b', 'c']
+ # Use base64-encoded page_id
+ encoded_page_id = encode_page_id(10)
+
+ result, next_page_id = paginate_results(items, encoded_page_id, 2)
+
+ assert result == []
+ assert next_page_id is None
+
+ def test_returns_none_next_page_when_last_page(self):
+ """Test that next_page_id is None on last page."""
+ items = ['a', 'b', 'c']
+ # Use base64-encoded page_id
+ encoded_page_id = encode_page_id(2)
+
+ result, next_page_id = paginate_results(items, encoded_page_id, 2)
+
+ assert result == ['c']
+ assert next_page_id is None
+
+ def test_respects_limit(self):
+ """Test that limit is respected."""
+ items = ['a', 'b', 'c', 'd', 'e']
+
+ result, next_page_id = paginate_results(items, None, 5)
+
+ assert result == items
+ assert next_page_id is None
+
+
+def _make_mock_user_context(
+ provider_tokens: dict | None = None,
+ user_id: str = 'test-user-id',
+):
+ """Create a mock UserContext for testing."""
+ context = MagicMock(spec=UserContext)
+ context.get_provider_tokens = AsyncMock(return_value=provider_tokens)
+ context.get_user_id = AsyncMock(return_value=user_id)
+ return context
+
+
+def _make_mock_provider_handler():
+ """Create a mock ProviderHandler."""
+ handler = MagicMock()
+ handler.get_github_installations = AsyncMock(
+ return_value=['inst-1', 'inst-2', 'inst-3', 'inst-4', 'inst-5']
+ )
+ handler.get_bitbucket_workspaces = AsyncMock(return_value=['ws-1', 'ws-2'])
+ handler.get_repositories = AsyncMock(return_value=[])
+ return handler
+
+
+def test_client():
+ """Create a test client with the actual git router and mocked dependencies.
+
+ We override check_session_api_key to bypass auth checks.
+ This allows us to test the actual Query parameter validation in the router.
+ """
+ app = FastAPI()
+ app.include_router(router)
+
+ # Override the auth dependency to always pass
+ app.dependency_overrides[check_session_api_key] = lambda: None
+
+ client = TestClient(app, raise_server_exceptions=False)
+ yield client
+
+ # Clean up
+ app.dependency_overrides.clear()
+
+
+class TestInstallationsEndpoint:
+ """Test suite for /installations endpoint."""
+
+ def test_returns_401_when_no_provider_tokens(self, test_client, monkeypatch):
+ """Test that 401 is returned when no provider tokens."""
+ mock_context = _make_mock_user_context(provider_tokens=None)
+ monkeypatch.setattr(
+ 'openhands.app_server.git.git_router.depends_user_context',
+ lambda: mock_context,
+ )
+
+ response = test_client.get('/git/installations', params={'provider': 'github'})
+
+ assert response.status_code == status.HTTP_401_UNAUTHORIZED
+
+ def test_returns_422_for_unsupported_provider(self, test_client, monkeypatch):
+ """Test that 422 is returned for unsupported provider."""
+ mock_context = _make_mock_user_context(provider_tokens={'github': 'token'})
+
+ # Patch the ProviderHandler
+ monkeypatch.setattr(
+ 'openhands.app_server.git.git_router.depends_user_context',
+ lambda: mock_context,
+ )
+
+ response = test_client.get('/git/installations', params={'provider': 'invalid'})
+ assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+
+
+class TestRepositoriesEndpoint:
+ """Test suite for /repositories endpoint."""
+
+ def test_returns_401_when_no_provider_tokens(self, test_client, monkeypatch):
+ """Test that 401 is returned when no provider tokens."""
+ mock_context = _make_mock_user_context(provider_tokens=None)
+ monkeypatch.setattr(
+ 'openhands.app_server.git.git_router.depends_user_context',
+ lambda: mock_context,
+ )
+
+ response = test_client.get('/git/repositories', params={'provider': 'github'})
+
+ assert response.status_code == status.HTTP_401_UNAUTHORIZED
+
+
+class TestGetUserInstallations:
+ """Test suite for get_user_installations function."""
+
+ @pytest.mark.asyncio
+ @patch('openhands.app_server.git.git_router.ProviderHandler')
+ async def test_returns_paginated_installations(self, mock_handler_cls):
+ """Test that installations are returned with pagination."""
+ # Arrange
+ mock_handler = _make_mock_provider_handler()
+ mock_handler_cls.return_value = mock_handler
+
+ mock_context = _make_mock_user_context(
+ provider_tokens={
+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')
+ },
+ user_id='user-123',
+ )
+
+ # Act
+ result = await get_user_installations(
+ provider=ProviderType.GITHUB,
+ page_id=None,
+ limit=2,
+ user_context=mock_context,
+ )
+
+ # Assert
+ assert result.items == ['inst-1', 'inst-2']
+ # next_page_id is base64-encoded
+ assert result.next_page_id == encode_page_id(2)
+
+ @pytest.mark.asyncio
+ @patch('openhands.app_server.git.git_router.ProviderHandler')
+ async def test_returns_second_page_correctly(self, mock_handler_cls):
+ """Test that second page of installations is returned correctly."""
+ # Arrange
+ mock_handler = _make_mock_provider_handler()
+ mock_handler_cls.return_value = mock_handler
+
+ mock_context = _make_mock_user_context(
+ provider_tokens={
+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')
+ },
+ user_id='user-123',
+ )
+
+ # Act - request second page
+ result = await get_user_installations(
+ provider=ProviderType.GITHUB,
+ page_id=encode_page_id(2), # Second page starts at offset 2
+ limit=2,
+ user_context=mock_context,
+ )
+
+ # Assert
+ assert result.items == ['inst-3', 'inst-4']
+ assert result.next_page_id == encode_page_id(4)
+
+
+class TestGetUserRepositories:
+ """Test suite for get_user_repositories function."""
+
+ @pytest.mark.asyncio
+ @patch('openhands.app_server.git.git_router.ProviderHandler')
+ async def test_returns_repositories_with_correct_structure(self, mock_handler_cls):
+ """Test that get_user_repositories returns correct RepositoryPage structure."""
+ # Arrange
+ mock_handler = MagicMock()
+ mock_handler.get_repositories = AsyncMock(
+ return_value=[
+ Repository(
+ id='1',
+ full_name='user/repo1',
+ git_provider=ProviderType.GITHUB,
+ is_public=True,
+ ),
+ Repository(
+ id='2',
+ full_name='user/repo2',
+ git_provider=ProviderType.GITHUB,
+ is_public=False,
+ ),
+ Repository(
+ id='3',
+ full_name='user/repo3',
+ git_provider=ProviderType.GITHUB,
+ is_public=True,
+ ),
+ ]
+ )
+ mock_handler_cls.return_value = mock_handler
+
+ mock_context = _make_mock_user_context(
+ provider_tokens={
+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')
+ },
+ user_id='user-123',
+ )
+
+ # Act
+ result = await get_user_repositories(
+ provider=ProviderType.GITHUB,
+ sort='updated',
+ installation_id=None,
+ page_id=None,
+ limit=10,
+ user_context=mock_context,
+ )
+
+ # Assert
+ assert len(result.items) == 3
+ assert result.items[0].id == '1'
+ assert result.items[1].id == '2'
+ assert result.items[2].id == '3'
+ assert result.next_page_id is None # No more pages
+
+ @pytest.mark.asyncio
+ @patch('openhands.app_server.git.git_router.ProviderHandler')
+ async def test_pagination_works_across_pages(self, mock_handler_cls):
+ """Test that pagination works correctly across multiple pages.
+
+ Note: This endpoint uses page-based pagination (passing page number to provider),
+ not offset-based pagination like installations. The provider returns limit+1 items,
+ and we check if there are more to determine next_page_id.
+ """
+ # Arrange
+ mock_handler = MagicMock()
+
+ # We'll set up the mock to return different data based on the page parameter
+ # First call (page=1): return 3 items (limit+1), meaning there's a next page
+ # Second call (page=2): return 3 items, meaning there's a next page
+ # Third call (page=3): return 2 items, meaning it's the last page
+ def mock_get_repositories(**kwargs):
+ page = kwargs.get('page', 1)
+ if page == 1:
+ return [
+ Repository(
+ id=str(i),
+ full_name=f'user/repo{i}',
+ git_provider=ProviderType.GITHUB,
+ is_public=True,
+ )
+ for i in range(1, 4) # 3 items = limit+1
+ ]
+ elif page == 2:
+ return [
+ Repository(
+ id=str(i),
+ full_name=f'user/repo{i}',
+ git_provider=ProviderType.GITHUB,
+ is_public=True,
+ )
+ for i in range(4, 7) # 3 items = limit+1
+ ]
+ else:
+ return [
+ Repository(
+ id=str(i),
+ full_name=f'user/repo{i}',
+ git_provider=ProviderType.GITHUB,
+ is_public=True,
+ )
+ for i in range(7, 9) # 2 items < limit+1 = last page
+ ]
+
+ mock_handler.get_repositories = AsyncMock(side_effect=mock_get_repositories)
+ mock_handler_cls.return_value = mock_handler
+
+ mock_context = _make_mock_user_context(
+ provider_tokens={
+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')
+ },
+ user_id='user-123',
+ )
+
+ # Act - First page (page=1)
+ result_page1 = await get_user_repositories(
+ provider=ProviderType.GITHUB,
+ sort='pushed',
+ installation_id=None,
+ page_id=None, # This means page 1
+ limit=2,
+ user_context=mock_context,
+ )
+
+ # Assert - First page returns 2 items (truncated from limit+1=3), with next_page_id
+ assert len(result_page1.items) == 2
+ assert result_page1.items[0].id == '1'
+ assert result_page1.items[1].id == '2'
+ assert result_page1.next_page_id == encode_page_id(2)
+
+ # Act - Second page (page=2)
+ result_page2 = await get_user_repositories(
+ provider=ProviderType.GITHUB,
+ sort='pushed',
+ installation_id=None,
+ page_id=encode_page_id(2), # This means page 2
+ limit=2,
+ user_context=mock_context,
+ )
+
+ # Assert - Second page returns next 2 items
+ assert len(result_page2.items) == 2
+ assert result_page2.items[0].id == '4'
+ assert result_page2.items[1].id == '5'
+ # next_page_id = page + 1 = 2 + 1 = 3, encoded as base64 = 'Mw'
+ assert result_page2.next_page_id == encode_page_id(3)
+
+ @pytest.mark.asyncio
+ @patch('openhands.app_server.git.git_router.ProviderHandler')
+ async def test_passes_sort_parameter_to_provider(self, mock_handler_cls):
+ """Test that sort parameter is passed through to the provider handler."""
+ # Arrange
+ mock_handler = MagicMock()
+ mock_handler.get_repositories = AsyncMock(return_value=[])
+ mock_handler_cls.return_value = mock_handler
+
+ mock_context = _make_mock_user_context(
+ provider_tokens={
+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')
+ },
+ user_id='user-123',
+ )
+
+ # Act
+ await get_user_repositories(
+ provider=ProviderType.GITHUB,
+ sort='stars',
+ installation_id=None,
+ page_id=None,
+ limit=10,
+ user_context=mock_context,
+ )
+
+ # Assert - verify get_repositories was called with the sort parameter
+ mock_handler.get_repositories.assert_called_once()
+ call_kwargs = mock_handler.get_repositories.call_args.kwargs
+ assert call_kwargs.get('sort') == 'stars'
+
+ @pytest.mark.asyncio
+ @patch('openhands.app_server.git.git_router.ProviderHandler')
+ async def test_passes_installation_id_to_provider(self, mock_handler_cls):
+ """Test that installation_id filtering is passed through to the provider."""
+ # Arrange
+ mock_handler = MagicMock()
+ mock_handler.get_repositories = AsyncMock(return_value=[])
+ mock_handler_cls.return_value = mock_handler
+
+ mock_context = _make_mock_user_context(
+ provider_tokens={
+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')
+ },
+ user_id='user-123',
+ )
+
+ # Act
+ await get_user_repositories(
+ provider=ProviderType.GITHUB,
+ sort='pushed',
+ installation_id='app-123',
+ page_id=None,
+ limit=10,
+ user_context=mock_context,
+ )
+
+ # Assert - verify get_repositories was called with installation_id
+ mock_handler.get_repositories.assert_called_once()
+ call_kwargs = mock_handler.get_repositories.call_args.kwargs
+ assert call_kwargs.get('installation_id') == 'app-123'