Simplify basic-server-vanillajs to be self-contained

- Remove dependency on shared `server-utils.js`
- Use Express + `StreamableHTTPServerTransport` directly
- Simplify tool response to plain ISO time string
- Add graceful shutdown handling
- Remove artificial delay in UI teardown handler

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: jonathanhefner

examples/basic-server-vanillajs/server.ts

@@ -1,73 +1,104 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import type { CallToolResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import cors from "cors";
+import express, { type Request, type Response } from "express";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { RESOURCE_MIME_TYPE, RESOURCE_URI_META_KEY } from "../../dist/src/app";
-import { startServer } from "../shared/server-utils.js";
 
+const PORT = parseInt(process.env.PORT ?? "3002", 10);
 const DIST_DIR = path.join(import.meta.dirname, "dist");
-const RESOURCE_URI = "ui://get-time/mcp-app.html";
-
-/**
- * Creates a new MCP server instance with tools and resources registered.
- * Each HTTP session needs its own server instance because McpServer only supports one transport.
- */
-function createServer(): McpServer {
-  const server = new McpServer({
-    name: "Basic MCP App Server (Vanilla JS)",
-    version: "1.0.0",
-  });
 
-  // MCP Apps require two-part registration: a tool (what the LLM calls) and a
-  // resource (the UI it renders). The `_meta` field on the tool links to the
-  // resource URI, telling hosts which UI to display when the tool executes.
+
+const server = new McpServer({
+  name: "Basic MCP App Server (Vanilla JS)",
+  version: "1.0.0",
+});
+
+
+{
+  // Two-part registration: tool + resource, tied together by the resource URI.
+  const resourceUri = "ui://get-time/mcp-app.html";
+
+  // Register a tool with UI metadata. When the host calls this tool, it reads
+  // `_meta[RESOURCE_URI_META_KEY]` to know which resource to fetch and render as
+  // an interactive UI.
   server.registerTool(
     "get-time",
     {
       title: "Get Time",
       description: "Returns the current server time as an ISO 8601 string.",
       inputSchema: {},
-      _meta: { [RESOURCE_URI_META_KEY]: RESOURCE_URI },
+      _meta: { [RESOURCE_URI_META_KEY]: resourceUri },
     },
     async (): Promise<CallToolResult> => {
       const time = new Date().toISOString();
-      return {
-        content: [{ type: "text", text: JSON.stringify({ time }) }],
-      };
+      return { content: [{ type: "text", text: time }] };
     },
   );
 
+  // Register the resource, which returns the bundled HTML/JavaScript for the UI.
   server.registerResource(
-    RESOURCE_URI,
-    RESOURCE_URI,
+    resourceUri,
+    resourceUri,
     { mimeType: RESOURCE_MIME_TYPE },
     async (): Promise<ReadResourceResult> => {
       const html = await fs.readFile(path.join(DIST_DIR, "mcp-app.html"), "utf-8");
 
       return {
         contents: [
-          // Per the MCP App specification, "text/html;profile=mcp-app" signals
-          // to the Host that this resource is indeed for an MCP App UI.
-          { uri: RESOURCE_URI, mimeType: RESOURCE_MIME_TYPE, text: html },
+          { uri: resourceUri, mimeType: RESOURCE_MIME_TYPE, text: html },
         ],
       };
     },
   );
-
-  return server;
 }
 
-async function main() {
-  if (process.argv.includes("--stdio")) {
-    await createServer().connect(new StdioServerTransport());
-  } else {
-    const port = parseInt(process.env.PORT ?? "3102", 10);
-    await startServer(createServer, { port, name: "Basic MCP App Server (Vanilla JS)" });
+
+// Start an Express server that exposes the MCP endpoint.
+const expressApp = express();
+expressApp.use(cors());
+expressApp.use(express.json());
+
+expressApp.post("/mcp", async (req: Request, res: Response) => {
+  try {
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: undefined,
+      enableJsonResponse: true,
+    });
+    res.on("close", () => { transport.close(); });
+
+    await server.connect(transport);
+
+    await transport.handleRequest(req, res, req.body);
+  } catch (error) {
+    console.error("Error handling MCP request:", error);
+    if (!res.headersSent) {
+      res.status(500).json({
+        jsonrpc: "2.0",
+        error: { code: -32603, message: "Internal server error" },
+        id: null,
+      });
+    }
   }
-}
+});
 
-main().catch((e) => {
-  console.error(e);
-  process.exit(1);
+const httpServer = expressApp.listen(PORT, (err) => {
+  if (err) {
+    console.error("Error starting server:", err);
+    process.exit(1);
+  }
+  console.log(`Server listening on http://localhost:${PORT}/mcp`);
 });
+
+function shutdown() {
+  console.log("\nShutting down...");
+  httpServer.close(() => {
+    console.log("Server closed");
+    process.exit(0);
+  });
+}
+
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);

examples/basic-server-vanillajs/src/mcp-app.ts

@@ -15,12 +15,8 @@ const log = {
 
 
 function extractTime(result: CallToolResult): string {
-  const text = result.content!
-    .filter((c): c is { type: "text"; text: string } => c.type === "text")
-    .map((c) => c.text)
-    .join("");
-  const { time } = JSON.parse(text) as { time: string };
-  return time;
+  const { text } = result.content?.find((c) => c.type === "text")!;
+  return text;
 }
 
 
@@ -40,8 +36,6 @@ const app = new App({ name: "Get Time App", version: "1.0.0" });
 
 app.onteardown = async () => {
   log.info("App is being torn down");
-  await new Promise((resolve) => setTimeout(resolve, 500)); // Simulate cleanup work
-  log.info("App teardown complete");
   return {};
 };