@fnet/cli 0.2.8 → 0.2.10

package/template/fnet/node/src/cli/v2/modes/websocket/index.njk

@@ -0,0 +1,104 @@
+{# ============================================================================
+   WEBSOCKET MODE - MAIN
+   ============================================================================
+   WebSocket server for real-time bidirectional communication
+   Supports connection handling, message processing, and heartbeat
+   ============================================================================ #}
+
+if (cliMode === 'websocket') {
+  // WebSocket mode code
+  const port = args['cli-port'] || args.cli_port || 3000;
+  const heartbeat = args['ws-heartbeat'] || args.ws_heartbeat || 30000; // 30 seconds default
+  
+  const wss = new WebSocketServer({ port });
+  
+  // Store active connections
+  const clients = new Set();
+  
+  wss.on('connection', (ws) => {
+    console.log('WebSocket client connected');
+    clients.add(ws);
+    
+    // Set up heartbeat
+    ws.isAlive = true;
+    ws.on('pong', () => {
+      ws.isAlive = true;
+    });
+    
+    // Handle incoming messages
+    ws.on('message', async (data) => {
+      try {
+        // Parse message
+        const message = data.toString();
+        let input;
+        
+        try {
+          input = JSON.parse(message);
+        } catch (e) {
+          // If not JSON, wrap in object
+          input = { data: message };
+        }
+        
+        // Validate input
+        // TODO: Add schema validation if needed
+
+        // Process with Engine
+        {% if atom.doc.features.cli.extend===true %}
+        const result = await runExtended(input, { Engine });
+        {% else %}
+        const engine = new Engine();
+        const result = await engine.run(input);
+        {% endif %}
+
+        // Send response back to client
+        ws.send(JSON.stringify(result));
+        
+      } catch (error) {
+        // Send error to client
+        ws.send(JSON.stringify({ 
+          error: error.message,
+          type: 'processing_error'
+        }));
+      }
+    });
+    
+    // Handle client disconnect
+    ws.on('close', () => {
+      console.log('WebSocket client disconnected');
+      clients.delete(ws);
+    });
+    
+    // Handle errors
+    ws.on('error', (error) => {
+      console.error('WebSocket error:', error.message);
+      clients.delete(ws);
+    });
+  });
+  
+  // Heartbeat interval
+  if (heartbeat > 0) {
+    const interval = setInterval(() => {
+      wss.clients.forEach((ws) => {
+        if (ws.isAlive === false) {
+          console.log('Terminating inactive client');
+          return ws.terminate();
+        }
+        
+        ws.isAlive = false;
+        ws.ping();
+      });
+    }, heartbeat);
+    
+    wss.on('close', () => {
+      clearInterval(interval);
+    });
+  }
+  
+  console.log(`WebSocket server started on port ${port}`);
+  if (heartbeat > 0) {
+    console.log(`Heartbeat interval: ${heartbeat}ms`);
+  }
+  
+  return;
+}
+

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,15 +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 basePath = '{{atom.doc.features.cli.mcp.path or 'mcp'}}';
 const mcpEndpoint = `/${basePath}`;           // MCP protocol endpoint
-const httpEndpoint = `/${basePath}/input`;    // HTTP input 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) {
@@ -107,7 +116,8 @@ app.get(mcpEndpoint, handleSessionRequest);
 // Handle DELETE requests for session termination
 app.delete(mcpEndpoint, handleSessionRequest);
 
-// Handle HTTP POST requests for normal input processing (non-MCP)
+{% 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));
@@ -131,11 +141,67 @@ app.post(httpEndpoint, async (req, res) => {
     });
   }
 });
+{% 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(`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`);