biz-a-cli 2.3.69 → 2.3.71

package/bin/app.js

@@ -10,7 +10,19 @@ import { env } from "../envs/env.js"
 import { prepareScript, encryptScript } from "./script.js"
 import { spawn } from "node:child_process"
 
-const keyFolderPath = process.argv[1].substring(0, process.argv[1].lastIndexOf("\\bin")) + "\\key"
+const getKeyFolderPath = () => {
+    const scriptPath = (typeof process.argv[1] === 'string' && process.argv[1].length > 0)
+        ? process.argv[1]
+        : path.join(import.meta.dirname, 'app.js')
+    const normalizedPath = scriptPath.replaceAll('/', '\\')
+    const binPathPos = normalizedPath.lastIndexOf('\\bin')
+    if (binPathPos >= 0) {
+        return normalizedPath.substring(0, binPathPos) + '\\key'
+    }
+    return path.resolve(import.meta.dirname, '..', 'key')
+}
+
+const keyFolderPath = getKeyFolderPath()
 
 const options = {
     "s": {
@@ -69,174 +81,401 @@ const removeCommandOptions = {
     }
 }
 
-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 } } }
-            }
-            else {
-                return null
+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
+    }
+}
+
+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 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 getNormalizedFileName = (file) => {
+    if (typeof file === 'string') {
+        return file.trim()
+    }
+    if (file && typeof file === 'object') {
+        const fileName = file.fileName || file.name || file.path
+        return (fileName || '').toString().trim()
+    }
+    return ''
+}
+
+const normalizeFileList = (files) => {
+    if (Array.isArray(files)) {
+        return files
+            .map((file) => getNormalizedFileName(file))
+            .filter((fileName) => fileName.length > 0)
+    }
+    if (typeof files === 'string') {
+        return files.split(',').map((f) => f.trim()).filter((f) => f.length > 0)
+    }
+    return null
+}
+
+const normalizeAppName = (value) => String(value ?? '')
+    .trim()
+    .replace(/\s+/g, '')
+    .toLowerCase()
+
+const normalizeBodyScripts = (body = null) => {
+    const scriptMap = new Map()
+    if (!body || typeof body !== 'object') {
+        return scriptMap
+    }
+
+    const setScript = (name, content) => {
+        const fileName = (name || '').toString().trim().toLowerCase()
+        if (fileName.length === 0) {
+            return
+        }
+        if (typeof content === 'string') {
+            scriptMap.set(fileName, content)
+        } else if (Buffer.isBuffer(content)) {
+            scriptMap.set(fileName, content.toString())
+        }
+    }
+
+    const fromObjects = (list) => {
+        if (!Array.isArray(list)) {
+            return
+        }
+        list.forEach((item) => {
+            if (!item || typeof item !== 'object') {
+                return
             }
-            while ((compressSuccess == false) && (retryCount <= maxRetry))
+            const fileName = item.fileName || item.name || item.path
+            const content = item.content ?? item.data ?? item.script
+            setScript(fileName, content)
+        })
+    }
+
+    fromObjects(body.files)
+    fromObjects(body.fileList)
+
+    if (body.fileContents && (typeof body.fileContents === 'object')) {
+        Object.entries(body.fileContents).forEach(([name, content]) => setScript(name, content))
+    }
+    if (body.scripts && (typeof body.scripts === 'object')) {
+        Object.entries(body.scripts).forEach(([name, content]) => setScript(name, content))
+    }
+
+    return scriptMap
+}
+
+const getFileList = ({ workingDir = process.cwd(), files = null } = {}) => {
+    const fileList = normalizeFileList(files)
+    const candidateFiles = fileList || fs.readdirSync(workingDir)
+
+    return candidateFiles.filter((fileName) => {
+        const normalizedName = fileName.toString().trim()
+        const filePath = path.isAbsolute(normalizedName) ? normalizedName : path.join(workingDir, normalizedName)
+        if (!fs.existsSync(filePath)) {
+            return false
         }
+        const stat = fs.statSync(filePath)
+        const baseName = path.basename(normalizedName)
+        return stat.isFile() && (stat.size > 0) && ((baseName.split('.').pop().toLowerCase().match(/^(js)$/) || (baseName.toLowerCase() == 'menu.json')))
+    })
+}
 
-        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')))
-            })
+const parseApplicationConfigData = (rawConfig) => {
+    if (rawConfig == null) {
+        return null
+    }
+    if (typeof rawConfig === 'object') {
+        return rawConfig
+    }
+
+    const rawText = String(rawConfig).trim()
+    if (!rawText) {
+        return null
+    }
+
+    try {
+        return JSON.parse(rawText)
+    } catch {
+        try {
+            return Function(`${rawText}; return (typeof get === 'function') ? get() : null;`)()
+        } catch {
+            return null
         }
+    }
+}
 
-        async function runUnitTests() {  //SCY BZ 4331
-            let jestCommand = ['--no-install', 'jest', '--json'];
-            let output = '';
+const resolveAppDisplayNameFromApplicationConfig = async ({ server, apiPort, dbIndex, sub }) => {
+    if ((typeof axios.request) !== 'function') {
+        return ''
+    }
 
-            const testDir = path.join(options.workingDir, "test");
-            const workDir = path.resolve(options.workingDir);
-            try {
-                process.chdir(testDir)
-            } catch (error) {
-                if (error.code === 'ENOENT') {
-                    jestCommand.push('--passWithNoTests')
+    const baseUrl = 'fina/rest/TOrmMethod/%22list%22'
+    const url = sub
+        ? `${server}/hub/${baseUrl}?subdomain=${sub}`
+        : `${server}:${apiPort}/${baseUrl}`
+
+    try {
+        const response = await axios.request({
+            method: 'POST',
+            url,
+            headers: { 'Content-Type': 'text/plain' },
+            data: {
+                dbIndex,
+                object: {
+                    columns: [
+                        { title: 'name', data: 'SYS$CONFIG.NAME' },
+                        { title: 'data', data: 'SYS$CONFIG.DATA' }
+                    ]
                 }
             }
-            process.chdir(workDir);
+        })
 
-            const child = process.platform === 'win32'
-                ? spawn('cmd.exe', ['/d', '/s', '/c', 'npx', ...jestCommand])
-                : spawn('npx', jestCommand)
-            const collectOutput = data => {
-                output += data?.toString() || ''
-            }
-            child.stderr?.on('data', collectOutput)
-            child.stdout?.on('data', () => { }) // SCY BZ 4363, ref : https://nodejs.org/download/release/v22.19.0/docs/api/child_process.html
-
-            child.on('error', e => {
-                output += e?.message ? `\n${e.message}` : ''
-            });
-            child.on('close', async code => {
-                console.log('====================');
-                console.log(output);
-                console.log('====================');
-                let noTestsFound = output.includes('No tests found');
-                let missingJest = (output.includes('missing packages') && output.includes('jest'));
-                let passWithNoTests = jestCommand.includes('--passWithNoTests');
-
-                if ((code == 0) ||
-                    ((code == 1) && noTestsFound) ||
-                    ((code == 1) && missingJest && passWithNoTests)) {
-                    await addApp()
-                } else {
-                    console.error('Biz-A Add aborted');
+        const rawRows = response?.data?.data
+        const rows = Array.isArray(rawRows)
+            ? rawRows
+            : (() => {
+                try {
+                    return JSON.parse(rawRows || '[]')
+                } catch {
+                    return []
                 }
-            })
+            })()
+
+        const applicationConfigRow = rows.find((row) => {
+            const name = String(row?.['SYS$CONFIG.NAME'] ?? row?.NAME ?? row?.name ?? '').trim().toUpperCase()
+            return name === 'APPLICATION_CONFIG'
+        })
+        if (!applicationConfigRow) {
+            return ''
         }
 
-        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
-            */
-            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 {
-                            fs.writeFileSync(bundleFolder + fileName, encryptedScript.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)`)
-
-                    // 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 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 })
-                    } else {
-                        console.error(res.data.error)
-                    }
+        const applicationConfig = parseApplicationConfigData(
+            applicationConfigRow?.['SYS$CONFIG.DATA'] ?? applicationConfigRow?.DATA ?? applicationConfigRow?.data
+        )
+        const displayName = applicationConfig?.metadata?.name
+        return (typeof displayName === 'string') ? displayName.trim() : ''
+    } catch {
+        return ''
+    }
+}
+
+async function addApp({
+    workingDir = process.cwd(),
+    verbose = false,
+    server = 'http://localhost',
+    apiPort = 212,
+    dbIndex = 2,
+    sub,
+    files = null,
+    body = null
+} = {}) {
+    const oldCwd = process.cwd()
+
+    /*
+    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
+    */
+    try {
+        process.chdir(path.resolve(workingDir))
+
+        const bundlingStart = performance.now()
+        const rootFolder = './upload/'
+        const bundleName = normalizeAppName(basename(process.cwd()))
+        const bundleFolder = rootFolder + bundleName + '/'
+        const sourceFiles = getFileList({ workingDir: process.cwd(), files })
+        const bodyScripts = normalizeBodyScripts(body)
+        const requestedFiles = normalizeFileList(files)
+        const bodySourceFiles = Array.from(bodyScripts.keys()).filter((fileName) => {
+            const isSupportedFile = fileName.match(/\.js$/) || (fileName === 'menu.json')
+            if (!isSupportedFile) {
+                return false
+            }
+            if (!requestedFiles) {
+                return true
+            }
+            return requestedFiles.some((requested) => path.basename(requested).toLowerCase() === fileName)
+        })
+        const mergedSourceFiles = Array.from(new Set([
+            ...sourceFiles,
+            ...bodySourceFiles
+        ]))
+
+        if (mergedSourceFiles.length > 0) {
+            const keys = await prepareKeys()
+            if (!keys) {
+                const msg = 'Can not prepare encryption keys'
+                console.error(msg)
+                return { success: false, error: msg }
+            }
+
+            let processedFile = 0
+            fs.rmSync(rootFolder, { force: true, recursive: true })
+            fs.mkdirSync(bundleFolder, { recursive: true })
+
+            for (const sourceFile of mergedSourceFiles) {
+                const sourceFilePath = path.isAbsolute(sourceFile) ? sourceFile : path.resolve(process.cwd(), sourceFile)
+                const fileName = path.basename(sourceFile).toLowerCase()
+                const scriptSource = bodyScripts.has(fileName)
+                    ? bodyScripts.get(fileName)
+                    : fs.readFileSync(sourceFilePath).toString()
+                const preparedScript = await prepareScript(fileName, scriptSource, verbose)
+                const encryptedScript = encryptScript(preparedScript, keys.encryptKey)
+                if (fileName == 'menu.json') {
+                    keys.metadata['menu'] = encryptedScript.toString('base64')
                 } else {
-                    console.error('Nothing to upload. Please recheck your app folder.')
+                    fs.writeFileSync(bundleFolder + fileName, encryptedScript.toString('base64'))
                 }
-            } catch (e) {
-                console.error(e.response?.data ? e.response.data : e)
+
+                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 = sub ?
+                `${server}/hub/${baseUrl}?subdomain=${sub}` :
+                `${server}:${apiPort}/${baseUrl}`
+            const headers = { 'Content-Type': 'text/plain' }
+            const appDisplayName = await resolveAppDisplayNameFromApplicationConfig({ server, apiPort, dbIndex, sub })
+            if (appDisplayName.length > 0) {
+                keys.metadata['name'] = appDisplayName
+            }
+            const uploadAppName = normalizeAppName(appDisplayName || bundleName)
+            const param = { _parameters: [dbIndex, uploadAppName, 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 })
+                return { success: true, data: res.data }
+            }
+
+            console.error(res.data.error)
+            return { success: false, error: res.data.error, data: res.data }
+        }
+
+        const msg = 'Nothing to upload. Please recheck your app folder.'
+        console.error(msg)
+        return { success: false, error: msg }
+    } catch (e) {
+        const errMsg = (e.response?.data ? e.response.data : e)
+        console.error(errMsg)
+        return { success: false, error: errMsg }
+    } finally {
+        process.chdir(oldCwd)
+    }
+}
+
+async function runUnitTests(options) {  //SCY BZ 4331
+    return new Promise((resolve) => {
+        let jestCommand = ['--no-install', 'jest', '--json']
+        let output = ''
+
+        const testDir = path.join(options.workingDir, 'test')
+        const workDir = path.resolve(options.workingDir)
+        try {
+            process.chdir(testDir)
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                jestCommand.push('--passWithNoTests')
+            }
+        }
+        process.chdir(workDir)
+
+        const child = process.platform === 'win32'
+            ? spawn('cmd.exe', ['/d', '/s', '/c', 'npx', ...jestCommand])
+            : spawn('npx', jestCommand)
+        const collectOutput = data => {
+            output += data?.toString() || ''
         }
+        child.stderr?.on('data', collectOutput)
+        child.stdout?.on('data', () => { }) // SCY BZ 4363, ref : https://nodejs.org/download/release/v22.19.0/docs/api/child_process.html
+
+        child.on('error', e => {
+            output += e?.message ? `\n${e.message}` : ''
+        })
+
+        child.on('close', async code => {
+            console.log('====================')
+            console.log(output)
+            console.log('====================')
+            const noTestsFound = output.includes('No tests found')
+            const missingJest = (output.includes('missing packages') && output.includes('jest'))
+            const passWithNoTests = jestCommand.includes('--passWithNoTests')
+
+            if ((code == 0) ||
+                ((code == 1) && noTestsFound) ||
+                ((code == 1) && missingJest && passWithNoTests)) {
+                await addApp({
+                    workingDir: workDir,
+                    verbose: options.verbose,
+                    server: options.server,
+                    apiPort: options.apiPort,
+                    dbIndex: options.dbIndex,
+                    sub: options.sub,
+                    files: options.files
+                })
+            } else {
+                console.error('Biz-A Add aborted')
+            }
+            resolve()
+        })
+    })
+}
 
-        await runUnitTests()
+const buildCli = () => 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 (commandOptions) => {
+        await runUnitTests(commandOptions)
     })
-    .command('remove', 'Remove Biz-A Application', removeCommandOptions, (options) => {
-        (async () => {
+    .command('remove', 'Remove Biz-A Application', removeCommandOptions, (commandOptions) => {
+        ; (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 url = commandOptions.sub ?
+                    `${commandOptions.server}/hub/${baseUrl}?subdomain=${commandOptions.sub}` :
+                    `${commandOptions.server}:${commandOptions.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 });
+                const deleteApps = commandOptions.appName.trim().replaceAll(' ', '').toLowerCase()
+                const param = { _parameters: [commandOptions.dbIndex, deleteApps] }
+                const res = await axios.post(url, param, { headers: headers })
                 if (res.data?.success) {
                     if (deleteApps == '') {
                         console.log('All apps removed')
@@ -261,8 +500,9 @@ Object
     .recommendCommands()
     .demandCommand(1, 'You need at least one command before moving on')
     .strict()
-    .parse();
-
-export { options, addCommandOptions, removeCommandOptions }
 
+if (process.env.BIZA_APP_SKIP_PARSE !== '1') {
+    buildCli().parse()
+}
 
+export { options, addCommandOptions, removeCommandOptions, getFileList, addApp }

package/bin/directHubEvent.js

@@ -1,4 +1,4 @@
-import { apiRequestListener, RECONNECT_SOCKET_DELAY } from './hubEvent.js'
+import { clientListener, RECONNECT_SOCKET_DELAY } from './hubEvent.js'
 import { deploymentListenerForVSCode } from './deployEvent.js'
 import { Tunnel as QuickTunnel } from 'cloudflared'
 import { Server as ioServer } from 'socket.io'
@@ -61,7 +61,7 @@ export function directHubEvent(serverSocket, argv){
 
         if (clientSocket.handshake.query.isClient) {
             setConnectListeners(clientSocket);
-            apiRequestListener(clientSocket, argv);
+            clientListener(clientSocket, argv);
             clientSocket.join(CLIENT_ROOM);
         }
         else if (clientSocket.handshake.query.isDeploy) {

package/bin/hub.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = 'production';
@@ -6,9 +6,9 @@ if (!process.env.NODE_ENV) {
 
 import yargs from 'yargs';
 import { io as ioClient } from "socket.io-client";
-import { streamEvent, hubEvent, RECONNECT_SOCKET_DELAY } from './hubEvent.js'
+import { streamEvent, hubEvent, RECONNECT_SOCKET_DELAY, status } from './hubEvent.js'
 import { createLogger, transports, format } from "winston";
-import os from 'node:os'
+import os from 'os';
 import { directHubEvent, localhostTunnel, createSocketServer }from './directHubEvent.js'
 import { env } from "../envs/env.js"
 
@@ -138,7 +138,7 @@ app.use('/cb', (req, res)=>{
 });
 
 app.use('/status', (req, res)=>{
-    res.status(200).json(argv.cliAddress());
+    res.status(200).json(status(argv));
 });
 
 // create HTTP(s) Server
@@ -150,8 +150,8 @@ const getProtocol = ()=>(isHttps ? 'Https://' : 'Http://')
 let server = isHttps ? https.createServer({key: fs.readFileSync(keyFile), cert: fs.readFileSync(certFile), ca: fs.readFileSync(rootFile),}, app) : http.createServer(app)
 argv.cliAddress = ()=>{
     const ip = Object.values(os.networkInterfaces()).flat().reduce((ip, {family, address, internal})=> ip || !internal && family==='IPv4' && address, undefined)
-    return {ip, port: argv.serverport, address: `${ip}:${argv.serverport}`, publicUrl: argv.connectedPublicUrl, hubUrl: argv.connectedHubUrl}
-}
+    return {ip, port: argv.serverport, address: `${ip}:${argv.serverport}`, publicUrl: argv.connectedPublicUrl, hubUrl: argv.connectedHubUrl};
+};
 server.listen(argv.serverport, () => {
     const info = argv.cliAddress()
     console.log(`${new Date()}: CLI is listening at ${getProtocol() + (process.env.HOST || info.ip || 'localhost')}:${info.port} `);