nextcloud-mcp-lite 0.1.0__tar.gz

nextcloud_mcp_lite-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.5
+Name: nextcloud-mcp-lite
+Version: 0.1.0
+Summary: Minimal MCP server for Nextcloud file sync and PIM
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1
+Requires-Dist: httpx<0.29,>=0.28.1
+Requires-Dist: icalendar<7.4,>=7.3.0
+Requires-Dist: mcp[cli]<3,>=2.1

nextcloud_mcp_lite-0.1.0/nextcloud_mcp/calendar.py

@@ -0,0 +1,212 @@
+"""MCP tools for Nextcloud Calendar operations."""
+
+import logging
+import uuid
+from datetime import datetime, timedelta
+from typing import Any
+
+import httpx
+from mcp.server.mcpserver import MCPServer
+from mcp.types import ToolAnnotations
+
+from nextcloud_mcp.client import NextcloudClient
+
+logger = logging.getLogger(__name__)
+
+
+def configure_calendar_tools(mcp: MCPServer, client: NextcloudClient) -> None:
+    """Register all Calendar tools."""
+
+    @mcp.tool(
+        title="List Calendars",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_list_calendars() -> dict[str, Any]:
+        """List all calendars for the current user."""
+        try:
+            calendars = await client.list_calendars()
+            return {"calendars": calendars}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="List Events",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_list_events(
+        calendar_path: str,
+        start: str | None = None,
+        end: str | None = None,
+    ) -> dict[str, Any]:
+        """List events in a calendar, optionally filtered by date range (ISO format: 2024-01-15T10:00:00)."""
+        try:
+            # Convert ISO dates to CalDAV format (YYYYMMDDTHHMMSSZ)
+            cal_start = None
+            cal_end = None
+            if start:
+                cal_start = datetime.fromisoformat(start).strftime('%Y%m%dT%H%M%SZ')
+            if end:
+                cal_end = datetime.fromisoformat(end).strftime('%Y%m%dT%H%M%SZ')
+            events = await client.get_events(calendar_path, cal_start, cal_end)
+            return {"calendar": calendar_path, "events": events}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Get Event",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_get_event(calendar_path: str, event_uid: str) -> dict[str, Any]:
+        """Get a single event by its UID."""
+        try:
+            path = calendar_path if calendar_path.endswith("/") else calendar_path + "/"
+            url = f"{client.base_url}{path}{event_uid}.ics"
+            async with httpx.AsyncClient(
+                auth=client.auth, verify=client.verify, timeout=30
+            ) as http:
+                response = await http.get(url)
+                response.raise_for_status()
+                return {"uid": event_uid, "vcalendar": response.text}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Create Event",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_create_event(
+        calendar_path: str,
+        summary: str,
+        start: str,
+        end: str | None = None,
+        description: str = "",
+        location: str = "",
+    ) -> dict[str, Any]:
+        """Create a new calendar event. Start/end in ISO format (e.g. 2024-01-15T10:00:00)."""
+        try:
+            uid = str(uuid.uuid4())
+            dtstart = datetime.fromisoformat(start)
+            dtend = datetime.fromisoformat(end) if end else dtstart + timedelta(hours=1)
+
+            vcal = f"""BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Nextcloud MCP//EN
+BEGIN:VEVENT
+UID:{uid}
+DTSTART:{dtstart.strftime('%Y%m%dT%H%M%S')}
+DTEND:{dtend.strftime('%Y%m%dT%H%M%S')}
+SUMMARY:{summary}
+DESCRIPTION:{description}
+LOCATION:{location}
+END:VEVENT
+END:VCALENDAR"""
+
+            await client.create_event(calendar_path, vcal)
+            return {"status": "ok", "uid": uid, "summary": summary}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Update Event",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_update_event(
+        calendar_path: str,
+        event_uid: str,
+        summary: str | None = None,
+        start: str | None = None,
+        end: str | None = None,
+        description: str | None = None,
+    ) -> dict[str, Any]:
+        """Update an existing event. Only provided fields are changed."""
+        try:
+            # Fetch existing event
+            result = await nc_get_event(calendar_path, event_uid)
+            if "error" in result:
+                return result
+
+            vcal = result["vcalendar"]
+            # Simple field replacement
+            if summary:
+                vcal = vcal.replace(
+                    vcal[vcal.find("SUMMARY:"):vcal.find("\n", vcal.find("SUMMARY:"))],
+                    f"SUMMARY:{summary}",
+                )
+            if description is not None:
+                vcal = vcal.replace(
+                    vcal[vcal.find("DESCRIPTION:"):vcal.find("\n", vcal.find("DESCRIPTION:"))],
+                    f"DESCRIPTION:{description}",
+                )
+            if start:
+                dtstart = datetime.fromisoformat(start)
+                vcal = vcal.replace(
+                    vcal[vcal.find("DTSTART:"):vcal.find("\n", vcal.find("DTSTART:"))],
+                    f"DTSTART:{dtstart.strftime('%Y%m%dT%H%M%S')}",
+                )
+            if end:
+                dtend = datetime.fromisoformat(end)
+                vcal = vcal.replace(
+                    vcal[vcal.find("DTEND:"):vcal.find("\n", vcal.find("DTEND:"))],
+                    f"DTEND:{dtend.strftime('%Y%m%dT%H%M%S')}",
+                )
+
+            # Update in place (preserves UID)
+            await client.update_event(calendar_path, event_uid, vcal)
+            return {"status": "ok", "uid": event_uid}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Delete Event",
+        annotations=ToolAnnotations(destructive_hint=True, idempotent_hint=True, open_world_hint=True),
+    )
+    async def nc_delete_event(calendar_path: str, event_uid: str) -> dict[str, Any]:
+        """Delete a calendar event."""
+        try:
+            await client.delete_event(calendar_path, event_uid)
+            return {"status": "ok", "uid": event_uid}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="List Todos",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_list_todos(calendar_path: str) -> dict[str, Any]:
+        """List todo tasks in a calendar."""
+        try:
+            todos = await client.list_todos(calendar_path)
+            return {"calendar": calendar_path, "todos": todos}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Create Todo",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_create_todo(
+        calendar_path: str,
+        summary: str,
+        due: str | None = None,
+        description: str = "",
+    ) -> dict[str, Any]:
+        """Create a new todo task. Due in ISO format."""
+        try:
+            uid = str(uuid.uuid4())
+            due_line = f"DUE:{datetime.fromisoformat(due).strftime('%Y%m%dT%H%M%S')}" if due else ""
+
+            vcal = f"""BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Nextcloud MCP//EN
+BEGIN:VTODO
+UID:{uid}
+SUMMARY:{summary}
+DESCRIPTION:{description}
+{due_line}
+END:VTODO
+END:VCALENDAR"""
+
+            await client.create_todo(calendar_path, vcal)
+            return {"status": "ok", "uid": uid, "summary": summary}
+        except Exception as e:
+            return {"error": str(e)}

nextcloud_mcp_lite-0.1.0/nextcloud_mcp/cli.py

@@ -0,0 +1,86 @@
+"""CLI for the minimal Nextcloud MCP server."""
+
+import logging
+import sys
+
+import click
+
+from nextcloud_mcp.config import Settings
+from nextcloud_mcp.server import create_server
+
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.option(
+    "--host", "-h", default="127.0.0.1", show_default=True, help="Server host (HTTP mode only)"
+)
+@click.option(
+    "--port", "-p", type=int, default=8000, show_default=True, help="Server port (HTTP mode only)"
+)
+@click.option(
+    "--transport",
+    "-t",
+    default="stdio",
+    show_default=True,
+    type=click.Choice(["stdio", "streamable-http"]),
+    help="MCP transport protocol",
+)
+def run(
+    host: str,
+    port: int,
+    transport: str,
+):
+    """Run the Nextcloud MCP server.
+
+    Authentication: set NEXTCLOUD_HOST, NEXTCLOUD_USERNAME, NEXTCLOUD_PASSWORD
+    (use an app password from Nextcloud Settings > Security > Devices & sessions).
+
+    Examples:
+        # stdio mode (Claude Code, local MCP clients)
+        $ NEXTCLOUD_HOST=https://cloud.example.com \\
+          NEXTCLOUD_USERNAME=user \\
+          NEXTCLOUD_PASSWORD=xxxx-yyyy-zzzz \\
+          nextcloud-mcp run --transport stdio
+
+        # HTTP mode (connect from other clients)
+        $ nextcloud-mcp run --transport streamable-http --host 127.0.0.1 --port 8000
+    """
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s - %(message)s",
+    )
+
+    try:
+        settings = Settings.from_env()
+    except ValueError as e:
+        click.echo(f"Configuration error: {e}", err=True)
+        sys.exit(1)
+
+    click.echo(
+        f"Starting Nextcloud MCP server ({transport}) connected to {settings.nextcloud_host}",
+        err=True,
+    )
+
+    server = create_server(settings)
+
+    if transport == "stdio":
+        server.run(transport="stdio")
+    else:
+        import uvicorn
+
+        app = server.streamable_http_app()
+        uvicorn.run(app=app, host=host, port=port, log_level="info")
+
+
+@click.group()
+def cli():
+    """Minimal MCP server for Nextcloud file sync and PIM."""
+    pass
+
+
+cli.add_command(run)
+
+
+if __name__ == "__main__":
+    cli()

nextcloud_mcp_lite-0.1.0/nextcloud_mcp/client.py

@@ -0,0 +1,374 @@
+"""Minimal Nextcloud client using WebDAV and CalDAV."""
+
+import base64
+import logging
+from typing import Any
+
+import httpx
+
+from nextcloud_mcp.config import Settings
+
+logger = logging.getLogger(__name__)
+
+
+class NextcloudClient:
+    """HTTP client for Nextcloud WebDAV, CalDAV, and OCS APIs."""
+
+    def __init__(self, settings: Settings):
+        self.settings = settings
+        self.base_url = settings.nextcloud_host
+        self.auth = (settings.nextcloud_username, settings.nextcloud_password)
+        self.verify = settings.verify_ssl
+
+    def _client(self, **kwargs) -> httpx.AsyncClient:
+        """Create an async HTTP client with auth and default settings."""
+        return httpx.AsyncClient(
+            auth=self.auth,
+            verify=self.verify,
+            timeout=kwargs.get("timeout", 30),
+            **{k: v for k, v in kwargs.items() if k != "timeout"},
+        )
+
+    @property
+    def webdav_base(self) -> str:
+        """WebDAV endpoint base URL."""
+        return f"{self.base_url}/remote.php/dav/files/{self.settings.nextcloud_username}"
+
+    # =========================================================================
+    # WebDAV Operations
+    # =========================================================================
+
+    async def propfind(self, path: str = "/", depth: int = 1) -> list[dict[str, Any]]:
+        """List directory contents via PROPFIND."""
+        url = f"{self.webdav_base}{path}"
+        async with self._client() as client:
+            response = await client.request(
+                "PROPFIND",
+                url,
+                headers={"Depth": str(depth), "Content-Type": "application/xml"},
+                content='<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:displayname/><d:getcontenttype/><d:getcontentlength/><d:getlastmodified/><d:resourcetype/></d:prop></d:propfind>',
+            )
+            response.raise_for_status()
+            return self._parse_propfind(response.text)
+
+    async def get_file(self, path: str) -> bytes:
+        """Download file content."""
+        url = f"{self.webdav_base}{path}"
+        async with self._client(timeout=60) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return response.content
+
+    async def put_file(self, path: str, content: bytes) -> None:
+        """Upload/create a file."""
+        url = f"{self.webdav_base}{path}"
+        async with self._client(timeout=60) as client:
+            response = await client.put(url, content=content)
+            response.raise_for_status()
+
+    async def delete(self, path: str) -> None:
+        """Delete a file or directory."""
+        url = f"{self.webdav_base}{path}"
+        async with self._client() as client:
+            response = await client.delete(url)
+            response.raise_for_status()
+
+    async def move(self, source: str, destination: str) -> None:
+        """Move or rename a file/directory."""
+        source_url = f"{self.webdav_base}{source}"
+        dest_url = f"{self.webdav_base}{destination}"
+        async with self._client() as client:
+            response = await client.request(
+                "MOVE",
+                source_url,
+                headers={"Destination": dest_url, "Overwrite": "F"},
+            )
+            response.raise_for_status()
+
+    async def copy(self, source: str, destination: str) -> None:
+        """Copy a file/directory."""
+        source_url = f"{self.webdav_base}{source}"
+        dest_url = f"{self.webdav_base}{destination}"
+        async with self._client() as client:
+            response = await client.request(
+                "COPY",
+                source_url,
+                headers={"Destination": dest_url, "Overwrite": "F"},
+            )
+            response.raise_for_status()
+
+    async def mkcol(self, path: str) -> None:
+        """Create a directory (MKCOL)."""
+        url = f"{self.webdav_base}{path}"
+        async with self._client() as client:
+            response = await client.request("MKCOL", url)
+            response.raise_for_status()
+
+    async def get_file_id(self, path: str) -> int | None:
+        """Get the file ID for a given path via PROPFIND."""
+        url = f"{self.webdav_base}{path}"
+        async with self._client() as client:
+            response = await client.request(
+                "PROPFIND",
+                url,
+                headers={"Depth": "0", "Content-Type": "application/xml"},
+                content='<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:fileid/></d:prop></d:propfind>',
+            )
+            response.raise_for_status()
+            # Parse fileid from response
+            import xml.etree.ElementTree as ET
+            root = ET.fromstring(response.text)
+            for elem in root.iter():
+                if elem.tag.endswith("fileid"):
+                    return int(elem.text) if elem.text else None
+        return None
+
+    # =========================================================================
+    # OCS Share API
+    # =========================================================================
+
+    async def create_public_link(self, path: str, permissions: int = 1) -> dict[str, Any]:
+        """Create a public download link for a file/folder."""
+        url = f"{self.base_url}/ocs/v2.php/apps/api_sharing/api/v1/shares"
+        async with self._client() as client:
+            response = await client.post(
+                url,
+                data={
+                    "path": path,
+                    "shareType": 3,  # Public link
+                    "permissions": permissions,
+                },
+                headers={"OCS-APIRequest": "true"},
+            )
+            response.raise_for_status()
+            return self._parse_ocs_response(response.json())
+
+    async def list_shares(self) -> list[dict[str, Any]]:
+        """List all shares for the current user."""
+        url = f"{self.base_url}/ocs/v2.php/apps/api_sharing/api/v1/shares"
+        async with self._client() as client:
+            response = await client.get(
+                url,
+                headers={"OCS-APIRequest": "true"},
+            )
+            response.raise_for_status()
+            data = self._parse_ocs_response(response.json())
+            return data if isinstance(data, list) else [data]
+
+    async def get_share(self, share_id: int) -> dict[str, Any]:
+        """Get details of a specific share."""
+        url = f"{self.base_url}/ocs/v2.php/apps/api_sharing/api/v1/shares/{share_id}"
+        async with self._client() as client:
+            response = await client.get(
+                url,
+                headers={"OCS-APIRequest": "true"},
+            )
+            response.raise_for_status()
+            return self._parse_ocs_response(response.json())
+
+    async def update_share(self, share_id: int, **kwargs) -> dict[str, Any]:
+        """Update a share (permissions, password, expireDate, etc.)."""
+        url = f"{self.base_url}/ocs/v2.php/apps/api_sharing/api/v1/shares/{share_id}"
+        async with self._client() as client:
+            response = await client.put(
+                url,
+                data=kwargs,
+                headers={"OCS-APIRequest": "true"},
+            )
+            response.raise_for_status()
+            return self._parse_ocs_response(response.json())
+
+    # =========================================================================
+    # CalDAV Operations
+    # =========================================================================
+
+    async def list_calendars(self) -> list[dict[str, Any]]:
+        """List all calendars."""
+        url = f"{self.base_url}/remote.php/dav/calendars/{self.settings.nextcloud_username}/"
+        async with self._client() as client:
+            response = await client.request(
+                "PROPFIND",
+                url,
+                headers={"Depth": "1", "Content-Type": "application/xml"},
+                content='<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:" xmlns:cs="http://calendarserver.org/ns/"><d:prop><d:displayname/><d:resourcetype/><cs:getctag/></d:prop></d:propfind>',
+            )
+            response.raise_for_status()
+            return self._parse_calendars(response.text)
+
+    async def get_events(self, calendar_path: str, start: str = None, end: str = None) -> list[dict[str, Any]]:
+        """Get events from a calendar, optionally filtered by date range."""
+        path = calendar_path if calendar_path.endswith("/") else calendar_path + "/"
+        url = f"{self.base_url}{path}"
+        filter_xml = ""
+        if start and end:
+            filter_xml = f'<c:filter><c:comp-filter name="VCALENDAR"><c:comp-filter name="VEVENT"><c:time-range start="{start}" end="{end}"/></c:comp-filter></c:comp-filter></c:filter>'
+
+        async with self._client() as client:
+            response = await client.request(
+                "REPORT",
+                url,
+                headers={"Depth": "1", "Content-Type": "application/xml"},
+                content=f'<?xml version="1.0" encoding="UTF-8"?><c:calendar-query xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav"><d:prop><d:getcontenttype/><d:getetag/><c:calendar-data/></d:prop>{filter_xml}</c:calendar-query>',
+            )
+            response.raise_for_status()
+            return self._parse_calendar_data(response.text)
+
+    async def create_event(self, calendar_path: str, vcalendar: str) -> str:
+        """Create a new calendar event. Returns the event UID."""
+        import uuid
+        event_uid = str(uuid.uuid4())
+        path = calendar_path if calendar_path.endswith("/") else calendar_path + "/"
+        url = f"{self.base_url}{path}{event_uid}.ics"
+        async with self._client() as client:
+            response = await client.put(
+                url,
+                content=vcalendar.encode("utf-8"),
+                headers={"Content-Type": "text/calendar; charset=utf-8"},
+            )
+            response.raise_for_status()
+        return event_uid
+
+    async def update_event(self, calendar_path: str, event_uid: str, vcalendar: str) -> None:
+        """Update an existing calendar event (preserves UID)."""
+        path = calendar_path if calendar_path.endswith("/") else calendar_path + "/"
+        url = f"{self.base_url}{path}{event_uid}.ics"
+        async with self._client() as client:
+            response = await client.put(
+                url,
+                content=vcalendar.encode("utf-8"),
+                headers={"Content-Type": "text/calendar; charset=utf-8", "Overwrite": "T"},
+            )
+            response.raise_for_status()
+
+    async def delete_event(self, calendar_path: str, event_uid: str) -> None:
+        """Delete a calendar event."""
+        path = calendar_path if calendar_path.endswith("/") else calendar_path + "/"
+        url = f"{self.base_url}{path}{event_uid}.ics"
+        async with self._client() as client:
+            response = await client.delete(url)
+            response.raise_for_status()
+
+    async def list_todos(self, calendar_path: str) -> list[dict[str, Any]]:
+        """List todo tasks from a calendar."""
+        path = calendar_path if calendar_path.endswith("/") else calendar_path + "/"
+        url = f"{self.base_url}{path}"
+        async with self._client() as client:
+            response = await client.request(
+                "REPORT",
+                url,
+                headers={"Depth": "1", "Content-Type": "application/xml"},
+                content='<?xml version="1.0" encoding="UTF-8"?><c:calendar-query xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav"><d:prop><d:getcontenttype/><d:getetag/><c:calendar-data/></d:prop><c:filter><c:comp-filter name="VCALENDAR"><c:comp-filter name="VTODO"/></c:comp-filter></c:filter></c:calendar-query>',
+            )
+            response.raise_for_status()
+            return self._parse_calendar_data(response.text)
+
+    async def create_todo(self, calendar_path: str, vcalendar: str) -> str:
+        """Create a new todo task. Returns the todo UID."""
+        import uuid
+        todo_uid = str(uuid.uuid4())
+        path = calendar_path if calendar_path.endswith("/") else calendar_path + "/"
+        url = f"{self.base_url}{path}{todo_uid}.ics"
+        async with self._client() as client:
+            response = await client.put(
+                url,
+                content=vcalendar.encode("utf-8"),
+                headers={"Content-Type": "text/calendar; charset=utf-8"},
+            )
+            response.raise_for_status()
+        return todo_uid
+
+    # =========================================================================
+    # Parsing Helpers
+    # =========================================================================
+
+    def _parse_propfind(self, xml: str) -> list[dict[str, Any]]:
+        """Parse WebDAV PROPFIND response."""
+        import xml.etree.ElementTree as ET
+        results = []
+        try:
+            root = ET.fromstring(xml)
+            for response in root.findall(".//{DAV:}response"):
+                href = response.find(".//{DAV:}href")
+                if href is None:
+                    continue
+                href_text = href.text or ""
+
+                propstat = response.find(".//{DAV:}propstat")
+                if propstat is None:
+                    continue
+                prop = propstat.find(".//{DAV:}prop")
+                if prop is None:
+                    continue
+
+                status = propstat.find(".//{DAV:}status")
+                if status is not None and b"404" in status.text.encode() if status.text else False:
+                    continue
+
+                displayname = prop.find(".//{DAV:}displayname")
+                content_type = prop.find(".//{DAV:}getcontenttype")
+                content_length = prop.find(".//{DAV:}getcontentlength")
+                last_modified = prop.find(".//{DAV:}getlastmodified")
+                resource_type = prop.find(".//{DAV:}resourcetype")
+
+                is_collection = resource_type is not None and resource_type.find(".//{DAV:}collection") is not None
+                name = displayname.text if displayname is not None and displayname.text else href_text.rstrip("/").rsplit("/", 1)[-1] if href_text else ""
+
+                results.append({
+                    "path": href_text,
+                    "name": name,
+                    "is_dir": is_collection,
+                    "content_type": content_type.text if content_type is not None else "",
+                    "size": int(content_length.text) if content_length is not None and content_length.text else 0,
+                    "modified": last_modified.text if last_modified is not None else "",
+                })
+        except ET.ParseError as e:
+            logger.error("Failed to parse PROPFIND response: %s", e)
+        return results
+
+    def _parse_ocs_response(self, data: dict) -> Any:
+        """Parse OCS API response."""
+        try:
+            return data["ocs"]["data"]
+        except (KeyError, TypeError):
+            return data
+
+    def _parse_calendars(self, xml: str) -> list[dict[str, Any]]:
+        """Parse CalDAV calendar list PROPFIND response."""
+        import xml.etree.ElementTree as ET
+        results = []
+        try:
+            root = ET.fromstring(xml)
+            for response in root.findall(".//{DAV:}response"):
+                resource_type = response.find(".//{DAV:}resourcetype")
+                if resource_type is None:
+                    continue
+                # Skip principals
+                if resource_type.find(".//{DAV:}principal") is not None:
+                    continue
+
+                href = response.find(".//{DAV:}href")
+                displayname = response.find(".//{DAV:}displayname")
+                ctag = response.find(".//{http://calendarserver.org/ns/}getctag")
+
+                results.append({
+                    "path": href.text or "",
+                    "name": displayname.text if displayname is not None and displayname.text else (href.text.rstrip("/").rsplit("/", 1)[-1] if href is not None else ""),
+                    "ctag": ctag.text if ctag is not None else "",
+                })
+        except ET.ParseError as e:
+            logger.error("Failed to parse calendars: %s", e)
+        return results
+
+    def _parse_calendar_data(self, xml: str) -> list[dict[str, Any]]:
+        """Parse CalDAV calendar-data responses."""
+        import xml.etree.ElementTree as ET
+        results = []
+        try:
+            root = ET.fromstring(xml)
+            for response in root.findall(".//{DAV:}response"):
+                cal_data = response.find(".//{urn:ietf:params:xml:ns:caldav}calendar-data")
+                if cal_data is not None and cal_data.text:
+                    results.append({"vcalendar": cal_data.text})
+        except ET.ParseError as e:
+            logger.error("Failed to parse calendar data: %s", e)
+        return results

nextcloud_mcp_lite-0.1.0/nextcloud_mcp/config.py

@@ -0,0 +1,34 @@
+"""Configuration for the minimal Nextcloud MCP server."""
+
+from dataclasses import dataclass
+import os
+
+
+@dataclass
+class Settings:
+    """Simple settings from environment variables."""
+    nextcloud_host: str
+    nextcloud_username: str
+    nextcloud_password: str
+    verify_ssl: bool = True
+
+    @classmethod
+    def from_env(cls) -> "Settings":
+        host = os.environ.get("NEXTCLOUD_HOST", "").rstrip("/")
+        username = os.environ.get("NEXTCLOUD_USERNAME", "")
+        password = os.environ.get("NEXTCLOUD_PASSWORD", "")
+        verify_ssl = os.environ.get("NEXTCLOUD_VERIFY_SSL", "true").lower() == "true"
+
+        if not host:
+            raise ValueError("NEXTCLOUD_HOST environment variable is required")
+        if not username:
+            raise ValueError("NEXTCLOUD_USERNAME environment variable is required")
+        if not password:
+            raise ValueError("NEXTCLOUD_PASSWORD environment variable is required")
+
+        return cls(
+            nextcloud_host=host,
+            nextcloud_username=username,
+            nextcloud_password=password,
+            verify_ssl=verify_ssl,
+        )

nextcloud_mcp_lite-0.1.0/nextcloud_mcp/server.py

@@ -0,0 +1,27 @@
+"""MCP server setup for the minimal Nextcloud MCP."""
+
+import logging
+
+from mcp.server.mcpserver import MCPServer
+
+from nextcloud_mcp.config import Settings
+from nextcloud_mcp.client import NextcloudClient
+from nextcloud_mcp.webdav import configure_webdav_tools
+from nextcloud_mcp.calendar import configure_calendar_tools
+from nextcloud_mcp.sharing import configure_sharing_tools
+
+logger = logging.getLogger(__name__)
+
+
+def create_server(settings: Settings) -> MCPServer:
+    """Create and configure the MCP server."""
+    client = NextcloudClient(settings)
+
+    mcp = MCPServer("Nextcloud MCP")
+
+    # Register all tools
+    configure_webdav_tools(mcp, client)
+    configure_calendar_tools(mcp, client)
+    configure_sharing_tools(mcp, client)
+
+    return mcp

nextcloud_mcp_lite-0.1.0/nextcloud_mcp/sharing.py

@@ -0,0 +1,137 @@
+"""MCP tools for Nextcloud Sharing operations."""
+
+import logging
+from typing import Any
+
+import httpx
+from mcp.server.mcpserver import MCPServer
+from mcp.types import ToolAnnotations
+
+from nextcloud_mcp.client import NextcloudClient
+
+logger = logging.getLogger(__name__)
+
+
+def configure_sharing_tools(mcp: MCPServer, client: NextcloudClient) -> None:
+    """Register all Sharing tools."""
+
+    @mcp.tool(
+        title="Create Public Link",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_create_public_link(
+        path: str,
+        permissions: int = 1,
+        password: str | None = None,
+        expire_date: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a public download link for a file or folder.
+        permissions: 1=read, 2=update, 4=create, 8=delete, 16=share (can combine, e.g. 3=read+update)
+        expire_date: ISO format date (e.g. 2024-12-31)
+        """
+        try:
+            kwargs: dict[str, Any] = {
+                "path": path,
+                "shareType": 3,  # Public link
+                "permissions": permissions,
+            }
+            if password:
+                kwargs["password"] = password
+            if expire_date:
+                kwargs["expireDate"] = expire_date
+
+            url = f"{client.base_url}/ocs/v2.php/apps/api_sharing/api/v1/shares"
+            async with httpx.AsyncClient(
+                auth=client.auth, verify=client.verify, timeout=30
+            ) as http:
+                response = await http.post(
+                    url,
+                    data=kwargs,
+                    headers={"OCS-APIRequest": "true"},
+                )
+                response.raise_for_status()
+                data = response.json()
+                share = data.get("ocs", {}).get("data", {})
+                return {"status": "ok", "share": share}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="List Shares",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_list_shares() -> dict[str, Any]:
+        """List all shares for the current user."""
+        try:
+            url = f"{client.base_url}/ocs/v2.php/apps/api_sharing/api/v1/shares"
+            async with httpx.AsyncClient(
+                auth=client.auth, verify=client.verify, timeout=30
+            ) as http:
+                response = await http.get(
+                    url,
+                    headers={"OCS-APIRequest": "true"},
+                )
+                response.raise_for_status()
+                data = response.json()
+                shares = data.get("ocs", {}).get("data", [])
+                return {"shares": shares}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Get Share",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_get_share(share_id: int) -> dict[str, Any]:
+        """Get details of a specific share."""
+        try:
+            url = f"{client.base_url}/ocs/v2.php/apps/api_sharing/api/v1/shares/{share_id}"
+            async with httpx.AsyncClient(
+                auth=client.auth, verify=client.verify, timeout=30
+            ) as http:
+                response = await http.get(
+                    url,
+                    headers={"OCS-APIRequest": "true"},
+                )
+                response.raise_for_status()
+                data = response.json()
+                share = data.get("ocs", {}).get("data", {})
+                return {"share": share}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Update Share",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_update_share(
+        share_id: int,
+        permissions: int | None = None,
+        password: str | None = None,
+        expire_date: str | None = None,
+    ) -> dict[str, Any]:
+        """Update a share (permissions, password, expiry date)."""
+        try:
+            kwargs: dict[str, Any] = {}
+            if permissions is not None:
+                kwargs["permissions"] = permissions
+            if password is not None:
+                kwargs["password"] = password
+            if expire_date is not None:
+                kwargs["expireDate"] = expire_date
+
+            url = f"{client.base_url}/ocs/v2.php/apps/api_sharing/api/v1/shares/{share_id}"
+            async with httpx.AsyncClient(
+                auth=client.auth, verify=client.verify, timeout=30
+            ) as http:
+                response = await http.put(
+                    url,
+                    data=kwargs,
+                    headers={"OCS-APIRequest": "true"},
+                )
+                response.raise_for_status()
+                data = response.json()
+                share = data.get("ocs", {}).get("data", {})
+                return {"status": "ok", "share": share}
+        except Exception as e:
+            return {"error": str(e)}

nextcloud_mcp_lite-0.1.0/nextcloud_mcp/webdav.py

@@ -0,0 +1,191 @@
+"""MCP tools for Nextcloud WebDAV file operations."""
+
+import base64
+import logging
+from typing import Any
+
+import httpx
+from mcp.server.mcpserver import MCPServer
+from mcp.types import ToolAnnotations
+
+from nextcloud_mcp.client import NextcloudClient
+
+logger = logging.getLogger(__name__)
+
+
+def configure_webdav_tools(mcp: MCPServer, client: NextcloudClient) -> None:
+    """Register all WebDAV file operation tools."""
+
+    @mcp.tool(
+        title="List Files",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_list_files(path: str = "/") -> dict[str, Any]:
+        """List files and directories at the given path."""
+        try:
+            items = await client.propfind(path)
+            return {
+                "path": path,
+                "items": [
+                    {
+                        "name": item["name"],
+                        "path": item["path"],
+                        "is_dir": item["is_dir"],
+                        "size": item["size"],
+                        "content_type": item["content_type"],
+                        "modified": item["modified"],
+                    }
+                    for item in items
+                ],
+            }
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Read File",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_read_file(path: str) -> dict[str, Any]:
+        """Read a file's content. Returns text or base64 for binary."""
+        try:
+            content = await client.get_file(path)
+            try:
+                text = content.decode("utf-8")
+                return {"path": path, "content": text, "encoding": "utf-8"}
+            except UnicodeDecodeError:
+                return {
+                    "path": path,
+                    "content": base64.b64encode(content).decode("ascii"),
+                    "encoding": "base64",
+                }
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Write File",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_write_file(path: str, content: str, encoding: str = "utf-8") -> dict[str, Any]:
+        """Write content to a file (creates or overwrites)."""
+        try:
+            if encoding == "base64":
+                raw = base64.b64decode(content)
+            else:
+                raw = content.encode("utf-8")
+            await client.put_file(path, raw)
+            return {"status": "ok", "path": path, "bytes_written": len(raw)}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Create Directory",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_create_directory(path: str) -> dict[str, Any]:
+        """Create a new directory."""
+        try:
+            await client.mkcol(path)
+            return {"status": "ok", "path": path}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Delete",
+        annotations=ToolAnnotations(destructive_hint=True, idempotent_hint=True, open_world_hint=True),
+    )
+    async def nc_delete(path: str) -> dict[str, Any]:
+        """Delete a file or directory permanently."""
+        try:
+            await client.delete(path)
+            return {"status": "ok", "path": path}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Move",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_move(source: str, destination: str) -> dict[str, Any]:
+        """Move or rename a file or directory."""
+        try:
+            await client.move(source, destination)
+            return {"status": "ok", "source": source, "destination": destination}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Copy",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_copy(source: str, destination: str) -> dict[str, Any]:
+        """Copy a file or directory."""
+        try:
+            await client.copy(source, destination)
+            return {"status": "ok", "source": source, "destination": destination}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Find Files",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_find_files(path: str = "/", name_contains: str = "") -> dict[str, Any]:
+        """Find files by name pattern (simple substring match)."""
+        try:
+            items = await client.propfind(path, depth=1)
+            results = [
+                item for item in items
+                if name_contains.lower() in item["name"].lower()
+            ]
+            return {
+                "path": path,
+                "name_contains": name_contains,
+                "matches": [
+                    {
+                        "name": item["name"],
+                        "path": item["path"],
+                        "is_dir": item["is_dir"],
+                        "size": item["size"],
+                    }
+                    for item in results
+                ],
+            }
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="Rename",
+        annotations=ToolAnnotations(idempotent_hint=False, open_world_hint=True),
+    )
+    async def nc_rename(path: str, new_name: str) -> dict[str, Any]:
+        """Rename a file or directory (same parent, new name)."""
+        try:
+            parent = path.rsplit("/", 1)[0] or "/"
+            destination = f"{parent}/{new_name}"
+            await client.move(path, destination)
+            return {"status": "ok", "old_path": path, "new_path": destination}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @mcp.tool(
+        title="List Comments",
+        annotations=ToolAnnotations(read_only_hint=True, open_world_hint=True),
+    )
+    async def nc_list_comments(path: str) -> dict[str, Any]:
+        """List comments for a file."""
+        try:
+            file_id = await client.get_file_id(path)
+            if file_id is None:
+                return {"error": f"Could not resolve file ID for {path}"}
+            # Use OCS Comments API
+            url = f"{client.base_url}/ocs/v2.php/apps/comments/api/v1/files/{file_id}"
+            async with httpx.AsyncClient(
+                auth=client.auth, verify=client.verify, timeout=30
+            ) as http:
+                response = await http.get(url, headers={"OCS-APIRequest": "true"})
+                response.raise_for_status()
+                data = response.json()
+                comments = data.get("ocs", {}).get("data", [])
+                return {"file_id": file_id, "comments": comments}
+        except Exception as e:
+            return {"error": str(e)}

nextcloud_mcp_lite-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "nextcloud-mcp-lite"
+version = "0.1.0"
+description = "Minimal MCP server for Nextcloud file sync and PIM"
+requires-python = ">=3.11"
+dependencies = [
+    "mcp[cli]>=2.1,<3",
+    "httpx>=0.28.1,<0.29",
+    "click>=8.1",
+    "icalendar>=7.3.0,<7.4",
+]
+
+[project.scripts]
+nextcloud-mcp = "nextcloud_mcp.cli:cli"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["nextcloud_mcp"]