feat: Switch to using async client

Author: cbcoutinho

.github/workflows/test.yml

@@ -6,7 +6,21 @@ on:
       - master
 
 jobs:
-  build:
+  linting:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@f0ec1fc3b38f5e7cd731bb6ce540c5af426746bb # v6
+      - name: Check format
+        run: |
+          uv run --frozen ruff format --diff
+      - name: Linting
+        run: |
+          uv run --frozen ruff check
+
+
+  integration-test:
     runs-on: ubuntu-latest
 
     steps:

Dockerfile

@@ -4,6 +4,6 @@ WORKDIR /app
 
 COPY . .
 
-RUN uv sync --locked
+RUN uv sync --locked --no-dev
 
-CMD ["uv", "run", "--locked", "mcp", "run", "--transport", "sse", "nextcloud_mcp_server/server.py:mcp"]
+CMD ["/app/.venv/bin/mcp", "run", "--transport", "sse", "/app/nextcloud_mcp_server/server.py:mcp"]

nextcloud_mcp_server/client.py

@@ -17,7 +17,7 @@
     "loggers": {
         "": {
             "handlers": ["default"],
-            "level": "DEBUG",
+            "level": "INFO",
         },
         "httpx": {
             "handlers": ["default"],

nextcloud_mcp_server/config.py

@@ -4,10 +4,8 @@
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from mcp.server.fastmcp import FastMCP, Context
-from mcp.server import Server
 from collections.abc import AsyncIterator
 from nextcloud_mcp_server.client import NextcloudClient
-import asyncio  # Import asyncio
 
 setup_logging()
 
@@ -28,7 +26,7 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
         yield AppContext(client=client)
     finally:
         # Cleanup on shutdown
-        client._client.close()
+        await client._client.aclose()
 
 
 # Create an MCP server
@@ -38,46 +36,46 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
 
 
 @mcp.resource("nc://capabilities")
-def nc_get_capabilities():
+async def nc_get_capabilities():
     """Get the Nextcloud Host capabilities"""
     # client = NextcloudClient.from_env()
     ctx = (
         mcp.get_context()
     )  # https://github.com/modelcontextprotocol/python-sdk/issues/244
     client: NextcloudClient = ctx.request_context.lifespan_context.client
-    return client.capabilities()
+    return await client.capabilities()
 
 
 @mcp.resource("notes://settings")
-def notes_get_settings():
+async def notes_get_settings():
     """Get the Notes App settings"""
     ctx = (
         mcp.get_context()
     )  # https://github.com/modelcontextprotocol/python-sdk/issues/244
     client: NextcloudClient = ctx.request_context.lifespan_context.client
-    return client.notes_get_settings()
+    return await client.notes_get_settings()
 
 
 @mcp.tool()
-def nc_get_note(note_id: int, ctx: Context):
+async def nc_get_note(note_id: int, ctx: Context):
     """Get user note using note id"""
     client: NextcloudClient = ctx.request_context.lifespan_context.client
-    return client.notes_get_note(note_id=note_id)
+    return await client.notes_get_note(note_id=note_id)
 
 
 @mcp.tool()
-def nc_notes_create_note(title: str, content: str, category: str, ctx: Context):
+async def nc_notes_create_note(title: str, content: str, category: str, ctx: Context):
     """Create a new note"""
     client: NextcloudClient = ctx.request_context.lifespan_context.client
-    return client.notes_create_note(
+    return await client.notes_create_note(
         title=title,
         content=content,
         category=category,
     )
 
 
 @mcp.tool()
-def nc_notes_update_note(
+async def nc_notes_update_note(
     note_id: int,
     etag: str,
     title: str | None,
@@ -87,7 +85,7 @@ def nc_notes_update_note(
 ):
     logger.info("Updating note %s", note_id)
     client: NextcloudClient = ctx.request_context.lifespan_context.client
-    return client.notes_update_note(
+    return await client.notes_update_note(
         note_id=note_id,
         etag=etag,
         title=title,
@@ -97,35 +95,35 @@ def nc_notes_update_note(
 
 
 @mcp.tool()
-def nc_notes_append_content(note_id: int, content: str, ctx: Context):
+async def nc_notes_append_content(note_id: int, content: str, ctx: Context):
     """Append content to an existing note with a clear separator"""
     logger.info("Appending content to note %s", note_id)
     client: NextcloudClient = ctx.request_context.lifespan_context.client
-    return client.notes_append_content(note_id=note_id, content=content)
+    return await client.notes_append_content(note_id=note_id, content=content)
 
 
 @mcp.tool()
-def nc_notes_search_notes(query: str, ctx: Context):
+async def nc_notes_search_notes(query: str, ctx: Context):
     """Search notes by title or content, returning only id, title, and category."""
     client: NextcloudClient = ctx.request_context.lifespan_context.client
-    return client.notes_search_notes(query=query)
+    return await client.notes_search_notes(query=query)
 
 
 @mcp.tool()
-def nc_notes_delete_note(note_id: int, ctx: Context):
+async def nc_notes_delete_note(note_id: int, ctx: Context):
     logger.info("Deleting note %s", note_id)
     client: NextcloudClient = ctx.request_context.lifespan_context.client
-    return client.notes_delete_note(note_id=note_id)
+    return await client.notes_delete_note(note_id=note_id)
 
 
 @mcp.resource("nc://Notes/{note_id}/attachments/{attachment_filename}")
-def nc_notes_get_attachment(note_id: int, attachment_filename: str):
+async def nc_notes_get_attachment(note_id: int, attachment_filename: str):
     """Get a specific attachment from a note"""
     ctx = mcp.get_context()
     client: NextcloudClient = ctx.request_context.lifespan_context.client
     # Assuming a method get_note_attachment exists in the client
     # This method should return the raw content and determine the mime type
-    content, mime_type = client.get_note_attachment(
+    content, mime_type = await client.get_note_attachment(
         note_id=note_id, filename=attachment_filename
     )
     return {

nextcloud_mcp_server/server.py

@@ -17,6 +17,7 @@ dependencies = [
 nc-mcp-server = "nextcloud_mcp_server.server:run"
 
 [tool.pytest.ini_options]
+asyncio_mode = "auto"
 log_cli = 1
 log_cli_level = "WARN"
 log_level = "WARN"
@@ -38,9 +39,10 @@ build-backend = "poetry.core.masonry.api"
 
 [dependency-groups]
 dev = [
-    "black>=25.1.0",
     "commitizen>=4.8.2",
     "ipython>=9.2.0",
     "pytest>=8.3.5",
+    "pytest-asyncio>=1.0.0",
     "pytest-cov>=6.1.1",
+    "ruff>=0.11.13",
 ]

pyproject.toml

@@ -2,13 +2,13 @@
 import os
 import logging
 import uuid
-import time
 from nextcloud_mcp_server.client import NextcloudClient, HTTPStatusError
 
 logger = logging.getLogger(__name__)
 
+
 @pytest.fixture(scope="session")
-def nc_client() -> NextcloudClient:
+async def nc_client() -> NextcloudClient:
     """
     Fixture to create a NextcloudClient instance for integration tests.
     Uses environment variables for configuration.
@@ -20,15 +20,18 @@ def nc_client() -> NextcloudClient:
     client = NextcloudClient.from_env()
     # Optional: Perform a quick check like getting capabilities to ensure connection works
     try:
-        client.capabilities()
-        logger.info("NextcloudClient session fixture initialized and capabilities checked.")
+        await client.capabilities()
+        logger.info(
+            "NextcloudClient session fixture initialized and capabilities checked."
+        )
     except Exception as e:
         logger.error(f"Failed to initialize NextcloudClient session fixture: {e}")
         pytest.fail(f"Failed to connect to Nextcloud or get capabilities: {e}")
     return client
 
+
 @pytest.fixture
-def temporary_note(nc_client: NextcloudClient):
+async def temporary_note(nc_client: NextcloudClient):
     """
     Fixture to create a temporary note for a test and ensure its deletion afterward.
     Yields the created note dictionary.
@@ -42,21 +45,21 @@ def temporary_note(nc_client: NextcloudClient):
 
     logger.info(f"Creating temporary note: {note_title}")
     try:
-        created_note_data = nc_client.notes_create_note(
+        created_note_data = await nc_client.notes_create_note(
             title=note_title, content=note_content, category=note_category
         )
         note_id = created_note_data.get("id")
         if not note_id:
             pytest.fail("Failed to get ID from created temporary note.")
-        
+
         logger.info(f"Temporary note created with ID: {note_id}")
-        yield created_note_data # Provide the created note data to the test
+        yield created_note_data  # Provide the created note data to the test
 
     finally:
         if note_id:
             logger.info(f"Cleaning up temporary note ID: {note_id}")
             try:
-                nc_client.notes_delete_note(note_id=note_id)
+                await nc_client.notes_delete_note(note_id=note_id)
                 logger.info(f"Successfully deleted temporary note ID: {note_id}")
             except HTTPStatusError as e:
                 # Ignore 404 if note was already deleted by the test itself
@@ -67,36 +70,42 @@ def temporary_note(nc_client: NextcloudClient):
             except Exception as e:
                 logger.error(f"Unexpected error deleting temporary note {note_id}: {e}")
 
+
 @pytest.fixture
-def temporary_note_with_attachment(nc_client: NextcloudClient, temporary_note: dict):
+async def temporary_note_with_attachment(nc_client: NextcloudClient, temporary_note: dict):
     """
     Fixture that creates a temporary note, adds an attachment, and cleans up both.
     Yields a tuple: (note_data, attachment_filename, attachment_content).
     Depends on the temporary_note fixture.
     """
     note_data = temporary_note
     note_id = note_data["id"]
-    note_category = note_data.get("category") # Get category from the note data
+    note_category = note_data.get("category")  # Get category from the note data
     unique_suffix = uuid.uuid4().hex[:8]
     attachment_filename = f"temp_attach_{unique_suffix}.txt"
-    attachment_content = f"Content for {attachment_filename}".encode('utf-8')
+    attachment_content = f"Content for {attachment_filename}".encode("utf-8")
     attachment_mime = "text/plain"
-    
-    logger.info(f"Adding attachment '{attachment_filename}' to temporary note ID: {note_id} (category: '{note_category or ''}')")
+
+    logger.info(
+        f"Adding attachment '{attachment_filename}' to temporary note ID: {note_id} (category: '{note_category or ''}')"
+    )
     try:
         # Pass the category to add_note_attachment
-        upload_response = nc_client.add_note_attachment(
+        upload_response = await nc_client.add_note_attachment(
             note_id=note_id,
             filename=attachment_filename,
             content=attachment_content,
-            category=note_category, # Pass the fetched category
-            mime_type=attachment_mime
+            category=note_category,  # Pass the fetched category
+            mime_type=attachment_mime,
         )
-        assert upload_response.get("status_code") in [201, 204], f"Failed to upload attachment: {upload_response}"
+        assert upload_response.get("status_code") in [
+            201,
+            204,
+        ], f"Failed to upload attachment: {upload_response}"
         logger.info(f"Attachment '{attachment_filename}' added successfully.")
-        
+
         yield note_data, attachment_filename, attachment_content
-        
+
         # Cleanup for the attachment is handled by the notes_delete_note call
         # in the temporary_note fixture's finally block (which deletes the .attachments dir)