@fnet/cli 0.132.0 → 0.133.1

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

@@ -1,53 +1,15 @@
-{% include "src/default/macros/block-header.js.njk" %}
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
 
-{% include "src/default/macros/block-next-header.js.njk" %}
+{% import "src/default/types/block.js.njk" as block with context %}
 
-{% include "src/default/macros/block-modules-header.js.njk" %}
+{% call block.header() %}
+{% endcall %}
 
-export default function Block(context){
+{% call block.definition() %}
 
-  {% include "src/default/macros/block-body-header.js.njk" %}
+{% endcall %}
 
-  this.run= function (){
-      
-    {% include "src/default/macros/block-entry-args.js.njk" %}
-
-    return new Promise(async (resolve,reject)=>{
-                  
-      {% include "src/default/macros/block-run-header.js.njk" %}
-
-      {% include "src/default/macros/page.js.njk" %}
-
-      {% include "src/default/macros/block-modules.js.njk" %}
-
-      {% if context.next and context.transform.wait==='next' %}
-        flow.waitForNext({
-          key:'{{indexKey}}',
-          next: async () =>  {
-              {% include "src/default/macros/block-next.js.njk" %}
-          }
-        });
-      {% endif %}
-
-      {% for assign in context.transform.assign %}
-      flow.set({{assign.key | safe}},{{assign.value | safe}});
-      {% endfor%}
-
-      {% include "src/default/macros/block-signal.js.njk" %}
-
-      {% if context.transform.return %}
-        resolve({type:'return',value: {{context.transform.return | safe}}});
-      {% elseif context.next and context.transform.wait!=='next'%}
-        {% include "src/default/macros/block-next.js.njk" %}
-      {% elseif not context.next%}
-        resolve();
-      {% endif %}
-
-      {% include "src/default/macros/block-run-footer.js.njk" %}
-    });
-  }
-
-  Object.freeze(this);
-}
-
-{% include "src/default/macros/block-footer.js.njk" %}
+{% call block.footer()%} 
+{% endcall %}

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

@@ -1,156 +1,110 @@
-{% include "src/default/macros/block-header.js.njk" %}
-
-{% include "src/default/macros/block-next-header.js.njk" %}
-
-{% include "src/default/macros/block-library-header.js.njk" %}
-
-{% include "src/default/macros/block-modules-header.js.njk" %}
-
-export default function Block(context){
-
-  {% include "src/default/macros/block-body-header.js.njk" %}
-  
-  this.run= function (){
-      
-    {% include "src/default/macros/block-entry-args.js.njk" %}
-
-    return new Promise(async (resolve,reject)=>{
-
-
-      try{
-        {% include "src/default/macros/block-run-header.js.njk" %}
-
-        {% include "src/default/macros/page.js.njk" %}
-
-        {% include "src/default/macros/block-modules.js.njk" %}
-
-        {% if context.next and context.transform.wait==='next' %}
-          flow.waitForNext({
-            key:'{{indexKey}}',
-            next: async () =>  {
-                {% include "src/default/macros/block-next.js.njk" %}
-            }
-          });
-        {% endif %}
-
-        {# 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 %}
-
-        {% for assign in context.transform.result %}
-          flow.set({{assign.key | safe}},{{assign.value | safe}});
-        {% endfor%}
-
-        {% include "src/default/macros/block-assign.js.njk" %}
-
-        {% include "src/default/macros/block-signal.js.njk" %}
-
-        {% if context.transform.return %}
-          resolve({type:'return',value: {{context.transform.return | safe}}});
-        {% elseif context.next and context.transform.wait!=='next'%}
-          {% include "src/default/macros/block-next.js.njk" %}
-        {% elseif not context.next%}
-          resolve();
-        {% endif %}
-  
-        {% include "src/default/macros/block-run-footer.js.njk" %}
-      }
-      catch(error){
-          onError? onError(error) : reject(error);
-      }      
-    });
-  }
-
-  Object.freeze(this); 
-}
-
-{% include "src/default/macros/block-footer.js.njk" %}
+{% 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

@@ -1,87 +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];
+      }
+    });
 
-{% include "src/default/macros/block-header.js.njk" %}
-
-{% include "src/default/macros/block-next-header.js.njk" %}
-
-{% include "src/default/macros/block-modules-header.js.njk" %}
-
-{% 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%}
-
-export default function Block(context) {
-
-  {% include "src/default/macros/block-body-header.js.njk" %}
+    // Create new context with updated for
+    const loopContext = { ...c, for: forProxy };
 
-  this.run= function (){
-      
-    {% include "src/default/macros/block-entry-args.js.njk" %}
+    {% if childs.length %}
+      let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:loopContext  });
+      let currentArgs=args;
 
-    return new Promise(async (resolve,reject)=>{
-                  
-      {% include "src/default/macros/block-run-header.js.njk" %}
-      
-      {% include "src/default/macros/page.js.njk" %}
-      
-      {% include "src/default/macros/block-modules.js.njk" %}
+      do {
 
-      {% if childs.length %}
-        {% if childs[0].definition.dynamic %}
-          // FIRST CHILD: {{childs[0].indexKey}}
-          const { default: {{childs[0].codeKey}} } = await import("./{{childs[0].codeKey}}.js");
+        {% if workflow.parent.context.atom.doc.features.print_runners %}
+          console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
         {% endif %}
-      {% endif%}
-
-      for await(const {{context.transform.for.value | safe}} of {{context.transform.for.in | safe}}){
-        c.for={ {{context.transform.for.value | safe}} };
 
-        {% if childs.length %}
-          let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:c  });
-          let currentArgs=args;
+        const nextBlock= typeof currentArgs==='undefined'? await current.run()
+          : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
 
-          do {
-            
-            {% if workflow.parent.context.atom.doc.features.print_runners %}
-              console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
-            {% endif %}
+        if(nextBlock?.type==='return') return resolve(nextBlock);
+        else if(nextBlock?.type!=='block') break;
 
-            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.toType.ParentTypeId!==_this.constructor.TypeId)
+          return resolve(nextBlock);
 
-            if(nextBlock?.type==='return') return resolve(nextBlock);
-            else if(nextBlock?.type!=='block') break;
+        current=new nextBlock.toType({ parent:_this, engine, flow, caller:loopContext, error });
+        currentArgs=nextBlock.input;
 
-            if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
-              return resolve(nextBlock);
+      } while(true);
 
-            current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, onError, error });
-            currentArgs=nextBlock.input;
-            
-          } while(true);
-            
-        {% endif %}
-      }
-
-      {% include "src/default/macros/block-assign.js.njk" %}
-
-      {% include "src/default/macros/block-signal.js.njk" %}
-
-      {% if context.transform.return %}
-        resolve({type:'return',value: {{context.transform.return | safe}}});
-      {% elseif context.next %}
-        {% include "src/default/macros/block-next.js.njk" %}
-      {% else %}
-        resolve();
-      {% endif %}
-
-      {% include "src/default/macros/block-run-footer.js.njk" %}
-    });
-  }    
+    {% endif %}
+  }
 
-  Object.freeze(this); 
-}
+{% endcall %}
 
-{% include "src/default/macros/block-footer.js.njk" %}
+{% call block.footer()%} 
+{% endcall %}