@fnet/cli 0.114.0 → 0.115.0

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

@@ -1,42 +1,221 @@
 {% if atom.doc.features.cli.enabled===true %}
-import argv from '../default/to.args.js';
+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";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+{% endif %}
+
+{% 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';
 
     const run = async () => {
-      return await runExtended(await argv(),{ Engine });
+      const args = await argv();
+      const cliMode = args['cli-mode'] || args.cli_mode || 'default';
+
+      if (cliMode === 'default') {
+        // Default mode code
+        return await runExtended(args, { Engine });
+      }
+
+      {% 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
+              };
+            }
+          }
+        );
+
+        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 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();
+          }
+        });
+
+        const port = args['cli-port'] || args.cli_port || 3000;
+        server.listen(port, () => {
+          console.log(`HTTP server started on port ${port}`);
+        });
+        return;
+      }
+      {% endif %}
+
+      console.error(`Unknown CLI mode: ${cliMode}`);
+      process.exit(1);
     };
 
     run()
-      .then(() => {    
+      .then(() => {
         {# process.exit(0);  #}
       })
-      .catch((error) => {    
+      .catch((error) => {
         console.error(error.message);
         process.exit(1);
       });
   {% else %}
     {# TYPE 2 #}
     const run = async () => {
+      const args = await argv();
+      const cliMode = args['cli-mode'] || args.cli_mode || 'default';
       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));
+      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);
         }
-        {# process.exit(0); #}    
-      })
-      .catch((error) => {    
+        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
+              };
+            }
+          }
+        );
+
+        // 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
+
+        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();
+          }
+        });
+
+        // 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
+
+        const port = args['cli-port'] || args.cli_port || 3000;
+        server.listen(port, () => {
+          console.log(`HTTP server started on port ${port}`);
+        });
+        return;
+      }
+      {% endif %}
+
+      console.error(`Unknown CLI mode: ${cliMode}`);
+      process.exit(1);
+    };
+
+    run()
+      .catch((error) => {
         console.error(error.message);
         process.exit(1);
       });

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/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);
     }