Mobile MCP: let AI agents drive your iOS and Android apps. MCP server for simulators, emulators and real devices. Works with Claude Code, Codex, Cursor and any MCP client.
TypeScript agentandroidandroid-automationappium-alternativeclaude-codecodexcursoremulatoriosios-automationmcpmcp-servermobilemobile-automationmobile-testingreal-devicesimulatorskills
fix: serve server/discover for the 2026-07-28 protocol revision (#451)
Rahulec61fe05a5de
diff --git a/src/index.ts b/src/index.tsindex f22ee13..5f8ea67 100644--- a/src/index.ts+++ b/src/index.ts@@ -1,7 +1,8 @@#!/usr/bin/env nodeimport { createMcpExpressApp } from "@modelcontextprotocol/express";-import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";-import { NodeStreamableHTTPServerTransport } from "@modelcontextprotocol/node";+import { toNodeHandler } from "@modelcontextprotocol/node";+import { createMcpHandler } from "@modelcontextprotocol/server";+import { serveStdio } from "@modelcontextprotocol/server/stdio";import { createMcpServer, getAgentVersion, getSdkVersion } from "./server";import { error } from "./logger";import { Request, Response } from "express";@@ -41,37 +42,20 @@ const startHttpServer = async (host: string, port: number) => {});}- const handleMcpRequest = async (req: Request, res: Response) => {- // Stateless Streamable HTTP: fresh server + transport per request- // (Smithery / horizontal-host friendly; no session affinity).- const server = createMcpServer();- try {- const transport = new NodeStreamableHTTPServerTransport({- sessionIdGenerator: undefined,- });- // Register cleanup first: the response can close before handleRequest resolves.- res.on("close", () => {- transport.close();- server.close();- });- await server.connect(transport);- await transport.handleRequest(req, res, req.body);- } catch (err: unknown) {- error("Error handling MCP request: " + (err instanceof Error ? err.stack : String(err)));- if (!res.headersSent) {- res.status(500).json({- jsonrpc: "2.0",- error: {- code: -32603,- message: "Internal server error",- },- id: null,- });- }- }- };-- app.post("/mcp", handleMcpRequest);+ // createMcpHandler serves both protocol eras from one factory: requests+ // carrying the per-request `_meta` envelope (revision 2026-07-28, answered+ // with `server/discover` and the modern result vocabulary) get a fresh+ // era-marked instance, and legacy `initialize` traffic is served stateless+ // from the same factory — the same per-request model as before.+ // onerror keeps request-handling and transport failures in the application+ // log (the SDK otherwise answers HTTP 500 silently).+ const onerror = (err: Error) => error("Error handling MCP request: " + (err.stack ?? String(err)));+ const handler = createMcpHandler(() => createMcpServer(), { onerror });+ const node = toNodeHandler(handler, { onerror });++ app.all("/mcp", (req: Request, res: Response) => {+ void node(req, res, req.body);+ });// Stateless mode has no long-lived sessions; GET (SSE stream) and DELETE// (session teardown) are not applicable. Return 405 per SDK guidance.@@ -96,10 +80,11 @@ const startHttpServer = async (host: string, port: number) => {const startStdioServer = async () => {try {- const transport = new StdioServerTransport();-- const server = createMcpServer();- await server.connect(transport);+ // serveStdio owns the transport and the era decision for the+ // connection: a `server/discover` probe (revision 2026-07-28) pins+ // the connection modern, while an `initialize` handshake keeps+ // serving the 2025-era protocol exactly as before.+ serveStdio(() => createMcpServer());// Exit cleanly on termination signals so node flushes pending work// (including NODE_V8_COVERAGE output). Node's default SIGINT/SIGTERMdiff --git a/test/server-discover.test.ts b/test/server-discover.test.tsnew file mode 100644index 0000000..71da5a9--- /dev/null+++ b/test/server-discover.test.ts@@ -0,0 +1,90 @@+import { expect, test } from "@playwright/test";+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";+import { createMcpHandler } from "@modelcontextprotocol/server";+import { createMcpServer } from "../src/server";++const discoverRequestBody = (id: string | number) =>+ JSON.stringify({+ jsonrpc: "2.0",+ id,+ method: "server/discover",+ params: {+ _meta: {+ "io.modelcontextprotocol/protocolVersion": "2026-07-28",+ "io.modelcontextprotocol/clientInfo": { name: "discover-test", version: "1.0.0" },+ "io.modelcontextprotocol/clientCapabilities": {},+ },+ },+ });++test("serves server/discover for the 2026-07-28 protocol revision", async () => {+ const previousTelemetrySetting = process.env.MOBILEMCP_DISABLE_TELEMETRY;+ process.env.MOBILEMCP_DISABLE_TELEMETRY = "1";++ try {+ // createMcpHandler is the serving entry production uses; it marks+ // each request's instance as serving the 2026-07-28 era, which is+ // what installs the server/discover handler. A hand-constructed+ // McpServer connected straight to a transport never serves+ // server/discover (the era gate answers -32601 instead).+ const handler = createMcpHandler(() => createMcpServer());++ const response = await handler.fetch(+ new Request("http://localhost/mcp", {+ method: "POST",+ headers: {+ "Content-Type": "application/json",+ "Accept": "application/json, text/event-stream",+ "MCP-Protocol-Version": "2026-07-28",+ "Mcp-Method": "server/discover",+ },+ body: discoverRequestBody("discover-1"),+ }),+ );++ expect(response.status).toBe(200);+ const body = await response.json();+ expect(body.error).toBeUndefined();+ expect(body.result.supportedVersions).toContain("2026-07-28");+ expect(body.result.capabilities.tools).toBeDefined();+ expect(body.result.resultType).toBe("complete");+ expect(body.result._meta?.["io.modelcontextprotocol/serverInfo"]?.name).toBe("mobile-mcp");+ } finally {+ if (previousTelemetrySetting === undefined) {+ delete process.env.MOBILEMCP_DISABLE_TELEMETRY;+ } else {+ process.env.MOBILEMCP_DISABLE_TELEMETRY = previousTelemetrySetting;+ }+ }+});++test("still serves the legacy initialize handshake", async () => {+ const previousTelemetrySetting = process.env.MOBILEMCP_DISABLE_TELEMETRY;+ process.env.MOBILEMCP_DISABLE_TELEMETRY = "1";++ try {+ const server = createMcpServer();+ const client = new Client({ name: "legacy-test", version: "1.0.0" });+ const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();++ try {+ await server.connect(serverTransport);+ await client.connect(clientTransport);++ expect(client.getProtocolEra()).toBe("legacy");+ expect(client.getServerVersion()?.name).toBe("mobile-mcp");++ const tools = await client.listTools();+ expect(tools.tools.length).toBeGreaterThan(0);+ } finally {+ await client.close();+ await server.close();+ }+ } finally {+ if (previousTelemetrySetting === undefined) {+ delete process.env.MOBILEMCP_DISABLE_TELEMETRY;+ } else {+ process.env.MOBILEMCP_DISABLE_TELEMETRY = previousTelemetrySetting;+ }+ }+});