@fnet/cli 0.114.0 → 0.116.0

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

@@ -1,44 +1,327 @@
 {% if atom.doc.features.cli.enabled===true %}
-import argv from '../default/to.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.extend===true %}
-    {# TYPE 1 #}
-    import { default as runExtended } from '../../../cli';
-
-    const run = async () => {
-      return await runExtended(await argv(),{ Engine });
-    };
-
-    run()
-      .then(() => {    
-        {# process.exit(0);  #}
-      })
-      .catch((error) => {    
-        console.error(error.message);
-        process.exit(1);
-      });
-  {% else %}
-    {# TYPE 2 #}
-    const run = async () => {
-      const engine = new Engine();
-      return await engine.run(await argv());
-    };
-
-    run()
-      .then((result) => {    
-        if (typeof result !== 'undefined')
-        {
-          // TODO: REMOVE THIS LINE
-          const stdout_format=process.argv.slice(2).indexOf()!==-1? process.argv.slice(2)[process.argv.slice(2).indexOf('--stdout_format')+1]:null;
-          if(stdout_format==='json') console.log(JSON.stringify(result,null,2));
-          else console.log(result);
+{# Define macros for reusable code blocks #}
+{% macro importMcpDependencies() %}
+import { Server, ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+{% endmacro %}
+
+{% 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: {}
+      }
+    });
+
+    // 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}}",
+          inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: true
+          }
+        }]
+      };
+    });
+
+    // 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");
+    });
+
+    // Get transport type from arguments
+    const transportType = args['mcp-transport-type'] || args.mcp_transport_type || 'stdio';
+    let transport;
+
+    if (transportType === 'stdio') {
+      // Use stdio transport
+      transport = new StdioServerTransport();
+      console.log("MCP server started with stdio transport");
+    } else if (transportType === 'http') {
+      // Use HTTP 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 HTTP transport on port ${port}`);
+      });
+
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => Math.random().toString(36).substring(2, 15),
+      });
+
+      app.post('/mcp', async (req, res) => {
+        await transport.handleRequest(req, res, req.body);
+      });
+
+      app.get('/mcp', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+
+      app.delete('/mcp', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+    } else {
+      console.error(`Unknown MCP transport type: ${transportType}`);
+      console.error(`Supported types: stdio, http`);
+      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: {}
+      }
+    });
+
+    // 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}}",
+          inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: true
+          }
+        }]
+      };
+    });
+
+    // 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
+          };
         }
-        {# process.exit(0); #}    
-      })
-      .catch((error) => {    
-        console.error(error.message);
-        process.exit(1);
+      }
+      throw new Error("Tool not found");
+    });
+
+    // 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-type'] || args.mcp_transport_type || 'stdio';
+    let transport;
+
+    if (transportType === 'stdio') {
+      // Use stdio transport
+      transport = new StdioServerTransport();
+      console.log("MCP server started with stdio transport");
+    } else if (transportType === 'http') {
+      // Use HTTP 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 HTTP transport on port ${port}`);
+      });
+
+      transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => Math.random().toString(36).substring(2, 15),
       });
-  {% endif %}
+
+      app.post('/mcp', async (req, res) => {
+        await transport.handleRequest(req, res, req.body);
+      });
+
+      app.get('/mcp', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+
+      app.delete('/mcp', async (req, res) => {
+        await transport.handleRequest(req, res);
+      });
+    } else {
+      console.error(`Unknown MCP transport type: ${transportType}`);
+      console.error(`Supported types: stdio, http`);
+      process.exit(1);
+    }
+
+    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 });
+      }
+    });
+
+    const port = args['cli-port'] || args.cli_port || 3000;
+    app.listen(port, () => {
+      console.log(`HTTP server started on port ${port}`);
+    });
+    return;
+  }
+{% endmacro %}
+
+{% 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() }}
+{% endif %}
+
+{% if 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/bun/src/cli/index.js.njk

@@ -2,7 +2,7 @@
 
 {% if atom.doc.features.project.format==='esm' %}
 
-import argv from '../default/to.args.js';
+import argv from '../default/input.args.js';
 
 {% if atom.doc.features.cli.extend===true %}
 
@@ -40,7 +40,7 @@ run()
 
 {% elif atom.doc.features.project.format==='cjs' %}
 
-const argv = require('../default/to.args.js');
+const argv = require('../default/input.args.js');
 
 {% if atom.doc.features.cli.extend===true %}
 

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"

package/template/fnode/node/rollup.config.mjs.njk

@@ -182,9 +182,9 @@ const initPlugins = async (options) => {
     {% if atom.doc.features.project.format ==='esm' %}
     include: /node_modules/,
     ignore: ["fsevents"],
-    {% endif %}    
+    {% endif %}
   }));
-  
+
 
   {# POLYFILL #}
   {% if atom.doc.features.polyfill_enabled===true %}
@@ -193,7 +193,7 @@ const initPlugins = async (options) => {
     plugins.push(polyfills(options.polyfill.options));
   }
   {% endif %}
-  
+
   {# WORKBOX #}
   {% if atom.doc.features.workbox_enabled===true %}
   if (options?.workbox) {
@@ -291,7 +291,7 @@ const createConfigs = async () => {
     if (!fs.existsSync(groupDir)) {
       fs.mkdirSync(groupDir, { recursive: true });
     }
-    
+
     {% for key, value in atom.doc.features.rollup_output %}
     {% if value and value.enabled !== false %}
     {
@@ -310,17 +310,150 @@ const createConfigs = async () => {
           entryFileNames: "[name].cjs",
           chunkFileNames: "[name]-[hash].cjs",
           {% endif %}
-          {% include 'rollup_config_output_name.njk' %}
-          {% include 'rollup_config_output_globals.njk' %}
-          {% include 'rollup_config_output_banner.njk' %}
-          {% include 'rollup_config_output_footer.njk' %}
+          {# BEGIN: rollup_config_output_name #}
+          {% if value.format==='iife' or value.format==='umd'%}
+          name: "{{atom.doc.bundleName}}",
+          {% endif %}
+          {# END: rollup_config_output_name #}
+          {# BEGIN: rollup_config_output_globals #}
+          {% if value.browser===true %}
+          {% if value.globals.length %}
+          globals: {
+              {% for global in value.globals %}
+                  "{{global.key}}":"{{global.value}}" {% if not loop.last %},{% endif %}
+              {% endfor %}
+          },
+          {% endif %}
+          {% endif %}
+          {# END: rollup_config_output_globals #}
+          {# BEGIN: rollup_config_output_banner #}
+          {% if value.banner %}
+          banner:'{{value.banner}}',
+          {% endif %}
+          {# END: rollup_config_output_banner #}
+          {# BEGIN: rollup_config_output_footer #}
+          {% if value.format==='iife' %}
+              {% if atom.type==='workflow'%}
+              {# footer: "new {{atom.doc.bundleName}}().run().catch(e=>{});" #}
+              {% endif %}
+          {% endif %}
+          {# END: rollup_config_output_footer #}
         },
         {% if value.context %}
         context: "{{value.context}}",
         {% endif %}
-        {% include 'rollup_config_external.njk' %}
-        {% include 'rollup_config_onwarn.njk' %}
-        {% include 'rollup_config_plugins.njk' %}
+        {# BEGIN: rollup_config_external #}
+        {% if value.external_enabled %}
+        external: [
+            {% for external in value.external %}
+                "{{external}}" {% if not loop.last %},{% endif %}
+            {% endfor %}
+        ],
+        {% endif %}
+        {# END: rollup_config_external #}
+        {# BEGIN: rollup_config_onwarn #}
+        onwarn(warning, warn) {
+            switch (warning.code) {
+            case 'MODULE_LEVEL_DIRECTIVE':
+            case 'CIRCULAR_DEPENDENCY':
+                return;
+            default:
+                warn(warning);
+            }
+        },
+        {# END: rollup_config_onwarn #}
+        {# BEGIN: rollup_config_plugins #}
+        plugins: await initPlugins({
+            delete:{ targets: [path.normalize(groupDir + '{{key}}')], runOnce: DEVELOPMENT },
+
+            format:"{{ value.format }}",
+
+            {% if value.babel===true %}
+            babel:{{value.babel_options | dump | safe}},
+            {% endif %}
+
+            {% if value.replace ===true %}
+            replace:{{value.replace_options | dump | safe}},
+            {% endif %}
+
+            {% if value.browser===true %}
+            browser:true,
+            {% endif %}
+
+            {% if value.browsersync===true and atom.doc.features.browsersync_enabled===true%}
+            browsersync: {{value.browsersync_options | dump | safe}},
+            {% endif %}
+
+            {% if value.alias_enabled===true %}
+            alias:{{value.alias | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.css %}
+            postcss:{{value.css | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.copy %}
+            copy:{{value.copy | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if  value.terser%}
+            terser:{{value.terser | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.json %}
+            json:{{value.json | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.wasm %}
+            wasm: {{value.wasm | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.string %}
+            string:{{value.string | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.image %}
+            image:{{value.image | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.analyzer %}
+            analyzer:{{value.analyzer | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.visualizer %}
+            visualizer:{{value.visualizer | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.polyfill %}
+            polyfill:{{value.polyfill | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.nunjucks %}
+            nunjucks:{{value.nunjucks | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.workbox %}
+            workbox:{{value.workbox | dump | safe}},
+            {% endif %}
+
+            {# OK #}
+            {% if value.gzip %}
+            gzip:{{value.gzip | dump | safe}},
+            {% endif %}
+        }),
+        {# END: rollup_config_plugins #}
       }
       configs.push(config);
     }