@fnet/cli 0.2.7 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fnet/cli",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "files": [
     "dist",
     "template"

package/template/fnode/node/src/cli/v2/modes/mcp/imports.njk

@@ -12,6 +12,9 @@ import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprot
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import express from "express";
+{% if atom.doc.features.cli.mcp.ws===true %}
+import expressWs from "express-ws";
+{% endif %}
 {# crypto imported in shared section #}
 
 {% elif atom.doc.features.project.format==='cjs' %}
@@ -21,6 +24,9 @@ const { ListToolsRequestSchema, CallToolRequestSchema } = require("@modelcontext
 const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
 const { StreamableHTTPServerTransport } = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 const express = require("express");
+{% if atom.doc.features.cli.mcp.ws===true %}
+const expressWs = require("express-ws");
+{% endif %}
 {# crypto imported in shared section #}
 
 {% endif %}

package/template/fnode/node/src/cli/v2/modes/mcp/transport-http.njk

@@ -7,13 +7,24 @@
 
 // Use Streamable HTTP transport (official transport as of MCP 2025-03-26)
 const app = express();
+{% if atom.doc.features.cli.mcp.ws===true %}
+// Enable WebSocket support
+expressWs(app);
+{% endif %}
 app.use(express.json());
 
 const port = args['cli-port'] || args.cli_port || 3000;
 const host = args['cli-host'] || args.cli_host || '0.0.0.0';
-const mcpEndpoint = '/{{atom.doc.features.cli.mcp.path or 'mcp'}}';
+const basePath = '{{atom.doc.features.cli.mcp.path or 'mcp'}}';
+const mcpEndpoint = `/${basePath}`;           // MCP protocol endpoint
 const verbose = args['cli-verbose'] || args.cli_verbose || false;
 
+// Optional endpoints (enabled via config)
+const httpEnabled = {{atom.doc.features.cli.mcp.http or false}};
+const wsEnabled = {{atom.doc.features.cli.mcp.ws or false}};
+const httpEndpoint = `/${basePath}/input`;    // HTTP input endpoint
+const wsEndpoint = `/${basePath}/ws`;         // WebSocket endpoint
+
 // Verbose logging helper
 const log = (...args) => {
   if (verbose) {
@@ -105,9 +116,92 @@ app.get(mcpEndpoint, handleSessionRequest);
 // Handle DELETE requests for session termination
 app.delete(mcpEndpoint, handleSessionRequest);
 
+{% if atom.doc.features.cli.mcp.http===true %}
+// HTTP input endpoint (enabled via config: cli.mcp.http: true)
+app.post(httpEndpoint, async (req, res) => {
+  log('HTTP input request received');
+  log('Request body:', JSON.stringify(req.body, null, 2));
+
+  try {
+    // Call the Node function directly with the request body
+    const result = await Node(req.body);
+
+    log('HTTP input processed successfully');
+    log('Result:', JSON.stringify(result, null, 2));
+
+    // Return the result as JSON
+    res.json(result);
+  } catch (error) {
+    log('HTTP input processing error:', error.message);
+
+    // Return error response
+    res.status(500).json({
+      error: error.message,
+      stack: verbose ? error.stack : undefined
+    });
+  }
+});
+{% endif %}
+
+{% if atom.doc.features.cli.mcp.ws===true %}
+// WebSocket endpoint (enabled via config: cli.mcp.ws: true)
+// Map to store WebSocket clients
+const wsClients = new Set();
+
+app.ws(wsEndpoint, (ws, req) => {
+  log('WebSocket connection established');
+  wsClients.add(ws);
+
+  // Handle incoming messages
+  ws.on('message', async (message) => {
+    log('WebSocket message received:', message);
+
+    try {
+      // Parse JSON message
+      const data = JSON.parse(message);
+
+      // Call the Node function
+      const result = await Node(data);
+
+      log('WebSocket message processed successfully');
+      log('Result:', JSON.stringify(result, null, 2));
+
+      // Send result back to client
+      ws.send(JSON.stringify(result));
+    } catch (error) {
+      log('WebSocket message processing error:', error.message);
+
+      // Send error response
+      ws.send(JSON.stringify({
+        error: error.message,
+        stack: verbose ? error.stack : undefined
+      }));
+    }
+  });
+
+  // Handle connection close
+  ws.on('close', () => {
+    log('WebSocket connection closed');
+    wsClients.delete(ws);
+  });
+
+  // Handle errors
+  ws.on('error', (error) => {
+    log('WebSocket error:', error.message);
+    wsClients.delete(ws);
+  });
+});
+{% endif %}
+
 app.listen(port, host, () => {
   console.log(`MCP server started with Streamable HTTP transport`);
-  console.log(`Endpoint: http://${host}:${port}${mcpEndpoint}`);
+  console.log(`MCP endpoint: http://${host}:${port}${mcpEndpoint}`);
+  {% if atom.doc.features.cli.mcp.http===true %}
+  console.log(`HTTP endpoint: http://${host}:${port}${httpEndpoint}`);
+  {% endif %}
+  {% if atom.doc.features.cli.mcp.ws===true %}
+  console.log(`WebSocket endpoint: ws://${host}:${port}${wsEndpoint}`);
+  {% endif %}
   console.log(`Listening on ${host}:${port}`);
   if (verbose) {
     console.log(`Verbose logging enabled`);