@fnet/cli 0.4.25 → 0.5.0

package/template/fnode/node/src/cli/v2/modes/pipeline/index.njk

@@ -0,0 +1,103 @@
+{# ============================================================================
+   PIPELINE MODE - MAIN
+   ============================================================================
+   Unix pipeline integration via stdin/stdout
+   Supports line-by-line processing and full input mode
+   ============================================================================ #}
+
+if (cliMode === 'pipeline') {
+  // Pipeline mode code
+  const pipelineMode = args['pipeline-mode'] || args.pipeline_mode || 'lines';
+  const pipelineFormat = args['pipeline-format'] || args.pipeline_format || 'json';
+  
+  if (pipelineMode === 'lines') {
+    // Line-by-line processing (default)
+{% if atom.doc.features.project.format==='esm' %}
+    const readline = await import('readline');
+{% elif atom.doc.features.project.format==='cjs' %}
+    const readline = require('readline');
+{% endif %}
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+
+    rl.on('line', async (line) => {
+      try {
+        // Parse input based on format
+        let input;
+        if (pipelineFormat === 'json') {
+          input = JSON.parse(line);
+        } else {
+          input = { data: line };
+        }
+
+        // Validate input
+        // TODO: Add schema validation if needed
+
+        // Process with Core
+        const result = await Node(input);
+
+        // Output result
+        if (pipelineFormat === 'json') {
+          console.log(JSON.stringify(result));
+        } else {
+          console.log(result);
+        }
+      } catch (error) {
+        console.error(`Error processing line: ${error.message}`);
+      }
+    });
+
+    rl.on('close', () => {
+      process.exit(0);
+    });
+
+  } else if (pipelineMode === 'full') {
+    // Full input processing
+    let inputData = '';
+
+    process.stdin.on('data', (chunk) => {
+      inputData += chunk;
+    });
+
+    process.stdin.on('end', async () => {
+      try {
+        // Parse input based on format
+        let input;
+        if (pipelineFormat === 'json') {
+          input = JSON.parse(inputData);
+        } else {
+          input = { data: inputData };
+        }
+
+        // Validate input
+        // TODO: Add schema validation if needed
+
+        // Process with Core
+        const result = await Node(input);
+
+        // Output result
+        if (pipelineFormat === 'json') {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(result);
+        }
+
+        process.exit(0);
+      } catch (error) {
+        console.error(`Error processing input: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  } else {
+    console.error(`Unknown pipeline mode: ${pipelineMode}`);
+    console.error(`Supported modes: lines, full`);
+    process.exit(1);
+  }
+
+  return;
+}
+

package/template/fnode/node/src/cli/v2/modes/webhook/imports.njk

@@ -0,0 +1,9 @@
+{# ============================================================================
+   WEBHOOK MODE - IMPORTS
+   ============================================================================
+   No mode-specific imports needed
+   http and crypto modules are imported in shared imports section
+   ============================================================================ #}
+
+{# http and crypto modules imported in shared section #}
+

package/template/fnode/node/src/cli/v2/modes/webhook/index.njk

@@ -0,0 +1,122 @@
+{# ============================================================================
+   WEBHOOK MODE - IMPLEMENTATION
+   ============================================================================
+   Event-driven HTTP webhook server with HMAC signature verification
+   ============================================================================ #}
+
+if (cliMode === 'webhook') {
+  const port = args['cli-port'] || args.cli_port || 3000;
+  const webhookPath = args['webhook-path'] || args.webhook_path || '/webhook';
+  const webhookSecret = args['webhook-secret'] || args.webhook_secret || process.env.WEBHOOK_SECRET;
+  const signatureHeader = args['webhook-signature-header'] || args.webhook_signature_header || 'x-hub-signature-256';
+  
+  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, ' + signatureHeader);
+    
+    // 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. Use POST.' }));
+      return;
+    }
+    
+    // Only accept webhook path
+    if (req.url !== webhookPath) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Not found. Use ' + webhookPath }));
+      return;
+    }
+    
+    // Read request body
+    let body = '';
+    req.on('data', chunk => {
+      body += chunk.toString();
+    });
+    
+    req.on('end', async () => {
+      try {
+        // Verify signature if secret is provided
+        if (webhookSecret) {
+          const signature = req.headers[signatureHeader.toLowerCase()];
+          
+          if (!signature) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Missing signature header: ' + signatureHeader }));
+            return;
+          }
+          
+          // Calculate expected signature (HMAC-SHA256)
+          const hmac = crypto.createHmac('sha256', webhookSecret);
+          hmac.update(body);
+          const expectedSignature = 'sha256=' + hmac.digest('hex');
+          
+          // Compare signatures (timing-safe)
+          const signatureBuffer = Buffer.from(signature);
+          const expectedBuffer = Buffer.from(expectedSignature);
+          
+          if (signatureBuffer.length !== expectedBuffer.length || 
+              !crypto.timingSafeEqual(signatureBuffer, expectedBuffer)) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid signature' }));
+            return;
+          }
+        }
+        
+        // Parse JSON payload
+        let payload;
+        try {
+          payload = JSON.parse(body);
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Invalid JSON payload' }));
+          return;
+        }
+        
+        // Process webhook with Core
+        const result = await Node(payload);
+        
+        // Send response
+        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,
+          type: 'processing_error'
+        }));
+      }
+    });
+    
+    req.on('error', (error) => {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        error: error.message,
+        type: 'request_error'
+      }));
+    });
+  });
+  
+  server.listen(port, () => {
+    console.log(`Webhook server started on port ${port}`);
+    console.log(`Webhook endpoint: ${webhookPath}`);
+    if (webhookSecret) {
+      console.log(`Signature verification: enabled (header: ${signatureHeader})`);
+    } else {
+      console.log(`Signature verification: disabled (no secret provided)`);
+    }
+  });
+  
+  return;
+}
+

package/template/fnode/node/src/cli/v2/modes/websocket/imports.njk

@@ -0,0 +1,15 @@
+{# ============================================================================
+   WEBSOCKET MODE - IMPORTS
+   ============================================================================
+   WebSocket server dependencies using 'ws' library
+   Supports both ESM and CJS formats
+   ============================================================================ #}
+
+{% if atom.doc.features.project.format==='esm' %}
+// Using ws library for WebSocket mode
+import { WebSocketServer } from 'ws';
+{% elif atom.doc.features.project.format==='cjs' %}
+// Using ws library for WebSocket mode
+const { WebSocketServer } = require('ws');
+{% endif %}
+

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

@@ -0,0 +1,99 @@
+{# ============================================================================
+   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 Core
+        const result = await Node(input);
+        
+        // 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/default/engine.js.njk

@@ -0,0 +1,17 @@
+{% if atom.doc.features.project.format === 'esm' %}
+  {% if atom.relativePath %}
+    export * from "{{atom.relativePath}}";
+    export { default } from "{{atom.relativePath}}";
+  {% else %}
+    export * from "../libs/{{atom.id or atom.doc.name}}";
+    export { default } from "../libs/{{atom.id or atom.doc.name}}";
+  {% endif %}
+{% elif atom.doc.features.project.format === 'cjs' %}
+  {% if atom.relativePath %}
+    const moduleExports = require("{{atom.relativePath}}");
+    module.exports = { ...moduleExports, default: moduleExports.default || moduleExports };
+  {% else %}
+    const moduleExports = require("../libs/{{atom.id or atom.doc.name}}");
+    module.exports = { ...moduleExports, default: moduleExports.default || moduleExports };
+  {% endif %}
+{% endif %}

package/template/fnode/node/src/default/input.args.js.njk

@@ -0,0 +1,126 @@
+{% if atom.doc.features.project.format === 'esm' %}
+  import fnetArgs,{argsParser} from '@fnet/args';
+  import validate,{schema as inputSchema} from "./validate_input";
+
+{% elif atom.doc.features.project.format === 'cjs' %}
+  const {default:fnetArgs,argsParser} = require('@fnet/args');
+  const validate,{schema as inputSchema} = require("./validate_input");
+{% endif %}
+
+{% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}
+
+  const get_fargs = (argv) => {
+    const fargsIndex = argv.indexOf('--fargs');
+    if (fargsIndex !== -1 && argv[fargsIndex + 1]) return argv[fargsIndex + 1];
+    {% if atom.doc.features.cli.fargs.default %}
+    else return "{{atom.doc.features.cli.fargs.default}}";
+    {% endif %}
+  };
+
+  const get_ftags = (argv) => {
+    const ftags = [];
+    for (let i = 0; i < argv.length; i++) {
+      if (argv[i] === '--ftag' && argv[i + 1]) {
+        ftags.push(argv[i + 1]);
+        i++;
+      }
+    }
+    
+    {% if atom.doc.features.cli.fargs.tags %}
+      return ftags.length > 0 ? ftags : {{atom.doc.features.cli.fargs.tags | dump | safe}};
+    {% else %}
+      return ftags.length > 0 ? ftags : undefined;
+    {% endif %}
+  };
+
+{% endif %}
+
+{% if atom.doc.features.project.format === 'esm' %}
+
+  export default async () => {
+
+    let schema = inputSchema;
+    let initial;
+
+    {% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}    
+    const fargs = get_fargs(process.argv.slice(2));
+    const ftags = get_ftags(process.argv.slice(2));
+
+    if (fargs) {
+      const { default: fnetConfig } = await import("@fnet/config");
+      const config = await fnetConfig({ name: fargs, tags: ftags });
+      if (config?.data) {
+        initial=config.data;
+      }
+    }
+    {% endif %}
+
+    const packageCallback = async () => {
+      const { default: url } = await import("node:url");
+      const { default: path } = await import("node:path");
+      const { default: fs } = await import("node:fs");
+      let currentDir = path.dirname(url.fileURLToPath(import.meta.url));
+      let firstPackageJson = path.join(currentDir, "package.json");
+      while (currentDir !== path.parse(currentDir).root && !fs.existsSync(firstPackageJson)) {
+        currentDir = path.dirname(currentDir);
+        firstPackageJson = path.join(currentDir, "package.json");
+      }
+      if (!fs.existsSync(firstPackageJson)) return {
+        name: "Unknown",
+        version: "Unknown"
+      }
+      else return await JSON.parse(fs.readFileSync(firstPackageJson, "utf8"));
+    };
+
+    return await fnetArgs({schema,initial,validate,packageCallback});
+  };
+
+  export { argsParser };
+
+{% elif atom.doc.features.project.format === 'cjs' %}
+
+  module.exports = async () => {
+
+    let schema = inputSchema;
+    let initial;
+
+    {% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}    
+    const fargs = get_fargs(process.argv.slice(2));
+    const ftags = get_ftags(process.argv.slice(2));
+
+    if (fargs) {
+      const { default: fnetConfig } = await import("@fnet/config");
+      const config = await fnetConfig({ name: fargs, tags: ftags });
+      if (config?.data) {
+        initial=config.data;
+      }
+    }
+    {% endif %}
+
+    const packageCallback = async () => {
+      const path = require("node:path");
+      const fs = require("node:fs");
+
+      let currentDir = __dirname;
+      let firstPackageJson = path.join(currentDir, "package.json");
+
+      while (currentDir !== path.parse(currentDir).root && !fs.existsSync(firstPackageJson)) {
+        currentDir = path.dirname(currentDir);
+        firstPackageJson = path.join(currentDir, "package.json");
+      }
+
+      if (!fs.existsSync(firstPackageJson)) {
+        return {
+          name: "Unknown",
+          version: "Unknown"
+        };
+      } else {
+        return JSON.parse(fs.readFileSync(firstPackageJson, "utf8"));
+      }
+    };
+
+    return await fnetArgs({schema,initial,validate,packageCallback});
+  };
+
+  module.exports.argsParser = argsParser;
+{% endif %}

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

@@ -0,0 +1,16 @@
+{
+    "include": [
+        "src/**/*.js"
+    ],
+    "compilerOptions": {
+        "outDir": "./types",
+        "declaration": true,
+        "allowJs": true,
+        "emitDeclarationOnly": true,
+        "target": "es5",
+        "strict": true,
+        "forceConsistentCasingInFileNames": true,
+        "skipLibCheck": true,
+        "jsx": "react-jsx"
+    }
+}

package/template/fnode/project/.gitignore.njk

@@ -0,0 +1,11 @@
+.DS_Store
+.workspace
+.fnet
+.out
+.package
+.npmrc
+.vscode
+{% if runtime === 'node' %}
+{% elif runtime === 'python' %}
+__pycache__
+{% endif %}

package/template/fnode/project/.vscode/launch.json.njk

@@ -0,0 +1,78 @@
+{% if runtime==='node' %}
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "debug-fnode-cli",
+      "type": "node",
+      "request": "launch",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
+      "program": "${workspaceFolder}/.workspace/dist/cli/esm/index.js",
+      "cwd": "${workspaceFolder}/.workspace",
+      "preLaunchTask": "fnode-watch",
+      "console": "integratedTerminal"
+    },
+    {
+      "name": "debug-fnode-app",
+      "type": "chrome",
+      "request": "launch",
+      "url": "http://localhost:3000/dist/app/esm/",
+      "webRoot": "${workspaceFolder}/.workspace",
+      "preLaunchTask": "fnode-watch",
+      // "userDataDir": false,
+      // "runtimeArgs": [
+      //   "--profile-directory=<profile-name>",
+      // ]
+    },
+  ],
+  // "compounds": [
+  //   {
+  //     "name": "debug-fnode-all",
+  //     "configurations": [
+  //       "debug-fnode-cli",
+  //       "debug-fnode-app"
+  //     ]
+  //   }
+  // ]
+}
+{% elif runtime==='python' %}
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "debug-fnode-cli",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${workspaceFolder}/.workspace/src/cli/index.py",
+      "console": "integratedTerminal",
+      "cwd": "${workspaceFolder}/.workspace",
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}/.workspace/src"
+      },
+      {% if platform ==='win32' %}
+      "python": "${workspaceFolder}/.workspace/.conda/python.exe",
+      {% else %}
+      "python":"${workspaceFolder}/.workspace/.conda/bin/python",
+      {% endif %}
+      "args": []
+    }
+  ]
+}
+{% else %}
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+  ]
+}
+{% endif %}

package/template/fnode/project/.vscode/tasks.json.njk

@@ -0,0 +1,46 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "fnode-build",
+      "type": "shell",
+      "command": "fnode build",
+    },
+    {
+      "label": "fnode-watch",
+      "type": "shell",
+      "command": "fnode watch",
+      "isBackground": true
+    },
+    {
+      "label": "fnode-deploy",
+      "type": "shell",
+      "command": "fnode deploy",
+    },
+    {
+      "label": "fnode-cli",
+      "type": "shell",
+      "command": "fnode cli",
+    },
+    {
+      "label": "fnode-app",
+      "type": "shell",
+      "command": "fnode app",
+    },
+    {
+      "label": "fnode-project-update",
+      "type": "shell",
+      "command": "fnode project -u",
+    },
+    {
+      "label": "fnode-npm-update",
+      "type": "shell",
+      "command": "fnode npm update",
+    },
+    {
+      "label": "fnode-npm-outdated",
+      "type": "shell",
+      "command": "fnode npm outdated",
+    }
+  ]
+}

package/template/fnode/project/fnet/targets.yaml.njk

@@ -0,0 +1,25 @@
+{% if runtime ==='node' %}
+npm-default:
+  type: npm
+  enabled: false
+  version: "{{npm.version or "0.1.0"}}"  
+  params:
+    # bin: some-bin-name
+    name: "{{npm.name or "@fnet/"+name}}"
+{% elif runtime==='bun' %}
+npm-default:
+  type: npm
+  enabled: false
+  version: "{{npm.version or "0.1.0"}}"  
+  params:
+    # bin: some-bin-name
+    name: "{{npm.name or "@fnet/"+name}}"
+{% elif runtime==='python' %}
+pypi-default:
+  type: pypi
+  enabled: false
+  version: "{{pip.version or "0.1.0"}}"  
+  params:
+    # bin: some-bin-name
+    name: "{{pip.name or "@fnet/"+name}}"
+{% endif %}

package/template/fnode/project/fnode.yaml.njk

@@ -0,0 +1,12 @@
+name: {{name}}
+
+{% if runtime === 'node' %}
+features:
+  s::runtime.type: node
+{% elif runtime === 'python' %}
+features:
+  s::runtime.type: python
+{% elif runtime === 'bun' %}
+features:
+  s::runtime.type: bun
+{% endif %}