mcp-server-appwrite 2.2.0__tar.gz → 2.2.1__tar.gz

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcp-server-appwrite
-Version: 2.2.0
+Version: 2.2.1
 Summary: Build and deploy application backends. Add authentication, PostgreSQL/MySQL databases, vector databases, storage, serverless functions, realtime, messaging, hosting, domains, CDN and firewall.
 License-File: LICENSE
 Requires-Python: >=3.12

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/docs/apps.md

@@ -48,6 +48,24 @@ text summary. 2026-07-28 clients send `clientCapabilities` with every request,
 and stdio has the handshake, so both are gated exactly. `tools/call` is not
 gated, because the view's own calls reach the server through the host.
 
+## Telemetry
+
+On the hosted transport, two counters show which views people use:
+
+- `mcp.apps.views` counts `appwrite_show` calls by `view` (`invalid` for a name
+  that is not one), `status` (`success` or `error`), `client_id`, and `origin`:
+  `model` when the model opens a view, `view` when the view refreshes, pages,
+  polls a build or opens a row on its own. Views opened per view type is
+  `origin="model"`; how much people then use each view is `origin="view"`.
+- `mcp.apps.writes` counts `appwrite_view_write` calls by `action` (the
+  allowlisted write, or `invalid`), `status` and `client_id`.
+
+The view marks its own calls with `"io.appwrite/origin": "view"` in the
+request's `_meta`. Hosts forward a view's `tools/call` params as sent; a host
+that drops `_meta` makes those calls count as `origin="model"`. Both counters
+feed the MCP Apps row of the MCP dashboard (appwrite-labs/monitoring
+`dashboards/Cloud/mcp.json`).
+
 ## Security
 
 - The resource declares no CSP domains, so hosts apply the spec's restrictive

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/src/mcp_server_appwrite/apps/protocol.py

@@ -19,6 +19,8 @@ Apps are offered behind the ``apps`` flag (``MCP_APPS``); see :func:`enabled`.
 from __future__ import annotations
 
 from collections.abc import Mapping
+from contextvars import ContextVar
+from enum import StrEnum
 from typing import Any
 
 from mcp.server import Server, ServerRequestContext
@@ -34,6 +36,22 @@ MIME_TYPE = "text/html;profile=mcp-app"
 
 SETTINGS: dict[str, Any] = {"mimeTypes": [MIME_TYPE]}
 
+ORIGIN_META_KEY = "io.appwrite/origin"
+"""The request ``_meta`` key the view sets to ``"view"`` on its own calls, so
+telemetry can tell a view refreshing and paging itself from the model opening
+one. Hosts forward a view's ``tools/call`` params as sent; a host that drops
+``_meta`` makes those calls count as the model's."""
+
+
+class Origin(StrEnum):
+    MODEL = "model"
+    VIEW = "view"
+
+
+_origin: ContextVar[Origin] = ContextVar(
+    "appwrite_mcp_apps_origin", default=Origin.MODEL
+)
+
 
 def enabled() -> bool:
     """Whether this server offers MCP Apps."""
@@ -56,6 +74,20 @@ def supported(context: ServerRequestContext[Any, Any]) -> bool:
     return not isinstance(mime_types, list) or MIME_TYPE in mime_types
 
 
+def bind_origin(context: ServerRequestContext[Any, Any]) -> None:
+    """Remember who made this ``tools/call``: the view, when its ``_meta``
+    says so, else the model. Contextvars reach the worker thread that runs the
+    tool."""
+    meta = context.meta
+    from_view = isinstance(meta, Mapping) and meta.get(ORIGIN_META_KEY) == Origin.VIEW
+    _origin.set(Origin.VIEW if from_view else Origin.MODEL)
+
+
+def origin() -> Origin:
+    """Who made the ``tools/call`` being served."""
+    return _origin.get()
+
+
 def register(server: Server[Any]) -> None:
     """Advertise the extension in ``server``'s capabilities."""
     server.extensions[EXTENSION] = dict(SETTINGS)

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/src/mcp_server_appwrite/apps/views.py

@@ -29,8 +29,9 @@ from typing import Any
 import mcp.types as types
 from appwrite_console.query import Query
 
+from .. import telemetry
 from ..constants import SHOW_TOOL_NAME, VIEW_WRITE_TOOL_NAME
-from . import executions, files, resource, usage, users
+from . import executions, files, protocol, resource, usage, users
 
 Run = Callable[[dict[str, Any], bool], list[Any]]
 """Runs a hidden catalog tool from raw call arguments (``tool_name``,
@@ -86,6 +87,18 @@ class Views:
         return [(_show_tool(), self.show), (_write_tool(), self.write)]
 
     def show(self, arguments: dict[str, Any]) -> types.CallToolResult:
+        view = arguments.get("view")
+        status = "error"
+        try:
+            result = self._show(arguments)
+            status = "success"
+            return result
+        finally:
+            telemetry.record_view(
+                str(view) if view in View else "invalid", protocol.origin(), status
+            )
+
+    def _show(self, arguments: dict[str, Any]) -> types.CallToolResult:
         view = arguments.get("view")
         if view == View.TABLE:
             data = self._table(arguments)
@@ -113,6 +126,18 @@ class Views:
         )
 
     def write(self, arguments: dict[str, Any]) -> types.CallToolResult:
+        tool_name = arguments.get("tool_name")
+        status = "error"
+        try:
+            result = self._write(arguments)
+            status = "success"
+            return result
+        finally:
+            telemetry.record_view_write(
+                tool_name if tool_name in WRITES else "invalid", status
+            )
+
+    def _write(self, arguments: dict[str, Any]) -> types.CallToolResult:
         tool_name = arguments.get("tool_name")
         if tool_name not in WRITES:
             raise ValueError(

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/src/mcp_server_appwrite/assets/view.html

@@ -304,6 +304,8 @@ details.headers td { height: 32px; max-width: none; white-space: normal; overflo
   const PROTOCOL_VERSION = "2026-01-26";
   const SHOW_TOOL = "appwrite_show";
   const WRITE_TOOL = "appwrite_view_write";
+  // Tells the server's telemetry this call is the view's, not the model's.
+  const ORIGIN = { "io.appwrite/origin": "view" };
   const POLL_MS = 3000;
   const PAGE_SIZE = 25;
   const FILES_PAGE = 24;
@@ -352,7 +354,7 @@ details.headers td { height: 32px; max-width: none; white-space: normal; overflo
   }
 
   async function callTool(name, args) {
-    const result = await request("tools/call", { name, arguments: args });
+    const result = await request("tools/call", { name, arguments: args, _meta: ORIGIN });
     if (result && result.isError) {
       throw new Error(textOf(result) || "The Appwrite call failed.");
     }

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/src/mcp_server_appwrite/data/docs_index.npz

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
-name: mcp_server_appwrite-2.2.0/src/mcp_server_appwrite/data/docs_index.npz
+name: mcp_server_appwrite-2.2.1/src/mcp_server_appwrite/data/docs_index.npz
 size: 35543664 bytes
 sha256: 61d266fdb9a958b272d1b351cc6ebd6e824b0d0fe294483703e0795e4b0580df

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/src/mcp_server_appwrite/server.py

@@ -1379,6 +1379,7 @@ def build_mcp_server(
         ctx: ServerRequestContext, params: types.CallToolRequestParams
     ) -> types.CallToolResult:
         _emit_initialize(ctx)
+        apps.bind_origin(ctx)
         start = time.monotonic()
         name = params.name
         arguments = params.arguments or {}

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/src/mcp_server_appwrite/telemetry.py

@@ -311,6 +311,20 @@ def _build_instruments(meter: Any, transport: str, version: str) -> None:
         ),
     )
 
+    _instruments["apps_views"] = meter.create_counter(
+        "mcp.apps.views",
+        unit="{call}",
+        description=(
+            "MCP Apps appwrite_show calls by view, origin (the model opening a "
+            "view, or the view refreshing and paging itself) and status."
+        ),
+    )
+    _instruments["apps_writes"] = meter.create_counter(
+        "mcp.apps.writes",
+        unit="{call}",
+        description="MCP Apps appwrite_view_write calls by action and status.",
+    )
+
     _instruments["token_usage"] = meter.create_counter(
         "mcp.token.usage",
         unit="{token}",
@@ -711,6 +725,30 @@ def record_tool_call(
         )
 
 
+def record_view(view: str, origin: str, status: str) -> None:
+    """One ``appwrite_show`` call. ``view`` is a view name, or ``invalid``."""
+    _safe_add(
+        "apps_views",
+        1,
+        {
+            "view": view,
+            "origin": origin,
+            "status": status,
+            "client_id": current_client_id(),
+        },
+    )
+
+
+def record_view_write(action: str, status: str) -> None:
+    """One ``appwrite_view_write`` call. ``action`` is an allowlisted catalog
+    write, or ``invalid``."""
+    _safe_add(
+        "apps_writes",
+        1,
+        {"action": action, "status": status, "client_id": current_client_id()},
+    )
+
+
 def record_hallucination(attempted_tool: Any) -> None:
     _safe_add(
         "tool_hallucination",

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/tests/e2e/support.py

@@ -302,7 +302,7 @@ class Client:
         self, method: str, params: Mapping[str, Any] | None = None, *, path: str = "/"
     ) -> tuple[int, dict[str, Any]]:
         """One 2026-07-28 request: protocol version and method in the headers,
-        client identity in ``params._meta``."""
+        client identity in ``params._meta`` next to any ``_meta`` in ``params``."""
         body = {
             "jsonrpc": "2.0",
             "id": next(self._ids),
@@ -316,6 +316,7 @@ class Client:
                         "version": "1",
                     },
                     "io.modelcontextprotocol/clientCapabilities": self._capabilities,
+                    **(params or {}).get("_meta", {}),
                 },
             },
         }

{mcp_server_appwrite-2.2.0 → mcp_server_appwrite-2.2.1}/tests/e2e/test_apps.py

@@ -25,6 +25,7 @@ from support import (
     Cloud,
     Project,
     Server,
+    collector,
     column,
     deployment,
     execution,
@@ -42,6 +43,10 @@ EXTENSION = "io.modelcontextprotocol/ui"
 MIME_TYPE = "text/html;profile=mcp-app"
 VIEW_URI = "ui://appwrite/view"
 UI = {"extensions": {EXTENSION: {"mimeTypes": [MIME_TYPE]}}}
+FROM_VIEW = {"io.appwrite/origin": "view"}
+"""The ``_meta`` the view sends on its own calls."""
+VIEWS = "mcp.apps.views"
+WRITES = "mcp.apps.writes"
 ROWS = 30
 PAGE = 25
 LOG_LINES = 250
@@ -225,10 +230,16 @@ class AppsFlow(unittest.TestCase):
         cls.host.__exit__(None, None, None)
         cls.server.__exit__(None, None, None)
 
-    def call(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
-        status, response = self.host.call(
-            "tools/call", {"name": name, "arguments": arguments}
-        )
+    def call(
+        self,
+        name: str,
+        arguments: dict[str, Any],
+        meta: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"name": name, "arguments": arguments}
+        if meta is not None:
+            params["_meta"] = meta
+        status, response = self.host.call("tools/call", params)
         self.assertEqual(status, 200, response)
         return response["result"]
 
@@ -290,6 +301,9 @@ class AppsFlow(unittest.TestCase):
         # Appwrite data reaches the DOM as text only.
         self.assertNotIn("innerHTML", html)
         self.assertNotIn("insertAdjacentHTML", html)
+        # The view tags its own calls so telemetry can tell them apart.
+        self.assertIn('"io.appwrite/origin": "view"', html)
+        self.assertIn("_meta: ORIGIN", html)
         digest = hashlib.sha256(html.encode("utf-8")).hexdigest()[:12]
         self.assertEqual(uri, f"{VIEW_URI}/{digest}")
 
@@ -316,6 +330,8 @@ class AppsFlow(unittest.TestCase):
 
     def test_table_view_pages_through_rows(self):
         listed = cloud.calls("GET", rf"/v1/tablesdb/{DATABASE}/tables/{TABLE}/rows")
+        opened = collector().count(VIEWS, view="table", origin="model")
+        paged = collector().count(VIEWS, view="table", origin="view")
         result = self.show_table()
         data = result["structuredContent"]
         self.assertEqual(data["view"], "table")
@@ -353,9 +369,37 @@ class AppsFlow(unittest.TestCase):
             listed + 3,
         )
 
+        # The model opened the view; the view pages itself under its own origin.
+        self.call(
+            "appwrite_show",
+            {
+                "view": "table",
+                "project_id": PROJECT,
+                "database_id": DATABASE,
+                "table_id": TABLE,
+                "cursor": "ord_002",
+            },
+            meta=FROM_VIEW,
+        )
+        self.assertEqual(
+            collector().count(VIEWS, view="table", origin="view", status="success"),
+            paged + 1,
+        )
+        self.assertGreater(
+            collector().count(VIEWS, view="table", origin="model", status="success"),
+            opened,
+        )
+        self.assertEqual(
+            collector().count(VIEWS, view="table", origin="view"), paged + 1
+        )
+
     def test_view_writes_only_its_allowlist_and_only_when_confirmed(self):
         row_path = rf"/v1/tablesdb/{DATABASE}/tables/{TABLE}/rows/ord_001"
         writes = cloud.calls("PATCH", row_path)
+        action = "tables_db_update_row"
+        refused = collector().count(WRITES, action=action, status="error")
+        succeeded = collector().count(WRITES, action=action, status="success")
+        invalid = collector().count(WRITES, action="invalid")
         update = {
             "tool_name": "tables_db_update_row",
             "project_id": PROJECT,
@@ -396,6 +440,16 @@ class AppsFlow(unittest.TestCase):
         self.assertFalse(result.get("isError"), result)
         self.assertEqual(result["structuredContent"]["status"], "refunded")
         self.assertEqual(cloud.calls("PATCH", row_path), writes + 1)
+        # Every refusal and the write itself are counted by action; a tool off
+        # the allowlist is never named.
+        self.assertEqual(
+            collector().count(WRITES, action=action, status="error"), refused + 4
+        )
+        self.assertEqual(
+            collector().count(WRITES, action=action, status="success"), succeeded + 1
+        )
+        self.assertEqual(collector().count(WRITES, action="invalid"), invalid + 1)
+        self.assertEqual(collector().count(WRITES, action="tables_db_delete_row"), 0)
         last = self.show_table(cursor="ord_002")["structuredContent"]["rows"]
         self.assertEqual(last[0]["$id"], "ord_001")
         self.assertEqual(last[0]["status"], "refunded")
@@ -733,6 +787,8 @@ class AppsFlow(unittest.TestCase):
         self.assertIn("limit_history_exceeded", refused["content"][0]["text"])
 
     def test_bad_requests_are_tool_errors(self):
+        invalid = collector().count(VIEWS, view="invalid", status="error")
+        files = collector().count(VIEWS, view="files", status="error")
         cases = [
             (
                 {"view": "chart"},
@@ -773,6 +829,14 @@ class AppsFlow(unittest.TestCase):
                 result = self.call("appwrite_show", arguments)
                 self.assertTrue(result["isError"])
                 self.assertIn(error, result["content"][0]["text"])
+        # An unknown view name is not a label; a known one fails under its name.
+        self.assertEqual(
+            collector().count(VIEWS, view="invalid", status="error"), invalid + 1
+        )
+        self.assertEqual(collector().count(VIEWS, view="chart"), 0)
+        self.assertEqual(
+            collector().count(VIEWS, view="files", status="error"), files + 1
+        )
 
 
 if __name__ == "__main__":