Merge branch 'main' into patch-1

Author: hsheth2

README.md

@@ -173,18 +173,45 @@ Optionally, you can add it to a file called `.vscode/mcp.json` in your workspace
 }
 ```
 
-## Run with [HTTP+SSE Transport](https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse) (deprecated as of [2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports))
+## Running from source with [HTTP+SSE Transport](https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse) (deprecated as of [2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports))
 
 ```shell
 cd src/everything
 npm install
 npm run start:sse
 ```
 
-## Run with [Streamable HTTP Transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http)
+## Run from source with [Streamable HTTP Transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http)
 
 ```shell
 cd src/everything
 npm install
 npm run start:streamableHttp
 ```
+
+## Running as an installed package
+### Install 
+```shell
+npm install -g @modelcontextprotocol/server-everything@latest
+````
+
+### Run the default (stdio) server
+```shell
+npx @modelcontextprotocol/server-everything
+```
+
+### Or specify stdio explicitly
+```shell
+npx @modelcontextprotocol/server-everything stdio
+```
+
+### Run the SSE server
+```shell
+npx @modelcontextprotocol/server-everything sse
+```
+
+### Run the streamable HTTP server
+```shell
+npx @modelcontextprotocol/server-everything streamableHttp
+```
+

package-lock.json

@@ -1,23 +1,37 @@
 #!/usr/bin/env node
 
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createServer } from "./everything.js";
+// Parse command line arguments first
+const args = process.argv.slice(2);
+const scriptName = args[0] || 'stdio';
 
-async function main() {
-  const transport = new StdioServerTransport();
-  const { server, cleanup } = createServer();
-
-  await server.connect(transport);
-
-  // Cleanup on exit
-  process.on("SIGINT", async () => {
-    await cleanup();
-    await server.close();
-    process.exit(0);
-  });
+async function run() {
+    try {
+        // Dynamically import only the requested module to prevent all modules from initializing
+        switch (scriptName) {
+            case 'stdio':
+                // Import and run the default server
+                await import('./stdio.js');
+                break;
+            case 'sse':
+                // Import and run the SSE server
+                await import('./sse.js');
+                break;
+            case 'streamableHttp':
+                // Import and run the streamable HTTP server
+                await import('./streamableHttp.js');
+                break;
+            default:
+                console.error(`Unknown script: ${scriptName}`);
+                console.log('Available scripts:');
+                console.log('- stdio');
+                console.log('- sse');
+                console.log('- streamableHttp');
+                process.exit(1);
+        }
+    } catch (error) {
+        console.error('Error running script:', error);
+        process.exit(1);
+    }
 }
 
-main().catch((error) => {
-  console.error("Server error:", error);
-  process.exit(1);
-});
+run();

src/everything/README.md

@@ -22,7 +22,7 @@
     "start:streamableHttp": "node dist/streamableHttp.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.10.1",
+    "@modelcontextprotocol/sdk": "^1.11.0",
     "express": "^4.21.1",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5"

src/everything/index.ts

@@ -2,31 +2,40 @@ import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import express from "express";
 import { createServer } from "./everything.js";
 
+console.error('Starting SSE server...');
+
 const app = express();
 
 const { server, cleanup } = createServer();
 
 let transport: SSEServerTransport;
 
 app.get("/sse", async (req, res) => {
-  console.log("Received connection");
+  console.error("Received connection");
   transport = new SSEServerTransport("/message", res);
   await server.connect(transport);
 
   server.onclose = async () => {
     await cleanup();
     await server.close();
-    process.exit(0);
   };
+
 });
 
 app.post("/message", async (req, res) => {
-  console.log("Received message");
+  console.error("Received message");
 
   await transport.handlePostMessage(req, res);
 });
 
+process.on("SIGINT", async () => {
+  await cleanup();
+  await server.close();
+  process.exit(0);
+});
+
 const PORT = process.env.PORT || 3001;
 app.listen(PORT, () => {
-  console.log(`Server is running on port ${PORT}`);
+  console.error(`Server is running on port ${PORT}`);
 });
+

src/everything/package.json

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./everything.js";
+
+console.error('Starting default (STDIO) server...');
+
+async function main() {
+  const transport = new StdioServerTransport();
+  const {server, cleanup} = createServer();
+
+  await server.connect(transport);
+
+  // Cleanup on exit
+  process.on("SIGINT", async () => {
+    await cleanup();
+    await server.close();
+    process.exit(0);
+  });
+}
+
+main().catch((error) => {
+  console.error("Server error:", error);
+  process.exit(1);
+});
+

src/everything/sse.ts

@@ -4,14 +4,16 @@ import express, { Request, Response } from "express";
 import { createServer } from "./everything.js";
 import { randomUUID } from 'node:crypto';
 
+console.error('Starting Streamable HTTP server...');
+
 const app = express();
 
 const { server, cleanup } = createServer();
 
 const transports: { [sessionId: string]: StreamableHTTPServerTransport } = {};
 
 app.post('/mcp', async (req: Request, res: Response) => {
-  console.log('Received MCP POST request');
+  console.error('Received MCP POST request');
   try {
     // Check for existing session ID
     const sessionId = req.headers['mcp-session-id'] as string | undefined;
@@ -29,7 +31,7 @@ app.post('/mcp', async (req: Request, res: Response) => {
         onsessioninitialized: (sessionId) => {
           // Store the transport by session ID when session is initialized
           // This avoids race conditions where requests might come in before the session is stored
-          console.log(`Session initialized with ID: ${sessionId}`);
+          console.error(`Session initialized with ID: ${sessionId}`);
           transports[sessionId] = transport;
         }
       });
@@ -38,7 +40,7 @@ app.post('/mcp', async (req: Request, res: Response) => {
       transport.onclose = () => {
         const sid = transport.sessionId;
         if (sid && transports[sid]) {
-          console.log(`Transport closed for session ${sid}, removing from transports map`);
+          console.error(`Transport closed for session ${sid}, removing from transports map`);
           delete transports[sid];
         }
       };
@@ -83,7 +85,7 @@ app.post('/mcp', async (req: Request, res: Response) => {
 
 // Handle GET requests for SSE streams (using built-in support from StreamableHTTP)
 app.get('/mcp', async (req: Request, res: Response) => {
-  console.log('Received MCP GET request');
+  console.error('Received MCP GET request');
   const sessionId = req.headers['mcp-session-id'] as string | undefined;
   if (!sessionId || !transports[sessionId]) {
     res.status(400).json({
@@ -100,9 +102,9 @@ app.get('/mcp', async (req: Request, res: Response) => {
   // Check for Last-Event-ID header for resumability
   const lastEventId = req.headers['last-event-id'] as string | undefined;
   if (lastEventId) {
-    console.log(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
+    console.error(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
   } else {
-    console.log(`Establishing new SSE stream for session ${sessionId}`);
+    console.error(`Establishing new SSE stream for session ${sessionId}`);
   }
 
   const transport = transports[sessionId];
@@ -124,7 +126,7 @@ app.delete('/mcp', async (req: Request, res: Response) => {
     return;
   }
 
-  console.log(`Received session termination request for session ${sessionId}`);
+  console.error(`Received session termination request for session ${sessionId}`);
 
   try {
     const transport = transports[sessionId];
@@ -148,17 +150,17 @@ app.delete('/mcp', async (req: Request, res: Response) => {
 // Start the server
 const PORT = process.env.PORT || 3001;
 app.listen(PORT, () => {
-  console.log(`MCP Streamable HTTP Server listening on port ${PORT}`);
+  console.error(`MCP Streamable HTTP Server listening on port ${PORT}`);
 });
 
 // Handle server shutdown
 process.on('SIGINT', async () => {
-  console.log('Shutting down server...');
+  console.error('Shutting down server...');
 
   // Close all active transports to properly clean up resources
   for (const sessionId in transports) {
     try {
-      console.log(`Closing transport for session ${sessionId}`);
+      console.error(`Closing transport for session ${sessionId}`);
       await transports[sessionId].close();
       delete transports[sessionId];
     } catch (error) {
@@ -167,6 +169,6 @@ process.on('SIGINT', async () => {
   }
   await cleanup();
   await server.close();
-  console.log('Server shutdown complete');
+  console.error('Server shutdown complete');
   process.exit(0);
 });

src/everything/stdio.ts

@@ -2,6 +2,9 @@
 
 A Model Context Protocol server that provides web content fetching capabilities. This server enables LLMs to retrieve and process content from web pages, converting HTML to markdown for easier consumption.
 
+> [!CAUTION]
+> This server can access local/internal IP addresses and may represent a security risk. Exercise caution when using this MCP server to ensure this does not expose any sensitive data.
+
 The fetch tool will truncate the response, but by using the `start_index` argument, you can specify where to start the content extraction. This lets models read a webpage in chunks, until they find the information they need.
 
 ### Available Tools

src/everything/streamableHttp.ts

@@ -84,7 +84,10 @@ Once authenticated, you can use the server in your app's server configuration:
       "args": [
         "-y",
         "@modelcontextprotocol/server-gdrive"
-      ]
+      ],
+      "env": {
+        "GDRIVE_CREDENTIALS_PATH": "/path/to/.gdrive-server-credentials.json"
+      }
     }
   }
 }