codeocean-mcp-server 0.12.2__tar.gz → 0.13.0__tar.gz

{codeocean_mcp_server-0.12.2 → codeocean_mcp_server-0.13.0}/CHANGELOG.md

@@ -1,6 +1,13 @@
 CHANGELOG
 =========
 
+## 0.13.0 (2026-09-16)
+
+- [#46](https://github.com/codeocean/codeocean-mcp-server/pull/46) fix: bump mcp to 1.29.x and refresh locked dependencies
+- [#37](https://github.com/codeocean/codeocean-mcp-server/pull/37) feat: add capsule and pipeline release tools
+- [#47](https://github.com/codeocean/codeocean-mcp-server/pull/47) feat: add permissions and Git sync tools
+- **Minimum Code Ocean platform version updated to `4.8.0`.**
+
 ## 0.12.2 (2026-09-03)
 
 - [#42](https://github.com/codeocean/codeocean-mcp-server/pull/42) fix: run synchronous tool bodies in a worker thread

{codeocean_mcp_server-0.12.2 → codeocean_mcp_server-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeocean-mcp-server
-Version: 0.12.2
+Version: 0.13.0
 Summary: Code Ocean MCP Server
 Project-URL: Homepage, https://github.com/codeocean/codeocean-mcp-server
 Project-URL: Issues, https://github.com/codeocean/codeocean-mcp-server/issues
@@ -13,15 +13,15 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: anyio>=4.5
-Requires-Dist: codeocean<0.15.0,>=0.14.0
-Requires-Dist: mcp<1.24.0,>=1.23.0
+Requires-Dist: codeocean<0.18.0,>=0.17.0
+Requires-Dist: mcp<1.30.0,>=1.29.1
 Description-Content-Type: text/markdown
 
 # Code Ocean MCP Server
 
 Model Context Protocol (MCP) server for Code Ocean.
 
-This MCP server provides tools to search and run capsules and pipelines, and manage data assets.
+This MCP server provides tools to search, run, and release capsules and pipelines, and manage data assets.
 
 ## Table of Contents
 

{codeocean_mcp_server-0.12.2 → codeocean_mcp_server-0.13.0}/README.md

@@ -2,7 +2,7 @@
 
 Model Context Protocol (MCP) server for Code Ocean.
 
-This MCP server provides tools to search and run capsules and pipelines, and manage data assets.
+This MCP server provides tools to search, run, and release capsules and pipelines, and manage data assets.
 
 ## Table of Contents
 

{codeocean_mcp_server-0.12.2 → codeocean_mcp_server-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codeocean-mcp-server"
-version = "0.12.2"
+version = "0.13.0"
 authors = [{ name = "Code Ocean", email = "dev@codeocean.com" }]
 description = "Code Ocean MCP Server"
 readme = "README.md"
@@ -12,8 +12,8 @@ classifiers = [
 ]
 dependencies = [
   "anyio>=4.5",
-  "codeocean>=0.14.0,<0.15.0",
-  "mcp>=1.23.0,<1.24.0",
+  "codeocean>=0.17.0,<0.18.0",
+  "mcp>=1.29.1,<1.30.0",
 ]
 license = "MIT"
 
@@ -22,6 +22,7 @@ dev = [
   "boto3>=1.42.17",
   "deepdiff>=8.6.1",
   "hatch>=1.16.2",
+  "httpx>=0.28.1",
   "mcp-python-client>=0.1.9",
   "pytest>=9.0.2",
   "ruff>=0.14.10",

{codeocean_mcp_server-0.12.2 → codeocean_mcp_server-0.13.0}/src/codeocean_mcp_server/tools/capsules.py

@@ -2,11 +2,14 @@ from codeocean import CodeOcean
 from codeocean.capsule import (
     AppPanel,
     Capsule,
+    CapsuleReleaseJob,
     CapsuleSearchParams,
     Computation,
     DataAssetAttachParams,
     DataAssetAttachResults,
+    GitSyncResults,
 )
+from codeocean.components import Permissions
 from mcp.server.fastmcp import FastMCP
 
 from codeocean_mcp_server.models import dataclass_to_pydantic
@@ -17,7 +20,7 @@ CapsuleSearchParamsModel = dataclass_to_pydantic(CapsuleSearchParams)
 DataAssetAttachParamsModel = dataclass_to_pydantic(DataAssetAttachParams)
 
 
-def add_tools(mcp: FastMCP, client: CodeOcean):
+def add_tools(mcp: FastMCP, client: CodeOcean):  # noqa: C901
     """Add capsule tools to the MCP server."""
 
     @mcp.tool(description=(str(client.capsules.search_capsules.__doc__) + " " + str(CapsuleSearchResults.__doc__)))
@@ -86,3 +89,46 @@ def add_tools(mcp: FastMCP, client: CodeOcean):
     def get_capsule_app_panel(capsule_id: str, version: int | None = None) -> AppPanelModel:
         """Retrieve the app panel for a capsule, optionally for a specific version."""
         return client.capsules.get_capsule_app_panel(capsule_id, version)
+
+    @mcp.tool(description=(str(client.capsules.get_permissions.__doc__) + " Accepts a capsule ID or a pipeline ID."))
+    def get_capsule_permissions(capsule_id: str) -> Permissions:
+        """Get the users, groups and everyone-role permissions of a capsule or pipeline."""
+        return client.capsules.get_permissions(capsule_id)
+
+    @mcp.tool(
+        description=(
+            str(client.capsules.sync_capsule.__doc__)
+            + " Accepts a capsule ID or a pipeline ID. This pushes and pulls commits against the external"
+            " Git remote, so call it only when the user asked to sync."
+        )
+    )
+    def sync_capsule(capsule_id: str) -> GitSyncResults:
+        """Sync a capsule or pipeline with its linked external Git repository."""
+        return client.capsules.sync_capsule(capsule_id)
+
+    @mcp.tool(description=(str(client.capsules.release_capsule.__doc__) + " Accepts a capsule ID or a pipeline ID."))
+    def release_capsule(capsule_id: str) -> CapsuleReleaseJob:
+        """Start releasing a new version of an already-released capsule or pipeline."""
+        return client.capsules.release_capsule(capsule_id)
+
+    @mcp.tool(description=(str(client.capsules.get_release_job.__doc__) + " Accepts a capsule ID or a pipeline ID."))
+    def get_release_job(capsule_id: str, job_id: str) -> CapsuleReleaseJob:
+        """Get the status of a capsule or pipeline release job."""
+        return client.capsules.get_release_job(capsule_id, job_id)
+
+    @mcp.tool(
+        description=(
+            str(client.capsules.wait_until_release_completed.__doc__)
+            + " Accepts a capsule ID or a pipeline ID. Set `timeout` to bound the wait - without one this"
+            " polls until the release reaches a terminal state, however long that takes."
+        )
+    )
+    def wait_until_release_completed(
+        capsule_id: str,
+        job_id: str,
+        polling_interval: float = 5,
+        timeout: float | None = None,
+    ) -> CapsuleReleaseJob:
+        """Wait until a capsule or pipeline release job reaches a terminal state."""
+        job = client.capsules.get_release_job(capsule_id, job_id)
+        return client.capsules.wait_until_release_completed(capsule_id, job, polling_interval, timeout)

{codeocean_mcp_server-0.12.2 → codeocean_mcp_server-0.13.0}/src/codeocean_mcp_server/tools/data_assets.py

@@ -1,6 +1,7 @@
 import os
 
 from codeocean import CodeOcean
+from codeocean.components import Permissions
 from codeocean.data_asset import (
     DataAsset,
     DataAssetParams,
@@ -62,6 +63,11 @@ def add_tools(mcp: FastMCP, client: CodeOcean):
         file_urls = client.data_assets.get_data_asset_file_urls(data_asset_id, file_path)
         return download_and_read_file(file_urls.download_url)
 
+    @mcp.tool(description=client.data_assets.get_permissions.__doc__)
+    def get_data_asset_permissions(data_asset_id: str) -> Permissions:
+        """Get the users, groups and everyone-role permissions of a data asset."""
+        return client.data_assets.get_permissions(data_asset_id)
+
     @mcp.tool(description=client.data_assets.list_data_asset_files.__doc__)
     def list_data_asset_files(data_asset_id: str, path: str = "") -> Folder:
         """List files in a data asset."""

{codeocean_mcp_server-0.12.2 → codeocean_mcp_server-0.13.0}/tests/test_http_transport.py

@@ -16,24 +16,40 @@ import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 
+import httpx
 import pytest
 from mcp import ClientSession, StdioServerParameters
-from mcp.client.streamable_http import streamablehttp_client
+from mcp.client.streamable_http import streamable_http_client
 from mcp_client import get_tools
 
 SERVER_SCRIPT_PATH = str(Path(__file__).parent.parent / "src" / "codeocean_mcp_server" / "server.py")
 
-# How long the stub API takes to answer a token named "slow-...", standing in for a tool that waits.
-SLOW_API_SECONDS = 3.0
+# Upper bound on the test's own waits, so a regression fails the test instead of hanging it.
+RENDEZVOUS_TIMEOUT = 5.0
+
+# The stub API's escape hatch from a release that never comes, far enough past the test's own waits
+# that it cannot be what frees the server first.
+HELD_REQUEST_TIMEOUT = 60.0
 
 
 class _EchoTokenHandler(BaseHTTPRequestHandler):
-    """Answer the custom metadata endpoint with the basic-auth user, which is the API token."""
+    """Answer the custom metadata endpoint with the basic-auth user, which is the API token.
+
+    A token named "slow-..." stands in for a tool that waits on Code Ocean: the handler reports that
+    the request has arrived, then holds the response until the test releases it. Only a released
+    request is answered, so the test cannot mistake a lapsed hold for a server that stayed free.
+    """
+
+    slow_started = threading.Event()
+    slow_released = threading.Event()
 
     def do_GET(self):  # noqa: D102, N802
         user = base64.b64decode(self.headers["Authorization"].split(" ")[1]).decode().split(":")[0]
         if user.startswith("slow-"):
-            time.sleep(SLOW_API_SECONDS)
+            self.slow_started.set()
+            if not self.slow_released.wait(HELD_REQUEST_TIMEOUT):
+                self.send_error(500, "the held request was never released")
+                return
         body = json.dumps({"categories": [user]}).encode()
         self.send_response(200)
         self.send_header("Content-Type", "application/json")
@@ -94,10 +110,11 @@ def _stdio_server(domain: str) -> StdioServerParameters:
 
 async def _call_get_custom_metadata(url: str, token: str | None, scheme: str = "Bearer"):
     headers = {"Authorization": f"{scheme} {token}"} if token else None
-    async with streamablehttp_client(url, headers=headers) as (read_stream, write_stream, _):
-        async with ClientSession(read_stream, write_stream) as session:
-            await session.initialize()
-            return await session.call_tool("get_custom_metadata", {})
+    async with httpx.AsyncClient(headers=headers) as http_client:
+        async with streamable_http_client(url, http_client=http_client) as (read_stream, write_stream, _):
+            async with ClientSession(read_stream, write_stream) as session:
+                await session.initialize()
+                return await session.call_tool("get_custom_metadata", {})
 
 
 def test_concurrent_requests_use_their_own_token(http_server):
@@ -116,20 +133,31 @@ def test_concurrent_requests_use_their_own_token(http_server):
 
 
 def test_a_slow_tool_does_not_hold_up_other_requests(http_server):
-    """A tool call still waiting on Code Ocean leaves the server free to serve another session."""
-    url, _ = http_server
-
-    async def call_and_time(token: str):
-        result = await _call_get_custom_metadata(url, token)
-        return result, time.monotonic()
+    """A second session is served while a tool call is still waiting on Code Ocean.
 
-    async def both():
-        return await asyncio.gather(call_and_time("slow-token"), call_and_time("fast-token"))
-
-    (slow, slow_finished), (fast, fast_finished) = asyncio.run(both())
+    Fails if the synchronous tool runs on the event loop: the fast request then cannot even
+    initialize until the slow one is released, and times out.
+    """
+    url, _ = http_server
+    handler = _EchoTokenHandler
+
+    async def fast_while_slow_is_blocked():
+        slow = asyncio.create_task(_call_get_custom_metadata(url, "slow-token"))
+        try:
+            assert await asyncio.to_thread(handler.slow_started.wait, RENDEZVOUS_TIMEOUT), (
+                "the slow tool call never reached the stub API"
+            )
+            try:
+                fast = await asyncio.wait_for(_call_get_custom_metadata(url, "fast-token"), RENDEZVOUS_TIMEOUT)
+            except asyncio.TimeoutError:
+                pytest.fail("the fast request did not complete while the slow tool call was blocked")
+        finally:
+            handler.slow_released.set()
+        return await slow, fast
+
+    slow, fast = asyncio.run(fast_while_slow_is_blocked())
     assert slow.structuredContent["categories"] == ["slow-token"]
     assert fast.structuredContent["categories"] == ["fast-token"]
-    assert fast_finished < slow_finished - 1
 
 
 def test_request_without_credential_is_refused(http_server):
@@ -153,7 +181,7 @@ def test_tool_definitions_match_stdio(http_server):
     url, domain = http_server
 
     async def list_over_http():
-        async with streamablehttp_client(url) as (read_stream, write_stream, _):
+        async with streamable_http_client(url) as (read_stream, write_stream, _):
             async with ClientSession(read_stream, write_stream) as session:
                 await session.initialize()
                 return (await session.list_tools()).tools