@fnet/cli 0.133.0 → 0.133.1

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

@@ -0,0 +1,318 @@
+{% if atom.doc.features.cli.enabled===true %}
+
+{# 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";
+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: inputSchema,
+        }]
+      };
+    });
+
+    // 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'] || 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);
+      });
+
+      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: {}
+      }
+    });
+
+    // 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: inputSchema,
+        }]
+      };
+    });
+
+    // 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
+          };
+        }
+      }
+      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'] || 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);
+      });
+
+      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 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(await argv(), { Engine });
+  }
+{% endmacro %}
+
+{% macro defaultModeEngine(engineVar) %}
+  if (cliMode === 'default') {
+    // Default mode code
+    const result = await {{ engineVar }}.run(await argv());
+
+    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,{argsParser} from '../default/input.args.js';
+import { schema as inputSchema } from '../default/validate_input.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/index.js';
+
+  const run = async () => {
+    const args = argsParser(process.argv.slice(2));
+    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 #}
+  import { argsParser } from '@fnet/args';
+  const run = async () => {
+    const args =argsParser(process.argv.slice(2));
+    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/fnet/node/src/cli/v2/core/args-parser.njk

@@ -0,0 +1,10 @@
+{# ============================================================================
+   ARGUMENT PARSER
+   ============================================================================
+   Parses command-line arguments and extracts CLI mode
+   ============================================================================ #}
+
+const parseArgs = () => {
+  return argsParser(process.argv.slice(2));
+};
+

package/template/fnet/node/src/cli/v2/core/imports.njk

@@ -0,0 +1,31 @@
+{# ============================================================================
+   CORE IMPORTS
+   ============================================================================
+   Base imports required for all CLI modes
+   Supports both ESM and CJS formats, standard and extend modes
+
+   fnet-specific: Imports Engine instead of Node
+   - Standard mode: Creates engine instance and calls engine.run()
+   - Extend mode: Imports runExtended and passes { Engine } as context
+   ============================================================================ #}
+
+{% if atom.doc.features.project.format==='esm' %}
+{# ESM Format #}
+import argv,{argsParser} from '../default/input.args.js';
+import { schema as inputSchema } from '../default/validate_input.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 %}
+import { default as runExtended } from '../../../cli/index.js';
+{% endif %}
+
+{% elif atom.doc.features.project.format==='cjs' %}
+{# CJS Format #}
+const { default:argv,argsParser } = require('../default/input.args.js');
+const { schema: inputSchema } = require('../default/validate_input.js');
+const { default: Engine } = require('../default/{{atom.doc.features.cli_default_entry_file or atom.doc.features.main_default_entry_file}}');
+{% if atom.doc.features.cli.extend===true %}
+const { default: runExtended } = require('../../../cli/index.js');
+{% endif %}
+
+{% endif %}
+

package/template/fnet/node/src/cli/v2/core/run-wrapper.njk

@@ -0,0 +1,25 @@
+{# ============================================================================
+   RUN WRAPPER
+   ============================================================================
+   Error handling wrapper for the main run function
+   Supports both standard and extend modes
+   ============================================================================ #}
+
+{% if atom.doc.features.cli.extend===true %}
+{# Extend mode - with then() chain #}
+run()
+  .then(() => {
+    {# process.exit(0); #}
+  })
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+{% else %}
+{# Standard mode - simple catch #}
+run().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});
+{% endif %}
+

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

@@ -0,0 +1,184 @@
+{# ============================================================================
+   CLI TEMPLATE V2 - MODULAR ARCHITECTURE
+   ============================================================================
+
+   This template uses a modular, registry-based approach for maximum
+   extensibility. New modes, transports, and output formats can be added
+   without modifying the core template structure.
+
+   Architecture:
+   - core/       : Base imports, argument parsing, error handling
+   - modes/      : CLI execution modes (default, mcp, http, pipeline, etc.)
+   - output/     : Output formatters (json, yaml, table, etc.)
+
+   Each mode is self-contained and can be enabled/disabled via feature flags.
+
+   Supports:
+   - ESM and CJS formats
+   - Standard and Extend modes
+   - Multiple CLI modes (default, mcp, http)
+
+   ============================================================================ #}
+
+{% if atom.doc.features.cli.enabled===true %}
+
+{# --------------------------------------------------------------------------
+   CORE IMPORTS
+   -------------------------------------------------------------------------- #}
+{% include "./core/imports.njk" %}
+
+{# --------------------------------------------------------------------------
+   SHARED IMPORTS
+   --------------------------------------------------------------------------
+   Shared dependencies used by multiple modes
+   Prevents duplicate imports when multiple modes are enabled
+   -------------------------------------------------------------------------- #}
+{% if atom.doc.features.cli.http.enabled===true or atom.doc.features.cli.webhook.enabled===true %}
+// Shared: http module (used by HTTP and Webhook modes)
+{% if atom.doc.features.project.format==='esm' %}
+import http from 'http';
+{% elif atom.doc.features.project.format==='cjs' %}
+const http = require('http');
+{% endif %}
+{% endif %}
+
+{% if atom.doc.features.cli.mcp.enabled === true or atom.doc.features.cli.webhook.enabled===true %}
+// Shared: crypto module (used by MCP and Webhook modes)
+{% if atom.doc.features.project.format==='esm' %}
+import crypto from 'crypto';
+{% elif atom.doc.features.project.format==='cjs' %}
+const crypto = require('crypto');
+{% endif %}
+{% endif %}
+
+{# --------------------------------------------------------------------------
+   MODE-SPECIFIC IMPORTS
+   --------------------------------------------------------------------------
+   Import dependencies for ALL enabled CLI modes
+   Multiple modes can be enabled simultaneously
+   -------------------------------------------------------------------------- #}
+{% if atom.doc.features.cli.mcp.enabled === true %}
+{% include "./modes/mcp/imports.njk" %}
+{% endif %}
+
+{% if atom.doc.features.cli.http.enabled===true %}
+{% include "./modes/http/imports.njk" %}
+{% endif %}
+
+{% if atom.doc.features.cli.pipeline.enabled===true %}
+{% include "./modes/pipeline/imports.njk" %}
+{% endif %}
+
+{% if atom.doc.features.cli.websocket.enabled===true %}
+{% include "./modes/websocket/imports.njk" %}
+{% endif %}
+
+{% if atom.doc.features.cli.webhook.enabled===true %}
+{% include "./modes/webhook/imports.njk" %}
+{% endif %}
+
+{# --------------------------------------------------------------------------
+   ARGUMENT PARSER
+   -------------------------------------------------------------------------- #}
+{% include "./core/args-parser.njk" %}
+
+{# --------------------------------------------------------------------------
+   MAIN RUN FUNCTION
+   --------------------------------------------------------------------------
+   Mode registry: Each mode is self-contained and handles its own logic
+   -------------------------------------------------------------------------- #}
+const run = async () => {
+  const args = parseArgs();
+  const cliMode = args['cli-mode'] || args.cli_mode || 'default';
+
+  {# --------------------------------------------------------------------------
+     DEFAULT MODE
+     --------------------------------------------------------------------------
+     Standard or extended mode based on CLI configuration
+     -------------------------------------------------------------------------- #}
+  {% if atom.doc.features.cli.extend===true %}
+  {% include "./modes/default/extend.njk" %}
+  {% else %}
+  {% include "./modes/default/standard.njk" %}
+  {% endif %}
+
+  {# --------------------------------------------------------------------------
+     MCP MODE
+     --------------------------------------------------------------------------
+     Model Context Protocol server with multiple transport options
+     -------------------------------------------------------------------------- #}
+  {% if atom.doc.features.cli.mcp.enabled === true %}
+  {% include "./modes/mcp/index.njk" %}
+  {% endif %}
+
+  {# --------------------------------------------------------------------------
+     HTTP MODE
+     --------------------------------------------------------------------------
+     REST API server using built-in http module
+     -------------------------------------------------------------------------- #}
+  {% if atom.doc.features.cli.http.enabled===true %}
+  {% include "./modes/http/index.njk" %}
+  {% endif %}
+
+  {# --------------------------------------------------------------------------
+     PIPELINE MODE
+     --------------------------------------------------------------------------
+     Unix pipeline integration via stdin/stdout
+     -------------------------------------------------------------------------- #}
+  {% if atom.doc.features.cli.pipeline.enabled===true %}
+  {% include "./modes/pipeline/index.njk" %}
+  {% endif %}
+
+  {# --------------------------------------------------------------------------
+     WEBSOCKET MODE
+     --------------------------------------------------------------------------
+     Real-time bidirectional communication
+     -------------------------------------------------------------------------- #}
+  {% if atom.doc.features.cli.websocket.enabled===true %}
+  {% include "./modes/websocket/index.njk" %}
+  {% endif %}
+
+  {# --------------------------------------------------------------------------
+     WEBHOOK MODE
+     --------------------------------------------------------------------------
+     Event-driven HTTP with HMAC signature verification
+     -------------------------------------------------------------------------- #}
+  {% if atom.doc.features.cli.webhook.enabled===true %}
+  {% include "./modes/webhook/index.njk" %}
+  {% endif %}
+
+  {# --------------------------------------------------------------------------
+     FUTURE MODES
+     --------------------------------------------------------------------------
+     Add new modes here by simply including their index.njk
+
+     Examples:
+     - gRPC mode for high-performance RPC
+     - GraphQL mode for flexible APIs
+     - SSE mode for server-sent events
+     -------------------------------------------------------------------------- #}
+
+  {# {% if atom.doc.features.cli.webhook.enabled===true %}
+  {% include "./modes/webhook/index.njk" %}
+  {% endif %} #}
+
+  {# {% if atom.doc.features.cli.grpc.enabled===true %}
+  {% include "./modes/grpc/index.njk" %}
+  {% endif %} #}
+
+  {# --------------------------------------------------------------------------
+     UNKNOWN MODE HANDLER
+     -------------------------------------------------------------------------- #}
+  console.error(`Unknown CLI mode: ${cliMode}`);
+  console.error(`Available modes: default{% if atom.doc.features.cli.mcp.enabled === true %}, mcp{% endif %}{% if atom.doc.features.cli.http.enabled===true %}, http{% endif %}{% if atom.doc.features.cli.pipeline.enabled===true %}, pipeline{% endif %}{% if atom.doc.features.cli.websocket.enabled===true %}, websocket{% endif %}{% if atom.doc.features.cli.webhook.enabled===true %}, webhook{% endif %}`);
+  process.exit(1);
+};
+
+{# --------------------------------------------------------------------------
+   ERROR HANDLER & RUN
+   -------------------------------------------------------------------------- #}
+{% include "./core/run-wrapper.njk" %}
+
+{% endif %}
+{# End of cli.enabled check #}
+

package/template/fnet/node/src/cli/v2/modes/default/extend.njk

@@ -0,0 +1,11 @@
+{# ============================================================================
+   DEFAULT MODE - EXTEND
+   ============================================================================
+   Extended CLI mode for fnet: Calls runExtended with Engine context
+   ============================================================================ #}
+
+if (cliMode === 'default') {
+  // Default mode code
+  return await runExtended(await argv(), { Engine });
+}
+

package/template/fnet/node/src/cli/v2/modes/default/standard.njk

@@ -0,0 +1,20 @@
+{# ============================================================================
+   DEFAULT MODE - STANDARD
+   ============================================================================
+   Standard CLI mode for fnet: Creates engine instance and runs workflow
+   ============================================================================ #}
+
+if (cliMode === 'default') {
+  // Default mode code
+  const engine = new Engine();
+  const result = await engine.run(await argv());
+
+  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;
+}
+

package/template/fnet/node/src/cli/v2/modes/http/builtin.njk

@@ -0,0 +1,66 @@
+{# ============================================================================
+   HTTP MODE - BUILT-IN (Native Node.js HTTP)
+   ============================================================================
+   Simple REST API server using Node.js built-in http module
+   No external dependencies required
+   ============================================================================ #}
+
+const server = http.createServer(async (req, res) => {
+  // CORS headers
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+  // Handle OPTIONS preflight
+  if (req.method === 'OPTIONS') {
+    res.writeHead(200);
+    res.end();
+    return;
+  }
+
+  // Only accept POST requests
+  if (req.method !== 'POST') {
+    res.writeHead(405, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Method not allowed' }));
+    return;
+  }
+
+  // Check path
+  const path = '/{{atom.doc.features.cli.http.path or atom.doc.name}}';
+  if (req.url !== path) {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not found' }));
+    return;
+  }
+
+  // Parse request body
+  let body = '';
+  req.on('data', chunk => {
+    body += chunk.toString();
+  });
+
+  req.on('end', async () => {
+    try {
+      const data = JSON.parse(body);
+      {% if atom.doc.features.cli.extend===true %}
+      const result = await runExtended(data, { Engine });
+      {% else %}
+      const engine = new Engine();
+      const result = await engine.run(data);
+      {% endif %}
+
+      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 }));
+    }
+  });
+});
+
+const port = args['cli-port'] || args.cli_port || 3000;
+server.listen(port, () => {
+  console.log(`HTTP server started on port ${port} (native http)`);
+});
+return;
+

package/template/fnet/node/src/cli/v2/modes/http/imports.njk

@@ -0,0 +1,9 @@
+{# ============================================================================
+   HTTP MODE - IMPORTS
+   ============================================================================
+   No mode-specific imports needed
+   http module is imported in shared imports section
+   ============================================================================ #}
+
+{# http module imported in shared section #}
+