@fnet/cli 0.115.0 → 0.116.1

package/template/fnet/node/src/cli/index.js.njk

@@ -1,223 +1,332 @@
 {% if atom.doc.features.cli.enabled===true %}
-import argv from '../default/input.args.js';
-import { default as Engine } from '../default/{{atom.doc.features.cli_default_entry_file or atom.doc.features.main_default_entry_file}}';
 
-{% if atom.doc.features.cli.mcp.enabled===true %}
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+{# Define macros for reusable code blocks #}
+{% macro importMcpDependencies() %}
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-{% endif %}
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+{% endmacro %}
 
-{% if atom.doc.features.cli.http.enabled===true %}
-// Using Node.js built-in http module instead of express
-{% endif %}
-
-  {% if atom.doc.features.cli.extend===true %}
-    {# TYPE 1 #}
-    import { default as runExtended } from '../../../cli';
+{% macro mcpModeCodeExtended(runFn) %}
+  if (cliMode === 'mcp') {
+    // MCP mode code
+    const server = new Server({
+      name: "{{atom.doc.features.cli.mcp.name or atom.doc.name}}",
+      version: "{{atom.doc.version or '0.0.1'}}"
+    }, {
+      capabilities: {
+        tools: {}
+      }
+    });
 
-    const run = async () => {
-      const args = await argv();
-      const cliMode = args['cli-mode'] || args.cli_mode || 'default';
+    // Define available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [{
+          name: "{{atom.doc.features.cli.mcp.tool.name or atom.doc.name}}",
+          description: "{{atom.doc.features.cli.mcp.tool.description or atom.doc.description}}",
+          {% if atom.doc.input %}
+          inputSchema: {{atom.doc.input | dump | safe}}
+          {% else %}
+          inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: true
+          }
+          {% endif %}
+        }]
+      };
+    });
 
-      if (cliMode === 'default') {
-        // Default mode code
-        return await runExtended(args, { Engine });
+    // Handle tool execution
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name === "{{atom.doc.features.cli.mcp.tool.name or atom.doc.name}}") {
+        try {
+          const result = await {{ runFn }}(request.params.arguments, { Engine });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(result)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{
+              type: "text",
+              text: `Error: ${error.message}`
+            }],
+            isError: true
+          };
+        }
       }
+      throw new Error("Tool not found");
+    });
 
-      {% if atom.doc.features.cli.mcp.enabled===true %}
-      if (cliMode === 'mcp') {
-        // MCP mode code
-        const server = new McpServer({
-          name: "{{atom.doc.name}}",
-          version: "{{atom.doc.version}}"
-        });
-
-        server.tool(
-          "{{atom.doc.name}}",
-          async (toolArgs) => {
-            try {
-              const result = await runExtended(toolArgs, { Engine });
-              return {
-                content: [{
-                  type: "text",
-                  text: JSON.stringify(result)
-                }]
-              };
-            } catch (error) {
-              return {
-                content: [{
-                  type: "text",
-                  text: `Error: ${error.message}`
-                }],
-                isError: true
-              };
-            }
-          }
-        );
+    // Get transport type from arguments
+    const transportType = args['mcp-transport'] || args.mcp_transport || 'stdio';
+    let transport;
+
+    if (transportType === 'stdio') {
+      // Use stdio transport
+      transport = new StdioServerTransport();
+    } else if (transportType === 'sse') {
+      // Use SSE transport
+      const app = express();
+      app.use(express.json());
+
+      const port = args['cli-port'] || args.cli_port || 3000;
+      const server = app.listen(port, () => {
+        console.log(`MCP server started with SSE transport on port ${port}`);
+      });
+
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => Math.random().toString(36).substring(2, 15),
+      });
+
+      app.post('/sse', async (req, res) => {
+        await transport.handleRequest(req, res, req.body);
+      });
 
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-        console.log("MCP server started with stdio transport");
-        return;
+      app.get('/sse', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+
+      app.delete('/sse', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+    } else {
+      console.error(`Unknown MCP transport type: ${transportType}`);
+      console.error(`Supported types: stdio, sse`);
+      process.exit(1);
+    }
+
+    await server.connect(transport);
+    return;
+  }
+{% endmacro %}
+
+{% macro mcpModeCodeEngine(engineVar) %}
+  if (cliMode === 'mcp') {
+    // MCP mode code
+    const server = new Server({
+      name: "{{atom.doc.features.cli.mcp.name or atom.doc.name}}",
+      version: "{{atom.doc.version or '0.0.1'}}"
+    }, {
+      capabilities: {
+        tools: {}
       }
-      {% endif %}
-
-      {% if atom.doc.features.cli.http.enabled===true %}
-      if (cliMode === 'http') {
-        // HTTP mode code using built-in http module
-        const http = require('http');
-
-        const server = http.createServer((req, res) => {
-          if (req.method === 'POST' && req.url === '/{{atom.doc.name}}') {
-            let body = '';
-            req.on('data', chunk => {
-              body += chunk.toString();
-            });
-            req.on('end', async () => {
-              try {
-                const data = JSON.parse(body);
-                const result = await runExtended(data, { Engine });
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(result));
-              } catch (error) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: error.message }));
-              }
-            });
-          } else {
-            res.writeHead(404);
-            res.end();
+    });
+
+    // Define available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [{
+          name: "{{atom.doc.features.cli.mcp.tool.name or atom.doc.name}}",
+          description: "{{atom.doc.features.cli.mcp.tool.description or atom.doc.description}}",
+          {% if atom.doc.input %}
+          inputSchema: {{atom.doc.input | dump | safe}}
+          {% else %}
+          inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: true
           }
-        });
+          {% endif %}
+        }]
+      };
+    });
 
-        const port = args['cli-port'] || args.cli_port || 3000;
-        server.listen(port, () => {
-          console.log(`HTTP server started on port ${port}`);
-        });
-        return;
+    // Handle tool execution
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name === "{{atom.doc.features.cli.mcp.tool.name or atom.doc.name}}") {
+        try {
+          const result = await {{ engineVar }}.run(request.params.arguments);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(result)
+            }]
+          };
+        } catch (error) {
+          return {
+            content: [{
+              type: "text",
+              text: `Error: ${error.message}`
+            }],
+            isError: true
+          };
+        }
       }
-      {% endif %}
+      throw new Error("Tool not found");
+    });
 
-      console.error(`Unknown CLI mode: ${cliMode}`);
-      process.exit(1);
-    };
-
-    run()
-      .then(() => {
-        {# process.exit(0);  #}
-      })
-      .catch((error) => {
-        console.error(error.message);
-        process.exit(1);
+    // Note: Direct access to workflow nodes is not implemented in this version
+    // In a future version, we could expose workflow nodes as separate MCP tools
+
+    // Get transport type from arguments
+    const transportType = args['mcp-transport'] || args.mcp_transport || 'stdio';
+    let transport;
+
+    if (transportType === 'stdio') {
+      // Use stdio transport
+      transport = new StdioServerTransport();
+    } else if (transportType === 'sse') {
+      // Use SSE transport
+      const app = express();
+      app.use(express.json());
+
+      const port = args['cli-port'] || args.cli_port || 3000;
+      const server = app.listen(port, () => {
+        console.log(`MCP server started with SSE transport on port ${port}`);
       });
-  {% else %}
-    {# TYPE 2 #}
-    const run = async () => {
-      const args = await argv();
-      const cliMode = args['cli-mode'] || args.cli_mode || 'default';
-      const engine = new Engine();
-
-      if (cliMode === 'default') {
-        // Default mode code
-        const result = await engine.run(args);
-
-        if (typeof result !== 'undefined') {
-          const stdout_format = args['stdout-format'] || args.stdout_format || null;
-
-          if (stdout_format === 'json') console.log(JSON.stringify(result, null, 2));
-          else console.log(result);
-        }
-        return;
-      }
 
-      {% if atom.doc.features.cli.mcp.enabled===true %}
-      if (cliMode === 'mcp') {
-        // MCP mode code
-        const server = new McpServer({
-          name: "{{atom.doc.name}}",
-          version: "{{atom.doc.version}}"
-        });
-
-        server.tool(
-          "{{atom.doc.name}}",
-          async (toolArgs) => {
-            try {
-              const result = await engine.run(toolArgs);
-              return {
-                content: [{
-                  type: "text",
-                  text: JSON.stringify(result)
-                }]
-              };
-            } catch (error) {
-              return {
-                content: [{
-                  type: "text",
-                  text: `Error: ${error.message}`
-                }],
-                isError: true
-              };
-            }
-          }
-        );
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => Math.random().toString(36).substring(2, 15),
+      });
 
-        // Note: Direct access to workflow nodes is not implemented in this version
-        // In a future version, we could expose workflow nodes as separate MCP tools
+      app.post('/sse', async (req, res) => {
+        await transport.handleRequest(req, res, req.body);
+      });
 
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-        console.log("MCP server started with stdio transport");
-        return;
-      }
-      {% endif %}
-
-      {% if atom.doc.features.cli.http.enabled===true %}
-      if (cliMode === 'http') {
-        // HTTP mode code using built-in http module
-        const http = require('http');
-
-        const server = http.createServer((req, res) => {
-          if (req.method === 'POST' && req.url === '/{{atom.doc.name}}') {
-            let body = '';
-            req.on('data', chunk => {
-              body += chunk.toString();
-            });
-            req.on('end', async () => {
-              try {
-                const data = JSON.parse(body);
-                const result = await engine.run(data);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(result));
-              } catch (error) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: error.message }));
-              }
-            });
-          } else {
-            res.writeHead(404);
-            res.end();
-          }
-        });
+      app.get('/sse', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
 
-        // Note: Direct access to workflow nodes is not implemented in this version
-        // In a future version, we could expose workflow nodes as separate HTTP endpoints
+      app.delete('/sse', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+    } else {
+      console.error(`Unknown MCP transport type: ${transportType}`);
+      console.error(`Supported types: stdio, sse`);
+      process.exit(1);
+    }
 
-        const port = args['cli-port'] || args.cli_port || 3000;
-        server.listen(port, () => {
-          console.log(`HTTP server started on port ${port}`);
-        });
-        return;
+    await server.connect(transport);
+    return;
+  }
+{% endmacro %}
+
+{% macro httpModeCodeExpress(runFn, engineParam) %}
+  if (cliMode === 'http') {
+    // HTTP mode code using Express
+    const app = express();
+    app.use(express.json());
+
+    app.post('/{{atom.doc.features.cli.http.path or atom.doc.name}}', async (req, res) => {
+      try {
+        const result = await {{ runFn }}(req.body{{ engineParam }});
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
       }
-      {% endif %}
+    });
 
-      console.error(`Unknown CLI mode: ${cliMode}`);
-      process.exit(1);
-    };
+    const port = args['cli-port'] || args.cli_port || 3000;
+    app.listen(port, () => {
+      console.log(`HTTP server started on port ${port}`);
+    });
+    return;
+  }
+{% endmacro %}
 
-    run()
-      .catch((error) => {
-        console.error(error.message);
-        process.exit(1);
-      });
-  {% endif %}
+{% macro defaultModeExtended() %}
+  if (cliMode === 'default') {
+    // Default mode code
+    return await runExtended(args, { Engine });
+  }
+{% endmacro %}
+
+{% macro defaultModeEngine(engineVar) %}
+  if (cliMode === 'default') {
+    // Default mode code
+    const result = await {{ engineVar }}.run(args);
+
+    if (typeof result !== 'undefined') {
+      const stdout_format = args['stdout-format'] || args.stdout_format || null;
+
+      if (stdout_format === 'json') console.log(JSON.stringify(result, null, 2));
+      else console.log(result);
+    }
+    return;
+  }
+{% endmacro %}
+
+{% macro runWithCatch() %}
+run()
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+{% endmacro %}
+
+{% macro runWithThenCatch() %}
+run()
+  .then(() => {
+    {# process.exit(0); #}
+  })
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+{% endmacro %}
+
+{# Main template starts here #}
+import argv from '../default/input.args.js';
+import { default as Engine } from '../default/{{atom.doc.features.cli_default_entry_file or atom.doc.features.main_default_entry_file}}';
+
+{% if atom.doc.features.cli.mcp.enabled===true %}
+{{ importMcpDependencies() }}
+{% elif atom.doc.features.cli.http.enabled===true %}
+// Using express for HTTP mode
+import express from 'express';
+{% endif %}
+
+{% if atom.doc.features.cli.extend===true %}
+  {# TYPE 1 #}
+  import { default as runExtended } from '../../../cli';
+
+  const run = async () => {
+    const args = await argv();
+    const cliMode = args['cli-mode'] || args.cli_mode || 'default';
+
+    {{ defaultModeExtended() }}
+
+    {% if atom.doc.features.cli.mcp.enabled===true %}
+    {{ mcpModeCodeExtended('runExtended') }}
+    {% endif %}
+
+    {% if atom.doc.features.cli.http.enabled===true %}
+    {{ httpModeCodeExpress('runExtended', ', { Engine }') }}
+    {% endif %}
+
+    console.error(`Unknown CLI mode: ${cliMode}`);
+    process.exit(1);
+  };
+
+  {{ runWithThenCatch() }}
+{% else %}
+  {# TYPE 2 #}
+  const run = async () => {
+    const args = await argv();
+    const cliMode = args['cli-mode'] || args.cli_mode || 'default';
+    const engine = new Engine();
+
+    {{ defaultModeEngine('engine') }}
+
+    {% if atom.doc.features.cli.mcp.enabled===true %}
+    {{ mcpModeCodeEngine('engine') }}
+    {% endif %}
+
+    {% if atom.doc.features.cli.http.enabled===true %}
+    {{ httpModeCodeExpress('engine.run', '') }}
+    {% endif %}
+
+    console.error(`Unknown CLI mode: ${cliMode}`);
+    process.exit(1);
+  };
+
+  {{ runWithCatch() }}
+{% endif %}
 {% endif %}

package/template/fnode/node/package.json.njk

@@ -54,13 +54,22 @@
   "license": "{{atom.doc.license or 'MIT'}}",
   "scripts": {
     "build": "rollup --config",
+    "build:dev": "rollup --config --sourcemap --environment DEVELOPMENT",
     "watch": "rollup --config --watch --sourcemap --environment DEVELOPMENT",
     "serve": "bunx serve ./"
     {% if atom.doc.features.cli.enabled %}
     {% if atom.doc.features.project.format ==='cjs' %}
-    ,"cli": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/index.cjs"
+    ,"cli": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/index.cjs",
+    {% if atom.doc.features.cli.mcp.enabled===true %}
+    ,"mcp": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/index.cjs --cli-mode=mcp"
+    ,"mcp-inspect": "bunx @modelcontextprotocol/inspector bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/index.cjs --cli-mode=mcp"
+    {% endif %}
     {% else %}
     ,"cli": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/"
+    {% if atom.doc.features.cli.mcp.enabled===true %}
+    ,"mcp": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/ --cli-mode=mcp"
+    ,"mcp-inspect": "bunx @modelcontextprotocol/inspector bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/ --cli-mode=mcp"
+    {% endif %}
     {% endif %}
     ,"compile": "fbin compile {{atom.doc.features.cli.dir}}/index.js -o .bin/{{atom.doc['npm::bin'] or atom.doc['name'] or atom['id']}}"
     ,"install-bin": "fbin install ./.bin/{{atom.doc['npm::bin'] or atom.doc['name'] or atom['id']}} --yes"