@fnet/cli 0.5.1 → 0.5.2

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

@@ -0,0 +1,104 @@
+{# ============================================================================
+   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 Engine
+        {% if atom.doc.features.cli.extend===true %}
+        const result = await runExtended(input, { Engine });
+        {% else %}
+        const engine = new Engine();
+        const result = await engine.run(input);
+        {% endif %}
+
+        // 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/fnet/node/src/default/blocks/assign.js.njk

@@ -0,0 +1,15 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/call.js.njk

@@ -0,0 +1,110 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+{% set result=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+  {% include "src/default/macros/block-library-header.js.njk" %}
+{% endcall %}
+
+{% call block.definition() %}
+
+  {# NEW: Check if 'new' keyword is present for constructor call #}
+  {% if context.transform.new !== undefined %}
+    {# Constructor instantiation with 'new' keyword #}
+    {% if context.lib.type==='atom' and context.lib.atom.protocol!=='use:' %}
+      const LibClass=LIBRARY;
+    {% elseif context.lib.atom.protocol==='use:' %}
+      {# For use:e:: protocol, call value is the class name (e.g., use:e::Map → Map) #}
+      const LibClass={{context.transform.import}};
+      if(!LibClass) throw new Error('[use] Couldnt find class.');
+    {% else %}
+      throw new Error('Cannot instantiate: unsupported lib type.');
+    {% endif %}
+
+    {# Create instance with constructor args #}
+    {% if context.transform.new %}
+      const constructorArgs = {{ context.transform.new | safe }};
+      const instance = Array.isArray(constructorArgs) ? new LibClass(...constructorArgs) : new LibClass(constructorArgs);
+    {% else %}
+      const instance = new LibClass();
+    {% endif %}
+
+    {# If 'call' is specified, get the method from instance #}
+    {% if context.transform.call %}
+      const callLib = instance.{{context.transform.call}};
+    {% else %}
+      {# No method call, just return the instance #}
+      const callLib = () => instance;
+    {% endif %}
+
+  {% else %}
+    {# EXISTING: Normal function/method call (no 'new') #}
+    {% if context.lib.type==='atom'%}
+      {% if context.transform.libExp %}
+        const lib={{context.transform.libExp}};
+      {% else %}
+        const lib=LIBRARY;
+      {% endif %}
+    {% elseif context.lib.type==='subworkflow' %}
+      const lib={{context.lib.codeKey}};
+    {% elseif target.atom.protocol==='use:' %}
+      const lib={{context.transform.call}};
+      if(!lib) throw new Error('[use] Couldnt find lib.');
+    {% else %}
+      const lib=undefined;
+      throw new Error('Couldn file lib.');
+    {% endif %}
+
+    {% if context.lib.atom.doc.subtype==='workflow'%}
+      const Workflow=lib;
+      const workflow=new Workflow({app:engine.app,caller:c});
+      const callLib = workflow.run.bind(workflow);
+    {% elseif context.lib.type==='subworkflow'%}
+      const Workflow=lib;
+      const workflow=new Workflow({engine,flow,caller:c});
+      const callLib = workflow.run.bind(workflow);
+    {% else %}
+      const callLib = lib;
+    {% endif %}
+  {% endif %}
+
+  {# Execute the call #}
+  {% if context.transform.args %}
+    {% if context.lib.type==='subworkflow' %}
+      const callArgs ={ params: {{ context.transform.args | safe }} };
+    {% else %}
+      const callArgs ={{ context.transform.args | safe }} ;
+    {% endif %}
+
+    {% if context.transform.new !== undefined %}
+      {# For constructor calls, use instance as context #}
+      const result = Array.isArray(callArgs)?  await callLib.apply(instance,callArgs): await callLib.call(instance,callArgs);
+    {% else %}
+      {# For regular calls, use _this as context #}
+      {% if context.transform.context !== undefined %}
+        const result = Array.isArray(callArgs)?  await callLib.apply({{context.transform.context | safe}},callArgs): await callLib.call({{context.transform.context | safe}},callArgs);
+      {% else %}            
+        const result = Array.isArray(callArgs)?  await callLib.apply(_this,callArgs): await callLib.call(_this,callArgs);
+      {% endif %}
+
+    {% endif %}
+
+  {% else %}
+    {% if context.transform.new !== undefined %}
+      const result = await callLib.call(instance);
+    {% else %}
+      {% if context.transform.context !== undefined %}
+        const result = await callLib.call({{context.transform.context | safe}});
+      {% else %}            
+        const result = await callLib.call(_this);
+      {% endif %}
+    {% endif %}
+  {% endif %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/for.js.njk

@@ -0,0 +1,71 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+  {% if childs.length %}
+    {% if not childs[0].definition.dynamic %}
+      // FIRST CHILD: {{childs[0].indexKey}}
+      import {{childs[0].codeKey}} from "./{{childs[0].codeKey}}.js";
+    {% endif %}
+  {% endif%}
+{% endcall %}
+
+{% call block.definition() %}
+
+  {% if childs.length %}
+    {% if childs[0].definition.dynamic %}
+      // FIRST CHILD: {{childs[0].indexKey}}
+      const { default: {{childs[0].codeKey}} } = await import("./{{childs[0].codeKey}}.js");
+    {% endif %}
+  {% endif%}
+
+  for await(const {{context.transform.for.as | safe}} of {{context.transform.for.in | safe}}){
+    // Create Proxy for closure-like variable resolution
+    // Local variable shadows parent, but parent scope accessible via Proxy fallback
+    const localForVar = { {{context.transform.for.as | safe}}: {{context.transform.for.as | safe}} };
+    const forProxy = new Proxy(localForVar, {
+      get(target, prop) {
+        // Check local scope first (shadowing)
+        if (prop in target) return target[prop];
+        // Fallback to parent scope
+        return c.for?.[prop];
+      }
+    });
+
+    // Create new context with updated for
+    const loopContext = { ...c, for: forProxy };
+
+    {% if childs.length %}
+      let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:loopContext  });
+      let currentArgs=args;
+
+      do {
+
+        {% if workflow.parent.context.atom.doc.features.print_runners %}
+          console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+        {% endif %}
+
+        const nextBlock= typeof currentArgs==='undefined'? await current.run()
+          : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
+
+        if(nextBlock?.type==='return') return resolve(nextBlock);
+        else if(nextBlock?.type!=='block') break;
+
+        if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+          return resolve(nextBlock);
+
+        current=new nextBlock.toType({ parent:_this, engine, flow, caller:loopContext, error });
+        currentArgs=nextBlock.input;
+
+      } while(true);
+
+    {% endif %}
+  }
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/form.js.njk

@@ -0,0 +1,31 @@
+{% set waitForNext=true %}
+{% set assign=true %}
+{% set signal=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+
+  {% include "src/default/macros/block-library-header.js.njk" %}
+
+  import React from "react";
+
+{% endcall %}
+
+{% call block.definition() %}
+
+  {% if context.lib.type==='atom'%}
+    const formLib=LIBRARY;
+  {% elseif context.lib.type==='subworkflow' %}
+    const formLib={{context.lib.codeKey}};
+  {% else %}
+    const formLib=undefined; 
+    throw new Error('Couldnt find form.');
+  {% endif %}
+
+  {% include "src/default/macros/block-run-form.js.njk" %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/http.js.njk

@@ -0,0 +1,135 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+{% set result=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+  
+  // HTTP configuration
+  let url = {{ context.transform.http.url | safe }};
+  let method = "{{ context.transform.http.method |safe }}";
+  let headers = {{ context.transform.http.headers | safe  }};
+  let timeout = {{ context.transform.http.timeout }};
+  {% if context.transform.http.body !== undefined %}
+  let body = {% if context.transform.http.body is string %}{{ context.transform.http.body |safe }}{% else %}{{ context.transform.http.body | safe  }}{% endif %};
+  {% endif %}
+  {% if context.transform.http.params %}
+  let params = {{ context.transform.http.params | safe  }};
+  {% endif %}
+
+  // Create HTTP context for modules
+  const httpContext = { url, method, headers, timeout, params: {% if context.transform.http.params %}params{% else %}undefined{% endif %}, body: {% if context.transform.http.body !== undefined %}body{% else %}undefined{% endif %} };
+
+  // If any property is a module function (m::), call it with HTTP context
+  if (typeof url === 'function') {
+    url = await url(httpContext);
+  }
+
+  if (typeof method === 'function') {
+    method = await method(httpContext);
+  }
+
+  if (typeof headers === 'function') {
+    headers = await headers(httpContext);
+  }
+
+  if (typeof timeout === 'function') {
+    timeout = await timeout(httpContext);
+  }
+
+  {% if context.transform.http.params %}
+  if (typeof params === 'function') {
+    params = await params(httpContext);
+  }
+  {% endif %}
+
+  {% if context.transform.http.body !== undefined %}
+  if (typeof body === 'function') {
+    body = await body(httpContext);
+  }
+  {% endif %}
+
+  // Build URL with query parameters if provided
+  let finalUrl = url;
+  {% if context.transform.http.params %}
+  if (params && Object.keys(params).length > 0) {
+    const queryString = new URLSearchParams(params).toString();
+    finalUrl = url + (url.includes('?') ? '&' : '?') + queryString;
+  }
+  {% endif %}
+
+  // Prepare fetch options
+  const fetchOptions = {
+    method: method,
+    headers: headers
+  };
+
+  // Add body if present (and not GET/HEAD)
+  {% if context.transform.http.body %}
+  if (body !== undefined && method !== 'GET' && method !== 'HEAD') {
+    // Auto JSON.stringify if body is object
+    if (typeof body === 'object' && body !== null) {
+      fetchOptions.body = JSON.stringify(body);
+      // Auto set Content-Type if not already set
+      if (!fetchOptions.headers['Content-Type'] && !fetchOptions.headers['content-type']) {
+        fetchOptions.headers['Content-Type'] = 'application/json';
+      }
+    } else {
+      fetchOptions.body = body;
+    }
+  }
+  {% endif %}
+
+  // Create abort controller for timeout
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  fetchOptions.signal = controller.signal;
+
+  let result;
+
+  try {
+    // Execute HTTP request
+    const response = await fetch(finalUrl, fetchOptions);
+    clearTimeout(timeoutId);
+
+    // Check if response is successful (2xx)
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    // Parse response based on Content-Type
+    const contentType = response.headers.get('content-type');
+    
+    if (contentType && contentType.includes('application/json')) {
+      result = await response.json();
+    } else if (contentType && contentType.includes('text/')) {
+      result = await response.text();
+    } else {
+      // Try JSON first, fallback to text
+      try {
+        result = await response.json();
+      } catch (e) {
+        result = await response.text();
+      }
+    }
+  } catch (error) {
+    clearTimeout(timeoutId);
+
+    // Handle timeout error
+    if (error.name === 'AbortError') {
+      const timeoutError = new Error(`HTTP request timeout after ${timeout}ms: ${finalUrl}`);
+      return reject(timeoutError);
+    }
+
+    // Handle other errors
+    return reject(error);
+  }
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/modules.js.njk

@@ -0,0 +1,15 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/new.js.njk

@@ -0,0 +1,42 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+{% set result=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+  {% include "src/default/macros/block-library-header.js.njk" %}
+{% endcall %}
+
+{% call block.definition() %}
+
+  {# NEW: Check if 'new' keyword is present for constructor call #}
+  {% if context.transform.new !== undefined %}
+    {# Constructor instantiation with 'new' keyword #}
+    {% if context.lib.type==='atom' and context.lib.atom.protocol!=='use:' %}
+      const LibClass=LIBRARY;
+    {% elseif context.lib.atom.protocol==='use:' %}
+      {# For use:e:: protocol, call value is the class name (e.g., use:e::Map → Map) #}
+      const LibClass={{context.transform.import}};
+      if(!LibClass) throw new Error('[use] Couldnt find class.');
+    {% else %}
+      throw new Error('Cannot instantiate: unsupported lib type.');
+    {% endif %}
+
+    {# Create instance with constructor args #}
+    {% if context.transform.new %}
+      const constructorArgs = {{ context.transform.new | safe }};
+      const instance = Array.isArray(constructorArgs) ? new LibClass(...constructorArgs) : new LibClass(constructorArgs);
+    {% else %}
+      const instance = new LibClass();
+    {% endif %}
+
+  {% endif %}
+
+  const result = instance;
+  
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/next.js.njk

@@ -0,0 +1,15 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/output.js.njk

@@ -0,0 +1,15 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/blocks/parallel.js.njk

@@ -0,0 +1,64 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+{% set result=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+  {% for child in childs %}
+    {% if not child.definition.dynamic %}
+      // PARALLEL CHILD: {{child.indexKey}}
+      import {{child.codeKey}} from "./{{child.codeKey}}.js";
+    {% endif %}
+  {% endfor %}
+{% endcall %}
+
+{% call block.definition() %}
+  // PARALLEL EXECUTION
+  const promises = [];
+
+  {% for child in childs %}
+    {% if child.definition.dynamic %}
+      // PARALLEL CHILD: {{child.indexKey}}
+      const { default: {{child.codeKey}} } = await import("./{{child.codeKey}}.js");
+    {% endif %}
+
+    promises.push((async () => {
+      const current = new {{child.codeKey}}({ parent: _this, engine, flow, caller: c, error });
+
+      {% if workflow.parent.context.atom.doc.features.print_runners %}
+        console.log(new Date().toLocaleString(), ' * ', _this.constructor.IndexKey, ' -> ', current.constructor.IndexKey);
+      {% endif %}
+
+      const nextBlock = Array.isArray(args)
+        ? await current.run.apply(current, args)
+        : await current.run.call(current, args);
+
+      return nextBlock;
+    })());
+  {% endfor %}
+
+  // Execute based on strategy
+  {% set strategy = context.transform.strategy | default('all') %}
+  let result;
+
+  {% if strategy == 'race' %}
+    // Promise.race - first to complete wins
+    result = [await Promise.race(promises)];
+  {% elif strategy == 'any' %}
+    // Promise.any - first successful wins
+    result = [await Promise.any(promises)];
+  {% elif strategy == 'allsettled' %}
+    // Promise.allSettled - all complete, collect results
+    const settled = await Promise.allSettled(promises);
+    result = settled.map(r => r.status === 'fulfilled' ? r.value : null);
+  {% else %}
+    // Promise.all - all must succeed (default)
+    result = await Promise.all(promises);
+  {% endif %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}