biz-a-cli 2.3.1 → 2.3.2

package/bin/hub.js

@@ -1,50 +1,65 @@
 #!/usr/bin/env node
 
-const yargs = require('yargs');
+import yargs from 'yargs';
+import net from 'node:net';
+import io from "socket.io-client";
+
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const ss = require('socket.io-stream');  //SCY: Temporary, next will be replaced with import
+
 const IDLE_SOCKET_TIMEOUT_MILLISECONDS = 1000 * 30;
 
-let argv = yargs
-    .usage('Usage: $0 --server [string] --subdomain [string] --hostname [string] --port [number]')
+const argv = yargs(process.argv.slice(2))
+    .usage('Usage: $0 [options]')
     .options('s', {
         alias: 'server',
-        describe: '(Required) Tunnel server endpoint'
+        default: 'https://biz-a.herokuapp.com',
+        describe: '(Required) Tunnel server endpoint',
+        type: 'string',
+        demandOption: true
     })
     .options('sub', {
         alias: 'subdomain',
-        describe: '(Required) Public URL the tunnel server is forwarding to us'
+        describe: '(Required) Public URL the tunnel server is forwarding to us',
+        type: 'string',
+        demandOption: true
     })
     .options('h', {
         alias: 'hostname',
         default: '127.0.0.1',
-        describe: 'Address of local server for forwarding over socket-tunnel'
+        describe: 'Address of local server for forwarding over socket-tunnel',
+        type: 'string',
+        demandOption: true
     })
     .options('p', {
         alias: 'port',
-        describe: '(Required) Port of local server for forwarding over socket-tunnel'
+        default: 212,
+        describe: '(Required) Port of local server for forwarding over socket-tunnel',
+        type: 'number',
+        demandOption: true
     })
     .argv;
 
 if (argv.help) {
-    yargs.showHelp();
+    yargs().showHelp();
     process.exit();
 }
 
 if (!argv['server'] || !argv['subdomain'] || !argv['port']) {
-    for (var key in ['server', 'subdomain', 'port']) {
+    for (let key in ['server', 'subdomain', 'port']) {
         if (argv[key]) continue;
 
         console.log('Error: Required option, but nothing found');
 
-        yargs.showHelp();
-
+        yargs().showHelp();
         process.exit();
     }
 }
 
-return new Promise((resolve, reject) => {
-    const net = require('node:net');
-    const ss = require('socket.io-stream');
-    let socket = require('socket.io-client')(argv['server']);
+// return new Promise((resolve, reject) => {
+(() => new Promise((resolve, reject) => {
+    let socket = io(argv['server']);
 
     socket.on('connect', () => {
         console.log(new Date() + ': connected to socket server');
@@ -96,5 +111,5 @@ return new Promise((resolve, reject) => {
             s.end();
         });
     });
-
-})
+// })
+}))()

package/bin/index.js

@@ -1,102 +1,114 @@
 #!/usr/bin/env node
 
-const yargs = require("yargs");
-const axios = require("axios");
-const fs = require("fs").promises;
+import yargs from "yargs";
+import axios from "axios";
+import { promises as fs } from "fs";
+import { runInThisContext } from "vm";
 
-const vm= require("vm");
-const { option, number } = require("yargs");
-
-const options = yargs
-    .option("s", {alias:"server", describe:"Server URL", type:"string", demandOption:true})
-    .option("i", {alias:"dbindex", describe:"database index", type:number, demandOption:true})
-    // .option("d", {alias:"dir", describe:"Directory", type:"string", demandOption:false})
-    .option("sub", {alias:"subdomain", describe:"Subdomain", type:"string", demandOption:false})
+const options = yargs(process.argv.slice(2))
+    .option("s", {
+        alias: "server",
+        describe: "Server URL",
+        type: "string",
+        demandOption: true
+    })
+    .option("i", {
+        alias: "dbindex",
+        describe: "database index",
+        type: "number",
+        demandOption: true
+    })
+    // .option("d", {
+    //     alias: "dir",
+    //     describe: "Directory",
+    //     type: "string",
+    //     demandOption: false
+    // })
+    .option("sub", {
+        alias: "subdomain",
+        describe: "Subdomain",
+        type: "string",
+        demandOption: false
+    })
     .argv;
 
-const sendFile = async (filename, data)=>{
+const sendFile = async (filename, data) => {
     const baseUrl = 'fina/rest/TOrmMethod/%22setTemplate%22'
-    const url = options.sub ? 
-                `${options.server}/hub/${baseUrl}?subdomain=${options.sub}` :
-                `http://${options.server}:212/${baseUrl}`
-    // console.log('url', url)
-    
-    const headers={
-        'Content-Type':'text/plain'
+    const url = options.sub ?
+        `${options.server}/hub/${baseUrl}?subdomain=${options.sub}` :
+        `http://${options.server}:212/${baseUrl}`
+
+    const headers = {
+        'Content-Type': 'text/plain'
     }
-    const param = {_parameters: [options.dbindex, filename, data]};
-    return await axios.post(url, param, {headers:headers});
+    const param = { _parameters: [options.dbindex, filename, data] };
+    return await axios.post(url, param, { headers: headers });
 }
 
-function getParam(funcName){
-    var params = funcName.split('(');
+function getParam(funcName) {
+    let params = funcName.split('(');
     return params[1].split(')')[0].split(',');
 }
 
-function replacer(key,value){
-    if (typeof value == 'function'){
-      let arr = value.toString().replace(/(\r\n|\n|\r)/gm,"°").split("°");
-      if (arr.length < 3) throw 'Function must be minimal 3 lines';
-      return [
-        'window.Function',
-        getParam( arr[0] ),
-        arr.slice( 1, arr.length-1 )
-      ];
+function replacer(key, value) {
+    if (typeof value == 'function') {
+        let arr = value.toString().replace(/(\r\n|\n|\r)/gm, "°").split("°");
+        if (arr.length < 3) throw 'Function must be minimal 3 lines';
+        return [
+            'window.Function',
+            getParam(arr[0]),
+            arr.slice(1, arr.length - 1)
+        ];
     } else {
-      return value;
-    } 
+        return value;
+    }
 }
 
-const readTemplateFile= async (filename)=>{
+const readTemplateFile = async (filename) => {
     const data = await fs.readFile(filename);
     const ext = filename.split('.');
 
-    if (ext[ext.length-1] == 'js'){
+    if (ext[ext.length - 1] == 'js') {
         let result;
-        try{
-            const vmResult = vm.runInThisContext(data);
+        try {
+            const vmResult = runInThisContext(data);
             result = JSON.stringify(vmResult(), replacer);
-        } catch(ReferenceError) {
+        } catch (error) {
             const fn = `file://${process.cwd()}\\${filename}`;
-            const lib = await import(fn); 
+            const lib = await import(fn);
             result = JSON.stringify(lib.default(), replacer);
         }
-            
-        //console.log(result);
+
         return Buffer.from(result).toString('hex');
-        //console.log(result);
-        
+
     } else {
         return Buffer.from(data).toString('hex');
         //return JSON.stringify(JSON.parse(data));
     }
 }
 
-const loopFiles = async (dir) =>{
-    try{
+const loopFiles = async (dir) => {
+    try {
         const files = await fs.readdir(dir);
-        for (const file of files){
+        for (const file of files) {
             //const p = path.join(dir, file);
             if (file == 'package.json' || file == 'package-lock.json') continue;
 
             const stat = await fs.stat(file);
 
             if (stat.isFile()) {
-                
                 const data = await readTemplateFile(file);
-
-
-                //console.log(data.toString('hex'));
                 const res = await sendFile(file, data.toString('hex'));
-                if (res.data.success){
+                if (res.data.success) {
                     console.log(`file: ${file} uploaded`);
                 } else {
                     console.error(res.data.error);
                 }
-            } 
+            }
         }
-    } catch (e){
-        console.error(e.response && e.response.data ? e.response.data: e);
+    } catch (e) {
+        // console.error(e.response && e.response.data ? e.response.data : e);
+        console.error(e.response?.data ? e.response.data : e);
     }
 }
 

package/bin/proxy.js

@@ -1,20 +1,23 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
-const express = require('express');
-const cors = require('cors');
-const app        = express();
-const proxyCtl = require('../../biz-a/proxyController');
-const { option, number } = require("yargs");
-const yargs = require('yargs');
+import express from 'express';
+import cors from 'cors';
+const app = express();
+import { proxy } from '../proxyController.js';
+import yargs from 'yargs';
 
-
-const options = yargs
-    .option('p', {alias:'port', describe:'Port to use', type:'string', demandOption:false})
+const options = yargs(process.argv.slice(2))
+    .option('p', {
+        alias: 'port',
+        describe: 'Port to use',
+        type: 'string',
+        demandOption: false
+    })
     .argv;
 
 app.use(cors());
 
-app.use('/proxy', proxyCtl.proxy);
+app.use('/proxy', proxy);
 
 const port = 3000;
 

package/package.json

@@ -1,25 +1,26 @@
 {
   "name": "biz-a-cli",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "",
   "main": "bin/index.js",
+  "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "Imamatek",
   "license": "ISC",
   "bin": {
-    "uploadbiza": "./bin/index.js",
-    "proxy": "./bin/proxy.js",
-    "hub": "./bin/hub.js"
+    "uploadbiza": "bin/index.js",
+    "proxy": "bin/proxy.js",
+    "hub": "bin/hub.js"
   },
   "dependencies": {
-    "axios": "^0.27.2",
+    "axios": "^1.6.2",
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "net": "^1.0.2",
-    "socket.io-client": "^4.7.1",
+    "socket.io-client": "^4.7.2",
     "socket.io-stream": "^0.9.1",
-    "yargs": "^17.4.1"
+    "yargs": "^17.7.2"
   }
 }

package/proxyController.js

@@ -0,0 +1,83 @@
+import * as https from 'https';
+import * as http from 'http';
+
+export function proxy(clientRequest, clientResponse) {
+    try {
+        const isHttps = url => url.startsWith('https://');
+        const hasPort = url => url.indexOf(':') > -1;
+
+        const targetUrl = clientRequest.query.target ?
+            clientRequest.query.target
+            : clientRequest.get('target');
+        const target = targetUrl.split('/')[2];
+
+        let parsedHost = targetUrl.split('/').splice(2).splice(0, 1).join('/');
+        if (hasPort(target)) parsedHost = parsedHost.split(':')[0];
+        let targetPort = hasPort(target) ? target.split(':')[1] : null;
+
+        const parsedSSL = isHttps(targetUrl) ? https : http;
+
+        // console.log(clientRequest.headers)
+        let svrReqHeader = {};
+        if (clientRequest.headers["content-type"]) {
+            svrReqHeader["content-type"] = clientRequest.headers["content-type"];
+        }
+
+        const options = {
+            hostname: parsedHost,
+            port: isHttps(targetUrl) ?
+                // (targetPort ? targetPort : 443) :
+                // (targetPort ? targetPort : 80),
+                (targetPort || 443) :
+                (targetPort || 80),
+            path: clientRequest.url,
+            method: clientRequest.method,
+            headers: svrReqHeader
+        };
+        if (clientRequest.headers['user-agent']) {
+            options['User-Agent'] = clientRequest.headers['user-agent'];
+        }
+
+        const serverRequest = parsedSSL.request(options, function (serverResponse) {
+            try {
+                let body = '';
+                if (serverResponse.headers['content-type'] && String(serverResponse.headers['content-type']).indexOf('text/html') !== -1) {
+                    serverResponse.on('data', function (chunk) {
+                        body += chunk;
+                    });
+
+                    serverResponse.on('end', function () {
+                        clientResponse.writeHead(serverResponse.statusCode, serverResponse.headers);
+                        clientResponse.end(body);
+                    });
+                } else {
+                    serverResponse.pipe(clientResponse, {
+                        end: true,
+                    });
+                    clientResponse.contentType(serverResponse.headers['content-type']);
+                }
+            } catch (error) {
+                console.log('exception')
+                console.log(error);
+            }
+        });
+
+        serverRequest.on('error', function (err) {
+            // clientResponse.writeHead(503, {Error: err.message});
+            console.log('On Error serverRequest Proxy: ', err);
+        })
+
+        // console.log(clientRequest.body)
+        if (clientRequest.body) {
+            serverRequest.write(JSON.stringify(clientRequest.body));
+        }
+        serverRequest.end();
+    } catch (err) {
+        console.log(err);
+
+        // serverRequest.end();
+        // clientResponse.end();
+        serverRequest.destroy();
+        // clientResponse.destroy();
+    }
+};