biz-a-cli 2.3.56 → 2.3.58

package/bin/app.js

@@ -3,318 +3,217 @@
 import yargs from "yargs"
 import axios from "axios"
 import fs from "fs"
-import { runInNewContext } from "vm"
-import uglify from "uglify-js"
 import * as tar from "tar"
 import { verify, sign, privateDecrypt, constants as cryptoConstants, randomBytes, createCipheriv } from "node:crypto"
 import { basename } from "node:path"
 import { env } from "../envs/env.js"
-import * as vm from 'node:vm'
+import { prepareScript, encryptScript } from "./script.js"
 
 const keyFolderPath = process.argv[1].substring(0, process.argv[1].lastIndexOf("\\bin")) + "\\key"
 
-yargs(process.argv.slice(2))
-.option("s", {
-    alias: "server",
-    describe: `Server URL (ex: ${env.BIZA_SERVER_LINK} or http://192.168.1.1 or https://finaapi.imamatek.com)`,
-    type: "string",
-    demandOption: true
-})
-.option("i", {
-    alias: "dbIndex",
-    default: 2,
-    describe: "database index",
-    type: "number",
-    demandOption: false
-})
-.option("sub", {
-    alias: "subdomain",
-    describe: "Subdomain",
-    type: "string",
-    demandOption: false
-})
-.option("p", {
-    alias: "apiPort",
-    default : 212,
-    describe: "FINA API Port",
-    type: "number",
-    demandOption: false,
-})
-.command('add', 'Add Biz-A Application',
-    {
-        'd': {
-            alias: "workingDir",
-            describe: "Path to templates directory",
-            type: "string",
-            demandOption: false,
-            default: process.cwd(),
-        },
-        'v': {
-            alias: "verbose",
-            describe: "Print info to console",
-            type: "boolean",
-            demandOption: false,
-            default: false,
-        }
+const options = {
+    "s" : {
+        alias: "server",
+        describe: `API or Server URL (ex: ${env.BIZA_SERVER_LINK} or http://192.168.1.1 or https://finaapi.imamatek.com)`,
+        type: "string",
+        demandOption: true,
+        default: 'http://localhost'
     },
-    async (options)=>{
-
-        function printInfo(msg){if (options.verbose) {console.log(msg)}}
-
-        const prepareKeys = async ()=>{
-            const data = Buffer.from(JSON.stringify({issuer: 'CLI', acquirer: 'Client'})).toString('base64')
-            const privateKey = fs.readFileSync(`${keyFolderPath}\\cliPrivate.pem`)
-            const signature = sign('sha256', data, {key: privateKey, passphrase: 'Biz-A@cli', padding: cryptoConstants.RSA_PKCS1_PSS_PADDING}).toString('base64')
-            const res = await axios.get(env.BIZA_SERVER_LINK+'/api/issuerKey', {params: {data, signature}})
-            if ((res.data.data!=null) && verify('sha256', res.data.data, {key: fs.readFileSync(`${keyFolderPath}\\serverPublic.pem`), padding: cryptoConstants.RSA_PKCS1_PSS_PADDING}, Buffer.from(res.data.signature, 'base64'))) {
-                const resData = JSON.parse(Buffer.from(res.data.data, 'base64').toString())
-                const decryptedAESKey = privateDecrypt({key: privateKey, passphrase: 'Biz-A@cli', padding: cryptoConstants.RSA_PKCS1_OAEP_PADDING}, Buffer.from(resData.issuer.key, 'base64')).toString()
-                const cliSignature = (signedData)=>sign('sha256', signedData, {key: privateKey, passphrase: 'Biz-A@cli', padding: cryptoConstants.RSA_PKCS1_PSS_PADDING}).toString('base64')
-                const acquirerData = Buffer.from(JSON.stringify(resData.acquirer)).toString('base64')
-                const signature = cliSignature(acquirerData)
-                return {encryptKey: decryptedAESKey, metadata: {acquirer: {data: acquirerData, signature}}}
-            }
-            else {
-                return null
-            }
-        }
-
-        function replacer(key, value) {
-        /*
-            // with line break
-            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;
-            }
-        */
-
-            // without line break
-            if (typeof value == 'function') {
-                const fnScript = value.toString()
-                let params, body = ''
-                if (fnScript.indexOf('{')==-1) {
-                    const arr = fnScript.split('=>')
-                    params = arr[0]
-                    body = arr.slice(1).join()
-                } else {
-                    params = fnScript.split('{')[0]
-                    body = fnScript.substring(fnScript.indexOf('{')+1,  fnScript.lastIndexOf('}'))
-                }
-                params = params.replace(/(\s|=>|\(|\)|function)/gim, '')
-                printInfo(['window.Function', params, body])
-                return ['window.Function', params, body]
-            } else {
-                return value;
-            }
-        }
-
-        const minifiedIt = async (fileName) => {
-            const dataFile = fs.readFileSync(fileName);
-            printInfo(`===================\n${fileName.toUpperCase()}\n===================`)
-
-            const minifyResult = uglify.minify(dataFile.toString(), {compress: false, mangle: false})
-            if (minifyResult.error ) {throw (`${fileName}:${minifyResult.error.line}:${minifyResult.error.col}: ` + minifyResult.error)}
-            let jsMinData = minifyResult.code
-            jsMinData = jsMinData.replace('module.exports=get;', '') // Ex : at "executeBlockLib.js" of Imamatek App, will throw error. We need this line code for testing or debugging
-            const minifiedBuffer = Buffer.from(jsMinData)
-            printInfo(['Minify : \n', minifiedBuffer.toString()].join(''))
-
-            let stringifyData = ''
-            const isJsonFile = fileName.split('.').pop().toLowerCase().match(/^(json)$/)
-
-            // compile using node.js VM
-            try {
-                printInfo('Running script with VM')
-                if (isJsonFile) {
-                    const vmResult = runInNewContext(minifiedBuffer.toString())
-                    stringifyData = vmResult ? JSON.stringify((typeof vmResult=='function') ? vmResult() : (vmResult || ''), replacer) : ''
-                } else {
-                    // for handling "get" function in local scope (let, var, const)
-                    const sandbox = vm.createContext({script: ''});
-                    vm.runInContext(
-                        minifiedBuffer.toString() + "\n script = (typeof get=='undefined') ? '' : (typeof get=='function') ? get() : (get||'')",
-                        sandbox
-                    )
-                    stringifyData = JSON.stringify(sandbox.script, replacer)
-                }
-            } catch (err){
-                printInfo(`${fileName} : ` + err) // Do not log it as error, we will try to compile the script using ES6 Import
-                stringifyData = ''
-            }
-
-            const isEmptyScript = (scriptText)=>((typeof scriptText=='undefined') || (scriptText===null) || (scriptText.trim()==='""') || (typeof scriptText=='string' && scriptText.trim().length==0))
-
-            // compile using ES6 Import
-            if (isEmptyScript(stringifyData)) {
-                try {
-                    printInfo('Running script with Import function')
-                    const lib = await import(`file://${process.cwd()}\\${fileName}`, isJsonFile ? {assert: {type: "json"}} : {})
-                    stringifyData = JSON.stringify((typeof lib.default=='function') ? lib.default() : (lib.default || ''), replacer).replace(/  /g,'') // remove trailing whitespace
-                    // stringifyData = stringifyData.replace(/\\r\\n/g,'') // remove line break. We can not do this because "inline css" still requires line breaks
-                } catch (error){
-                    throw(`${fileName} : ` + error)
-                }
-            }
-
-            if (isEmptyScript(stringifyData)) {
-                throw(`${fileName} : ` + 'Failed to compile template script.\nPlease make sure the script is correct and not returning empty result')
-            } else {
-                printInfo('Array function :')
-                printInfo(['Stringify : \n', stringifyData].join(''))
-            }
-            // console.log('RESULT =>', stringifyData)
-            printInfo('===================')
-            return Buffer.from(stringifyData)
+    "i" : {
+        alias: "dbIndex",
+        default: 2,
+        describe: "database index",
+        type: "number",
+        demandOption: false
+    },
+    "sub": {
+        alias: "subdomain",
+        describe: "Subdomain",
+        type: "string",
+        demandOption: false
+    },
+    "p": {
+        alias: "apiPort",
+        default : 212,
+        describe: "FINA API Port",
+        type: "number",
+        demandOption: false,
+    }
+}
+
+const addCommandOptions = {
+    'd': {
+        alias: "workingDir",
+        describe: "Path to templates directory",
+        type: "string",
+        demandOption: false,
+        default: process.cwd(),
+    },
+    'v': {
+        alias: "verbose",
+        describe: "Print info to console",
+        type: "boolean",
+        demandOption: false,
+        default: false,
+    }
+}
+
+const removeCommandOptions = {
+    'n': {
+        alias: "appName",
+        describe: "Application name",
+        type: "string",
+        demandOption: true,
+        default: ""
+    }
+}
+
+Object
+.keys(options)
+.reduce((app, optKey)=>app = app.option(optKey, options[optKey]), yargs(process.argv.slice(2)))
+.command('add', 'Add Biz-A Application', addCommandOptions, async (options)=>{
+
+    const prepareKeys = async ()=>{
+        const data = Buffer.from(JSON.stringify({issuer: 'CLI', acquirer: 'Client'})).toString('base64')
+        const privateKey = fs.readFileSync(`${keyFolderPath}\\cliPrivate.pem`)
+        const signature = sign('sha256', data, {key: privateKey, passphrase: 'Biz-A@cli', padding: cryptoConstants.RSA_PKCS1_PSS_PADDING}).toString('base64')
+        const res = await axios.get(env.BIZA_SERVER_LINK+'/api/issuerKey', {params: {data, signature}})
+        if ((res.data.data!=null) && verify('sha256', res.data.data, {key: fs.readFileSync(`${keyFolderPath}\\serverPublic.pem`), padding: cryptoConstants.RSA_PKCS1_PSS_PADDING}, Buffer.from(res.data.signature, 'base64'))) {
+            const resData = JSON.parse(Buffer.from(res.data.data, 'base64').toString())
+            const decryptedAESKey = privateDecrypt({key: privateKey, passphrase: 'Biz-A@cli', padding: cryptoConstants.RSA_PKCS1_OAEP_PADDING}, Buffer.from(resData.issuer.key, 'base64')).toString()
+            const cliSignature = (signedData)=>sign('sha256', signedData, {key: privateKey, passphrase: 'Biz-A@cli', padding: cryptoConstants.RSA_PKCS1_PSS_PADDING}).toString('base64')
+            const acquirerData = Buffer.from(JSON.stringify(resData.acquirer)).toString('base64')
+            const signature = cliSignature(acquirerData)
+            return {encryptKey: decryptedAESKey, metadata: {acquirer: {data: acquirerData, signature}}}
         }
-
-        const encryptIt = (data, encryptKey)=>{
-            const initializeVector = randomBytes(16) // "iv" is unique for each template file
-            const cipher = createCipheriv('aes-256-cbc', Buffer.from(encryptKey, 'base64'), initializeVector)
-            return Buffer.concat([initializeVector, cipher.update(data), cipher.final()]) // we put "iv" at beginning of cipherText, seperate it when doing decryption
+        else {
+            return null
         }
+    }
 
-        const compressIt = (fileName, folderPath)=>{
-            // tar v7.1.0 -> tested 10x times, 2-3x times last compressed file have empty content
-            // tar v.7.4.0 -> tested 1000x times, all files have content (used app.test.js)
-            let compressSuccess = false
-            const maxRetry = 10
-            let retryCount = 0
-            do {
-                tar.c({file: fileName, cwd: folderPath, gzip: {level:9}, strict: true, sync: true}, fs.readdirSync(folderPath))
-                compressSuccess = true
-                tar.t({file: fileName, cwd: folderPath, sync: true, onentry: (entry)=>{
-                    if (entry.size==0) {
-                        compressSuccess = false
-                    }
-                }})
-                if (compressSuccess==false) {
-                    fs.unlinkSync(fileName)
-                    retryCount++
+    const compressIt = (fileName, folderPath)=>{
+        // tar v7.1.0 -> tested 10x times, 2-3x times last compressed file have empty content
+        // tar v.7.4.0 -> tested 1000x times, all files have content (used app.test.js)
+        let compressSuccess = false
+        const maxRetry = 10
+        let retryCount = 0
+        do {
+            tar.c({file: fileName, cwd: folderPath, gzip: {level:9}, strict: true, sync: true}, fs.readdirSync(folderPath))
+            compressSuccess = true
+            tar.t({file: fileName, cwd: folderPath, sync: true, onentry: (entry)=>{
+                if (entry.size==0) {
+                    compressSuccess = false
                 }
+            }})
+            if (compressSuccess==false) {
+                fs.unlinkSync(fileName)
+                retryCount++
             }
-            while ((compressSuccess==false) && (retryCount<=maxRetry))
-        }
-
-        const getFileList = ()=>{
-            return (fs.readdirSync(process.cwd())).filter((fileName)=>{
-                const stat = fs.statSync(fileName)
-                return stat.isFile() && (stat.size>0) && ((fileName.split('.').pop().toLowerCase().match(/^(js)$/) || (fileName.toLowerCase()=='menu.json')))
-            })
         }
+        while ((compressSuccess==false) && (retryCount<=maxRetry))
+    }
 
-        async function addApp() {
-            /*
-            hex    => 2 char = 1 bytes     => can be encrypted
-            base64 => 4 char = 3 bytes     => can be encrypted. Smaller size compare to Hex
-            utf8   => 1 char = 1 - 4 bytes => can not be encrypted, encryption need precise bytes per Character. Smallest Size compare to Hex and base64
-            */
-            process.chdir(options.workingDir)
-            try {
-                const bundlingStart = performance.now()
-                const rootFolder = './upload/'
-                const bundleName = basename(process.cwd()).trim().replace(' ', '').toLowerCase()
-                const bundleFolder = rootFolder+bundleName+'/'
-                const files = getFileList()
-                if (files.length>0) {
-                    const keys = await prepareKeys()
-                    let processedFile = 0
-                    fs.rmSync(rootFolder, {force: true, recursive: true})
-                    fs.mkdirSync(bundleFolder, {recursive: true})
-                    for (const file of files) {
-                        const fileName = file.toLowerCase();
-// if (['finalib.js', 'solib.js'].indexOf(fileName)==-1) {continue}
-                        const minifiedData = await minifiedIt(fileName);
-                        const encryptedData = encryptIt(minifiedData, keys.encryptKey)
-                        if (fileName=='menu.json') {
-                            keys.metadata['menu'] = encryptedData.toString('base64')
-                        } else {
-                            fs.writeFileSync(bundleFolder+fileName, encryptedData.toString('base64'))
-                        }
-                        processedFile++
-                    }
-                    const bundleFile = `${rootFolder}${bundleName}.tgz`
-                    compressIt(bundleFile, bundleFolder)
-                    console.log(`Finished packing ${processedFile} files into "${bundleFile}" (${((performance.now()-bundlingStart)/1000).toFixed(2)}s)`)
+    const getFileList = ()=>{
+        return (fs.readdirSync(process.cwd())).filter((fileName)=>{
+            const stat = fs.statSync(fileName)
+            return stat.isFile() && (stat.size>0) && ((fileName.split('.').pop().toLowerCase().match(/^(js)$/) || (fileName.toLowerCase()=='menu.json')))
+        })
+    }
 
-                    // send to FINAPI
-                    const uploadingStart = performance.now()
-                    const data = (fs.readFileSync(bundleFile)).toString('base64') // *.tgz to base64String
-                    const baseUrl = 'fina/rest/TOrmMethod/%22setApp%22'
-                    const url = options.sub ?
-                        `${options.server}/hub/${baseUrl}?subdomain=${options.sub}` :
-                        `${options.server}:${options.apiPort}/${baseUrl}`
-                    const headers = {'Content-Type': 'text/plain'}
-                    const param = { _parameters: [options.dbIndex, bundleName, data, keys.metadata] }
-                    const res = await axios.post(url, param, { headers: headers });
-                    if (res.data.success) {
-                        console.log(`Finished uploading "${bundleFile}" (${((performance.now()-uploadingStart)/1000).toFixed(2)}s)`)
-                        fs.rmSync(rootFolder, {force: true, recursive: true})
+    async function addApp() {
+        /*
+        hex    => 2 char = 1 bytes     => can be encrypted
+        base64 => 4 char = 3 bytes     => can be encrypted. Smaller size compare to Hex
+        utf8   => 1 char = 1 - 4 bytes => can not be encrypted, encryption need precise bytes per Character. Smallest Size compare to Hex and base64
+        */
+        process.chdir(options.workingDir)
+        try {
+            const bundlingStart = performance.now()
+            const rootFolder = './upload/'
+            const bundleName = basename(process.cwd()).trim().replace(' ', '').toLowerCase()
+            const bundleFolder = rootFolder+bundleName+'/'
+            const files = getFileList()
+            if (files.length>0) {
+                const keys = await prepareKeys()
+                let processedFile = 0
+                fs.rmSync(rootFolder, {force: true, recursive: true})
+                fs.mkdirSync(bundleFolder, {recursive: true})
+                for (const file of files) {
+                    const fileName = file.toLowerCase();
+                    const encryptedScript = encryptScript(await prepareScript(fileName, fs.readFileSync(fileName).toString(), options.verbose), keys.encryptKey)
+                    if (fileName=='menu.json') {
+                        keys.metadata['menu'] = encryptedScript.toString('base64')
                     } else {
-                        console.error(res.data.error)
+                        fs.writeFileSync(bundleFolder+fileName, encryptedScript.toString('base64'))
                     }
-                } else {
-                    console.error('Nothing to upload. Please recheck your app folder.')
-                }
-            } catch (e) {
-                console.error(e.response?.data ? e.response.data : e)
-                // console.error({e})
-            }
-        }
 
-        await addApp()
-    }
-)
-.command('remove', 'Remove Biz-A Application',
-    {
-        'n': {
-            alias: "appName",
-            describe: "Application name",
-            type: "string",
-            demandOption: true,
-            default: ""
-        }
-    },
-    (options)=>{
-        (async () => {
-            try {
-                const baseUrl = 'fina/rest/TOrmMethod/%22deleteApp%22'
+                    processedFile++
+                }
+                const bundleFile = `${rootFolder}${bundleName}.tgz`
+                compressIt(bundleFile, bundleFolder)
+                console.log(`Finished packing ${processedFile} files into "${bundleFile}" (${((performance.now()-bundlingStart)/1000).toFixed(2)}s)`)
+
+                // send to API
+                const uploadingStart = performance.now()
+                const data = (fs.readFileSync(bundleFile)).toString('base64') // *.tgz to base64String
+                const baseUrl = 'fina/rest/TOrmMethod/%22setApp%22'
                 const url = options.sub ?
                     `${options.server}/hub/${baseUrl}?subdomain=${options.sub}` :
                     `${options.server}:${options.apiPort}/${baseUrl}`
                 const headers = {'Content-Type': 'text/plain'}
-                const deleteApps = options.appName.trim().replaceAll(' ', '').toLowerCase()
-                const param = { _parameters: [options.dbIndex, deleteApps] }
+                const param = { _parameters: [options.dbIndex, bundleName, data, keys.metadata] }
                 const res = await axios.post(url, param, { headers: headers });
-                if (res.data?.success) {
-                    if (deleteApps=='') {
-                        console.log('All apps removed')
-                    } else {
-                        const failedList = (res.data._f && (typeof res.data._f=='string')) ? res.data._f.trim().replaceAll(' ', '').toLowerCase().split(',') : []
-                        const removeList = deleteApps.split(',')
-                        removeList.forEach((app)=>{
-                            console.log(`${app} ${failedList.indexOf(app)==-1 ? 'removed' : 'not found'}`)
-                        })
-                    }
+                if (res.data.success) {
+                    console.log(`Finished uploading "${bundleFile}" (${((performance.now()-uploadingStart)/1000).toFixed(2)}s)`)
+                    fs.rmSync(rootFolder, {force: true, recursive: true})
                 } else {
                     console.error(res.data.error)
                 }
-                return res
-            } catch (e) {
-                const errMsg = (e.response?.data ? e.response.data : e)
-                console.error(errMsg)
-                return errMsg
+            } else {
+                console.error('Nothing to upload. Please recheck your app folder.')
             }
-        })()
+        } catch (e) {
+            console.error(e.response?.data ? e.response.data : e)
+        }
     }
-)
+
+    await addApp()
+})
+.command('remove', 'Remove Biz-A Application', removeCommandOptions, (options)=>{
+    (async () => {
+        try {
+            const baseUrl = 'fina/rest/TOrmMethod/%22deleteApp%22'
+            const url = options.sub ?
+                `${options.server}/hub/${baseUrl}?subdomain=${options.sub}` :
+                `${options.server}:${options.apiPort}/${baseUrl}`
+            const headers = {'Content-Type': 'text/plain'}
+            const deleteApps = options.appName.trim().replaceAll(' ', '').toLowerCase()
+            const param = { _parameters: [options.dbIndex, deleteApps] }
+            const res = await axios.post(url, param, { headers: headers });
+            if (res.data?.success) {
+                if (deleteApps=='') {
+                    console.log('All apps removed')
+                } else {
+                    const failedList = (res.data._f && (typeof res.data._f=='string')) ? res.data._f.trim().replaceAll(' ', '').toLowerCase().split(',') : []
+                    const removeList = deleteApps.split(',')
+                    removeList.forEach((app)=>{
+                        console.log(`${app} ${failedList.indexOf(app)==-1 ? 'removed' : 'not found'}`)
+                    })
+                }
+            } else {
+                console.error(res.data.error)
+            }
+            return res
+        } catch (e) {
+            const errMsg = (e.response?.data ? e.response.data : e)
+            console.error(errMsg)
+            return errMsg
+        }
+    })()
+})
 .recommendCommands()
 .demandCommand(1, 'You need at least one command before moving on')
 .strict()
-.parse();
+.parse();
+
+export {options, addCommandOptions, removeCommandOptions}

package/bin/deployEvent.js

@@ -0,0 +1,105 @@
+import axios from 'axios';
+import { prepareScript, encryptScript } from './script.js';
+import { IDLE_SOCKET_TIMEOUT_MILLISECONDS } from './hubEvent.js';
+import { CLIENT_ROOM } from './directHubEvent.js';
+
+export async function getAppData(apiOpts){
+    return await axios.request({
+        timeout : IDLE_SOCKET_TIMEOUT_MILLISECONDS,
+        baseURL : `${apiOpts['secure']==true ? 'https://' : 'http://'}${apiOpts['hostname']}:${apiOpts['port']}`,
+        url : 'fina/rest/TOrmMethod/%22list%22',
+        method : 'POST',
+        "data" : {
+            "dbIndex": apiOpts['dbindex'],
+            "object":{
+                "columns":[
+                    {"title":"app", "data":"SYS$APPS.APPNAME"},
+                    {"title":"metadata", "data":"SYS$APPS.METADATA"}
+                ]
+            }
+        }
+    })
+    .then(response=>{
+        return {error: null, apps: JSON.parse(response.data.data)};
+    })
+    .catch(err=>{
+        return {"error": ((err && (err instanceof Error)) ? err.message : err), apps: []};
+    });
+};
+
+async function getDeployScript(serverUrl, appList, data){
+    let script = await prepareScript(data.fileName, data.script, false);
+    if (script) {
+        script = await axios.request({
+            timeout : IDLE_SOCKET_TIMEOUT_MILLISECONDS,
+            baseURL : serverUrl,
+            url : 'api/acquirerKey',
+            method : 'POST',
+            "data" : {"metadata": JSON.stringify(JSON.parse((appList.find((app)=>app['SYS$APPS.APPNAME']===data.appName))['SYS$APPS.METADATA'])['acquirer'])},
+        })
+        .then(response=>encryptScript(script, response.data).toString('base64'));
+    };
+    return script;
+};
+
+export async function onScriptChangeFromVsCode(sock, serverUrl, appList, data){
+    let script;
+    try {
+        script = await getDeployScript(serverUrl, appList, data);
+        if (script) {
+            sock.to(CLIENT_ROOM).emit('scriptDeploy', {...data, ...{script}});
+            return {error: null, script};
+        }
+        else {
+            throw new Error('Invalid Script');
+        };
+    }
+    catch (err) {
+        return {"error": ((err && (err instanceof Error)) ? err.message : err), script};
+    };
+};
+
+const addAppListListener = (sock,argv)=>{
+    sock.on('appList', async (data, cb)=>{
+        const result = await getAppData(argv);
+        cb(result.error, ((result.error) ? [] : result.apps.map((app)=>app['SYS$APPS.APPNAME'])));
+    });
+};
+
+const addOnScriptChangeListener = (sock, argv, deployFn)=>{
+    sock.on('scriptChange', async (data, cb)=>{
+        const result = await getAppData(argv);
+        if (result.error) {
+            cb(result);
+        }
+        else {
+            const deployResult = await deployFn(result.apps, data);
+            cb(deployResult.error, deployResult.script);
+        };
+    });
+};
+
+export const deploymentListenerForVSCode = (socket, argv)=>{
+    addAppListListener(socket,argv);
+    addOnScriptChangeListener(socket, argv, async (apps, data)=>{
+        return (await onScriptChangeFromVsCode(socket, argv['server'], apps, data));
+    });
+};
+
+export async function onScriptChangeFromHubServer(serverUrl, appList, data){
+    let script;
+    try {
+        script = await getDeployScript(serverUrl, appList, data);
+        return {error: (script ? null : 'Invalid Script'), script};
+    }
+    catch (err) {
+        return {"error": ((err && (err instanceof Error)) ? err.message : err), script};
+    };
+};
+
+export const deploymentListenerForHubServer = (socket, argv)=>{
+    addAppListListener(socket, argv);
+    addOnScriptChangeListener(socket, argv, async (apps, data)=>{
+        return (await onScriptChangeFromHubServer(argv['server'], apps, data));
+    });
+};