@vrdmr/fnx-test 0.1.1 → 0.1.2

package/lib/cli.js

@@ -1,5 +1,6 @@
 import { resolve as resolvePath, dirname, join } from 'node:path';
 import { readFile } from 'node:fs/promises';
+import { createServer } from 'node:net';
 import { fileURLToPath } from 'node:url';
 import { resolveProfile, listProfiles, setProfilesSource } from './profile-resolver.js';
 import { ensureHost, ensureBundle } from './host-manager.js';
@@ -7,6 +8,21 @@ import { launchHost, createHostState } from './host-launcher.js';
 import { startLiveMcpServer } from './live-mcp-server.js';
 import { detectDotnetModel, printInProcessError } from './dotnet-detector.js';
 
+function isPortFree(port) {
+  return new Promise((resolve) => {
+    const srv = createServer();
+    srv.once('error', () => resolve(false));
+    srv.listen(port, '127.0.0.1', () => { srv.close(() => resolve(true)); });
+  });
+}
+
+async function findOpenPort(start, maxRetries = 10) {
+  for (let i = 0; i < maxRetries; i++) {
+    if (await isPortFree(start + i)) return start + i;
+  }
+  return start; // fall through — let the host report the error
+}
+
 export async function main(args) {
   const cmd = args[0];
 
@@ -43,8 +59,12 @@ export async function main(args) {
   }
 
   const scriptRoot = getFlag(args, '--scriptroot') || process.cwd();
-  const port = getFlag(args, '--port') || '7071';
-  const mcpPort = getFlag(args, '--mcp-port') || String(parseInt(port) + 1);
+  const requestedPort = parseInt(getFlag(args, '--port') || '7071');
+  const port = await findOpenPort(requestedPort);
+  if (port !== requestedPort) {
+    console.log(`  Port ${requestedPort} in use, using ${port} instead.`);
+  }
+  const mcpPort = getFlag(args, '--mcp-port') || String(port + 1);
   const verbose = args.includes('--verbose');
   const noMcp = args.includes('--no-mcp');
   const noAzurite = args.includes('--no-azurite');
@@ -138,10 +158,12 @@ export async function main(args) {
   const hostState = createHostState();
 
   if (!noMcp) {
-    startLiveMcpServer(hostState, parseInt(mcpPort)).catch((err) => {
-      console.error(`  ⚠️  MCP server failed to start on port ${mcpPort}: ${err.message}`);
-      console.error(`     Use --no-mcp to disable, or --mcp-port <port> to change port.`);
-    });
+    startLiveMcpServer(hostState, parseInt(mcpPort))
+      .then((server) => { hostState._mcpServer = server; })
+      .catch((err) => {
+        console.error(`  ⚠️  MCP server failed to start on port ${mcpPort}: ${err.message}`);
+        console.error(`     Use --no-mcp to disable, or --mcp-port <port> to change port.`);
+      });
     // Don't await — host startup should not depend on MCP server
   }
 
@@ -294,7 +316,7 @@ MCP server (for VS Code Copilot / AI assistants):
   # .vscode/mcp.json — live host data (when fnx start is running):
   # {
   #   "servers": {
-  #     "fnx-live": {
+  #     "fnx-functions-debug": {
   #       "type": "http",
   #       "url": "http://127.0.0.1:7072/mcp"
   #     }

package/lib/host-launcher.js

@@ -382,8 +382,18 @@ export async function launchHost(hostDir, opts) {
     });
   }
 
-  process.on('SIGINT', () => { stopAzurite(); child.kill('SIGINT'); });
-  process.on('SIGTERM', () => { stopAzurite(); child.kill('SIGTERM'); });
+  process.on('SIGINT', () => {
+    stopAzurite();
+    child.kill('SIGINT');
+    if (hostState._mcpServer) hostState._mcpServer.close();
+    setTimeout(() => process.exit(0), 500);
+  });
+  process.on('SIGTERM', () => {
+    stopAzurite();
+    child.kill('SIGTERM');
+    if (hostState._mcpServer) hostState._mcpServer.close();
+    setTimeout(() => process.exit(0), 500);
+  });
 
   return new Promise((resolve, reject) => {
     child.on('error', (err) => {

package/lib/live-mcp-server.js

@@ -1,7 +1,11 @@
 /**
- * Live MCP server — exposes running host data over HTTP Streamable transport.
+ * Functions Debug MCP Server — stateless Streamable HTTP transport.
  * Started automatically when `fnx start` launches.
  *
+ * Follows the official MCP SDK stateless pattern: a fresh McpServer + transport
+ * is created per POST request, cleaned up on response close.
+ * Reference: https://github.com/modelcontextprotocol/typescript-sdk/blob/main/examples/server/src/simpleStatelessStreamableHttp.ts
+ *
  * Tools:
  *   get_host_status    — host version, state, uptime, PID, SKU, worker runtime
  *   get_functions      — list of functions with trigger types and routes
@@ -12,15 +16,6 @@
  */
 
 import { createServer as createHttpServer } from 'node:http';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const templatesMcpDir = join(__dirname, '..', 'templates-mcp');
-
-// Resolve MCP SDK from templates-mcp's node_modules
-const require = createRequire(join(templatesMcpDir, 'package.json'));
 
 // ─── Tool registration (called per session) ─────────────────────────
 
@@ -245,30 +240,26 @@ Quick health check without digging through verbose logs.`,
   );
 }
 
-// ─── Start live MCP server ──────────────────────────────────────────
+// ─── Start Functions Debug MCP Server (stateless) ───────────────────
 
 export async function startLiveMcpServer(hostState, mcpPort) {
-  const { McpServer } = await import(require.resolve('@modelcontextprotocol/sdk/server/mcp.js'));
+  const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
   const { StreamableHTTPServerTransport } = await import(
-    require.resolve('@modelcontextprotocol/sdk/server/streamableHttp.js')
+    '@modelcontextprotocol/sdk/server/streamableHttp.js'
   );
-  const { z } = await import(require.resolve('zod'));
-  const { randomUUID } = await import('node:crypto');
-
-  // Factory: create a new McpServer per session (SDK requirement)
-  function createMcpServer() {
-    const server = new McpServer({
-      name: 'fnx-live',
-      version: '0.1.0',
-    });
-
+  const { z } = await import('zod/v4');
+
+  // Factory: creates a fresh McpServer per request (stateless pattern)
+  function getServer() {
+    const server = new McpServer(
+      { name: 'fnx-functions-debug', version: '0.1.0' },
+      { capabilities: { logging: {} } },
+    );
     registerTools(server, hostState, z);
     return server;
   }
 
-  // ─── Start HTTP server with Streamable HTTP transport ───────────────
-
-  const transports = new Map(); // sessionId → { transport, server }
+  // ─── HTTP server with Streamable HTTP transport ─────────────────────
 
   const httpServer = createHttpServer(async (req, res) => {
     // CORS headers for browser-based MCP clients
@@ -283,79 +274,54 @@ export async function startLiveMcpServer(hostState, mcpPort) {
       return;
     }
 
-    // Health check endpoint
+    // Health check
     if (req.url === '/health') {
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ status: 'ok', hostState: hostState.state }));
       return;
     }
 
-    // MCP endpoint at /mcp
+    // MCP endpoint — stateless: new server + transport per POST
     if (req.url === '/mcp' || req.url?.startsWith('/mcp?')) {
-      try {
-        const sessionId = req.headers['mcp-session-id'];
-
-        if (req.method === 'POST') {
-          // Existing session: reuse transport
-          if (sessionId && transports.has(sessionId)) {
-            const { transport } = transports.get(sessionId);
-            await transport.handleRequest(req, res);
-            return;
-          }
-
-          // New session: create server + transport pair
-          const mcpServer = createMcpServer();
+      if (req.method === 'POST') {
+        const server = getServer();
+        try {
           const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => randomUUID(),
-            onsessioninitialized: (sid) => {
-              transports.set(sid, { transport, server: mcpServer });
-            },
+            sessionIdGenerator: undefined, // stateless — no sessions
           });
-
-          transport.onclose = () => {
-            const sid = transport.sessionId;
-            if (sid) transports.delete(sid);
-          };
-
-          await mcpServer.connect(transport);
-          await transport.handleRequest(req, res);
-          return;
-        }
-
-        if (req.method === 'GET') {
-          // SSE stream for notifications
-          if (sessionId && transports.has(sessionId)) {
-            const { transport } = transports.get(sessionId);
-            await transport.handleRequest(req, res);
-            return;
-          }
-          res.writeHead(400, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: 'Missing or invalid session ID for GET (SSE) request' }));
-          return;
-        }
-
-        if (req.method === 'DELETE') {
-          if (sessionId && transports.has(sessionId)) {
-            const { transport, server: mcpServer } = transports.get(sessionId);
-            await transport.handleRequest(req, res);
-            transports.delete(sessionId);
-            await mcpServer.close();
-            return;
+          await server.connect(transport);
+          await transport.handleRequest(req, res, await readBody(req));
+          res.on('close', () => {
+            transport.close();
+            server.close();
+          });
+        } catch (err) {
+          console.error('[MCP] Error handling request:', err.message);
+          if (!res.headersSent) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+              jsonrpc: '2.0',
+              error: { code: -32603, message: 'Internal server error' },
+              id: null,
+            }));
           }
-          res.writeHead(404, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: 'Session not found' }));
-          return;
         }
+        return;
+      }
 
+      // GET and DELETE not supported in stateless mode
+      if (req.method === 'GET' || req.method === 'DELETE') {
         res.writeHead(405, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Method not allowed. Use POST, GET, or DELETE.' }));
-      } catch (err) {
-        console.error('[MCP] Error handling request:', err.message);
-        if (!res.headersSent) {
-          res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: 'Internal server error' }));
-        }
+        res.end(JSON.stringify({
+          jsonrpc: '2.0',
+          error: { code: -32000, message: 'Method not allowed.' },
+          id: null,
+        }));
+        return;
       }
+
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Method not allowed. Use POST.' }));
       return;
     }
 
@@ -365,18 +331,50 @@ export async function startLiveMcpServer(hostState, mcpPort) {
   });
 
   return new Promise((resolve, reject) => {
-    httpServer.on('error', (err) => {
-      // Only reject during startup; after that, log and continue
-      if (!httpServer.listening) {
-        reject(err);
+    const maxRetries = 10;
+    let attempt = 0;
+    let port = mcpPort;
+
+    function tryListen() {
+      httpServer.once('error', onError);
+      httpServer.listen(port, '127.0.0.1', () => {
+        httpServer.removeListener('error', onError);
+        // Runtime errors after startup
+        httpServer.on('error', (err) => {
+          console.error(`  ⚠️  MCP server error: ${err.message}`);
+        });
+        console.log(`  Functions Debug MCP Server: http://127.0.0.1:${port}/mcp`);
+        resolve(httpServer);
+      });
+    }
+
+    function onError(err) {
+      if (err.code === 'EADDRINUSE' && attempt < maxRetries) {
+        attempt++;
+        port++;
+        tryListen();
       } else {
-        console.error(`  ⚠️  MCP server error: ${err.message}`);
+        reject(err);
       }
-    });
+    }
+
+    tryListen();
+  });
+}
 
-    httpServer.listen(mcpPort, '127.0.0.1', () => {
-      console.log(`  MCP Server:      http://127.0.0.1:${mcpPort}/mcp (Streamable HTTP)`);
-      resolve(httpServer);
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', (c) => chunks.push(c));
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch {
+        resolve(undefined);
+      }
     });
+    req.on('error', reject);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vrdmr/fnx-test",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "SKU-aware Azure Functions local emulator",
   "type": "module",
   "bin": {
@@ -32,5 +32,8 @@
   "engines": {
     "node": ">=18"
   },
-  "dependencies": {}
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^4.3.6"
+  }
 }