tnp-helpers 19.0.44 → 19.0.46

package/lib/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UtilsZip = exports.UtilsZipBrowser = exports.UtilsDotFile = exports.UtilsVSCode = exports.UtilsQuickFixes = exports.UtilsMd = exports.UtilsHttp = exports.UtilsTypescript = exports.UtilsNpm = void 0;
+exports.UtilsJava = exports.UtilsTaonWorker = exports.UtilsZip = exports.UtilsZipBrowser = exports.UtilsDotFile = exports.UtilsVSCode = exports.UtilsQuickFixes = exports.UtilsMd = exports.UtilsHttp = exports.UtilsTypescript = exports.UtilsNpm = void 0;
 //#region imports
 const lib_1 = require("tnp-config/lib");
 const lib_2 = require("tnp-core/lib");
@@ -1255,7 +1255,7 @@ var UtilsDotFile;
     };
     //#endregion
     //#region set value to/from dot file
-    UtilsDotFile.setValueToDotFile = (dotFileAbsPath, value, key) => {
+    UtilsDotFile.setValueToDotFile = (dotFileAbsPath, key, value) => {
         //#region @backendFunc
         dotFileAbsPath = (0, lib_2.crossPlatformPath)(dotFileAbsPath);
         let envContent = '';
@@ -1285,6 +1285,37 @@ var UtilsDotFile;
         //#endregion
     };
     //#endregion
+    //#region set comment to key in dot file
+    UtilsDotFile.setCommentToKeyInDotFile = (dotFileAbsPath, key, comment) => {
+        //#region @backendFunc
+        dotFileAbsPath = (0, lib_2.crossPlatformPath)(dotFileAbsPath);
+        let envContent = '';
+        if (lib_2.fse.existsSync(dotFileAbsPath)) {
+            envContent = index_1.Helpers.readFile(dotFileAbsPath, '');
+        }
+        else {
+            index_1.Helpers.writeFile(dotFileAbsPath, '');
+            index_1.Helpers.logInfo(`[${lib_1.config.frameworkName}-helpers] Created ${lib_2.path.basename(dotFileAbsPath)}`);
+            envContent = '';
+        }
+        // Regex: match line starting with "KEY=" and capture value part
+        const regex = new RegExp(`^(${key}=[^#\\n]*)(?:#.*)?$`, 'm');
+        if (regex.test(envContent)) {
+            // Replace existing comment (strip old, append new)
+            envContent = envContent.replace(regex, `$1 # ${comment}`);
+        }
+        else {
+            // Append as new entry with empty value but with comment
+            if (envContent.length > 0 && !envContent.endsWith('\n')) {
+                envContent += '\n';
+            }
+            envContent += `${key}= # ${comment}\n`;
+        }
+        index_1.Helpers.writeFile(dotFileAbsPath, envContent);
+        index_1.Helpers.info(`[${lib_1.config.frameworkName}-helpers] Updated comment for ${key} in ${lib_2.path.basename(dotFileAbsPath)}`);
+        //#endregion
+    };
+    //#endregion
     //#region get value from dot file
     UtilsDotFile.getValueFromDotFile = (dotFileAbsPath, key) => {
         //#region @backendFunc
@@ -1356,6 +1387,74 @@ var UtilsDotFile;
         //#endregion
     };
     //#endregion
+    //#region get comments keys as json object
+    /**
+     * @returns key|comment pairs as json object
+     */
+    UtilsDotFile.getCommentsKeysAsJsonObject = (dotFileAbsPath) => {
+        //#region @backendFunc
+        dotFileAbsPath = (0, lib_2.crossPlatformPath)(dotFileAbsPath);
+        if (!index_1.Helpers.exists(dotFileAbsPath)) {
+            return {};
+        }
+        const envContent = index_1.Helpers.readFile(dotFileAbsPath, '');
+        const result = {};
+        const lines = envContent.split(/\r?\n/);
+        const extractInlineComment = (valuePart) => {
+            // Find the first unquoted `#`
+            let inSingle = false;
+            let inDouble = false;
+            let escaped = false;
+            for (let i = 0; i < valuePart.length; i++) {
+                const ch = valuePart[i];
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (ch === '\\') {
+                    escaped = true;
+                    continue;
+                }
+                if (!inDouble && ch === "'") {
+                    inSingle = !inSingle;
+                    continue;
+                }
+                if (!inSingle && ch === '"') {
+                    inDouble = !inDouble;
+                    continue;
+                }
+                if (!inSingle && !inDouble && ch === '#') {
+                    // Everything after '#' is the comment
+                    const raw = valuePart.slice(i + 1);
+                    const comment = raw.replace(/^\s+/, ''); // trim only leading spaces after '#'
+                    return comment.length ? comment : '';
+                }
+            }
+            return undefined;
+        };
+        for (const line of lines) {
+            const raw = line;
+            const trimmed = raw.trim();
+            // Skip empty or full-line comments
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            // Support optional leading `export `
+            const withoutExport = trimmed.startsWith('export ')
+                ? trimmed.slice('export '.length).trim()
+                : trimmed;
+            const eqIdx = withoutExport.indexOf('=');
+            if (eqIdx === -1)
+                continue;
+            const key = withoutExport.slice(0, eqIdx).trim();
+            if (!key)
+                continue;
+            const valuePart = withoutExport.slice(eqIdx + 1);
+            result[key] = extractInlineComment(valuePart);
+        }
+        return result;
+        //#endregion
+    };
+    //#endregion
 })(UtilsDotFile || (exports.UtilsDotFile = UtilsDotFile = {}));
 //#endregion
 //#region utils zip browser
@@ -1504,11 +1603,28 @@ var UtilsZip;
         //#endregion
     };
     //#endregion
-    UtilsZip.zipDir = async (absPathToDir) => {
+    /**
+     * @returns absolute path to zip file
+     */
+    UtilsZip.zipDir = async (absPathToDir, options) => {
         //#region @backendFunc
+        const zipPath = `${absPathToDir}.zip`;
+        const destinationFileName = (0, lib_2.crossPlatformPath)([
+            lib_2.path.dirname(absPathToDir),
+            zipPath,
+        ]);
+        if (options.overrideIfZipFileExists) {
+            try {
+                index_1.Helpers.removeFileIfExists(destinationFileName);
+            }
+            catch (error) { }
+        }
+        if (index_1.Helpers.exists(destinationFileName)) {
+            index_1.Helpers.info(`[${lib_1.config.frameworkName}-helpers] Zip file already exists: ${destinationFileName}`);
+            return destinationFileName;
+        }
         const yazl = await Promise.resolve().then(() => require('yazl')); // Use default import for yazl
         const pipeline = (await Promise.resolve().then(() => require('stream/promises'))).pipeline;
-        const zipPath = `${absPathToDir}.zip`;
         const zipfile = new yazl.ZipFile();
         const addDirectoryToZip = async (dir, basePath) => {
             const entries = await lib_2.fse.promises.readdir(dir, { withFileTypes: true });
@@ -1526,6 +1642,7 @@ var UtilsZip;
         await addDirectoryToZip(absPathToDir, absPathToDir);
         zipfile.end();
         await pipeline(zipfile.outputStream, lib_2.fse.createWriteStream(zipPath));
+        return destinationFileName;
         //#endregion;
     };
     // Unzip: `/some/path/folder.zip` → `/some/path/folder`
@@ -1566,4 +1683,359 @@ var UtilsZip;
     };
 })(UtilsZip || (exports.UtilsZip = UtilsZip = {}));
 //#endregion
+//#region utils worker
+var UtilsTaonWorker;
+(function (UtilsTaonWorker) {
+    UtilsTaonWorker.getUniqueForTask = (task, location) => {
+        if (!location) {
+            throw new Error('[UtilsTaonWorker.getUniqueForTask()] Location must be provided');
+        }
+        if (!task) {
+            throw new Error('[UtilsTaonWorker.getUniqueForTask()] Task must be provided');
+        }
+        location = (0, lib_2.crossPlatformPath)(location);
+        return `task(${task?.trim()}) in ${location}`?.trim();
+    };
+})(UtilsTaonWorker || (exports.UtilsTaonWorker = UtilsTaonWorker = {}));
+//#endregion
+//#region utils java
+var UtilsJava;
+(function (UtilsJava) {
+    //#region select jdk version
+    UtilsJava.selectJdkVersion = async () => {
+        //#region @backendFunc
+        index_1.Helpers.taskStarted(`Looking for JDK versions...`);
+        const platform = lib_2.os.platform();
+        let currentJava = '';
+        let currentJavaLocation = '';
+        try {
+            currentJava = lib_2.child_process
+                .execSync('java -version 2>&1')
+                .toString()
+                .split('\n')[0];
+            currentJavaLocation = lib_2.child_process
+                .execSync('which java')
+                .toString()
+                .trim();
+        }
+        catch {
+            currentJava = '-- no selected --';
+            currentJavaLocation = '--';
+        }
+        console.log(`\nCURRENT JAVA GLOBAL VERSION: ${currentJava}`);
+        if (currentJavaLocation !== '--') {
+            console.log(`FROM: ${currentJavaLocation}\n`);
+        }
+        let javaVersions = [];
+        if (platform === 'darwin') {
+            try {
+                const result = lib_2.child_process
+                    .execSync('/usr/libexec/java_home -V 2>&1')
+                    .toString()
+                    .split('\n')
+                    .filter(l => l.includes('/Library/Java/JavaVirtualMachines'))
+                    .map(l => {
+                    const match = l.match(/(\/Library\/.*?\/Contents\/Home)/);
+                    if (match) {
+                        const version = l.match(/(?:jdk-|JDK )([\d._]+)/)?.[1] ?? 'unknown';
+                        return { version, path: match[1] };
+                    }
+                })
+                    .filter(Boolean);
+                javaVersions.push(...result);
+            }
+            catch {
+                console.warn('No versions found via /usr/libexec/java_home');
+            }
+            // ✅ Extra fallback for Homebrew + Corretto
+            const fallbackDirs = [
+                '/Library/Java/JavaVirtualMachines',
+                '/usr/local/Cellar',
+                '/opt/homebrew/Cellar',
+            ];
+            for (const baseDir of fallbackDirs) {
+                try {
+                    const dirs = lib_2.fse.readdirSync(baseDir, { withFileTypes: true });
+                    for (const dir of dirs) {
+                        if (dir.isDirectory() && /(jdk|corretto|openjdk)/i.test(dir.name)) {
+                            // Cellar layout: .../openjdk@21/<version>/libexec/openjdk.jdk/Contents/Home
+                            const homePath = baseDir.includes('Cellar')
+                                ? lib_2.path.join(baseDir, dir.name, lib_2.fse.readdirSync(lib_2.path.join(baseDir, dir.name))[0], 'libexec', 'openjdk.jdk', 'Contents', 'Home')
+                                : lib_2.path.join(baseDir, dir.name, 'Contents', 'Home');
+                            javaVersions.push({
+                                version: UtilsJava.detectJavaVersionMacOS(homePath),
+                                path: homePath,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        else if (platform === 'linux') {
+            const knownPaths = ['/usr/lib/jvm', '/usr/java', '/opt/java', '/opt/jdk'];
+            for (const basePath of knownPaths) {
+                try {
+                    const dirs = lib_2.fse.readdirSync(basePath, { withFileTypes: true });
+                    for (const dir of dirs) {
+                        if (dir.isDirectory() && /(jdk|java|corretto)/i.test(dir.name)) {
+                            const versionMatch = dir.name.match(/(\d+(?:\.\d+)+)/);
+                            javaVersions.push({
+                                version: versionMatch?.[1] ?? dir.name,
+                                path: lib_2.path.join(basePath, dir.name),
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        else if (platform === 'win32') {
+            try {
+                const output = lib_2.child_process.execSync('reg query "HKLM\\SOFTWARE\\JavaSoft\\Java Development Kit"', { encoding: 'utf8' });
+                const lines = output
+                    .split('\n')
+                    .filter(line => line.includes('JavaSoft\\Java Development Kit'));
+                for (const line of lines) {
+                    const version = line.trim().split('\\').pop();
+                    const pathOutput = lib_2.child_process.execSync(`reg query "${line.trim()}" /v JavaHome`, {
+                        encoding: 'utf8',
+                    });
+                    const match = pathOutput.match(/JavaHome\s+REG_SZ\s+(.+)/);
+                    if (match) {
+                        javaVersions.push({
+                            version,
+                            path: match[1].trim(),
+                        });
+                    }
+                }
+            }
+            catch {
+                // Ignore registry failure
+            }
+            // Fallback dirs
+            const fallbackDirs = [
+                'C:\\Program Files\\Amazon Corretto',
+                'C:\\Program Files\\Java',
+                'C:\\Program Files\\Eclipse Adoptium',
+                'C:\\Program Files\\Zulu',
+                'C:\\Java',
+            ];
+            for (const baseDir of fallbackDirs) {
+                try {
+                    const subdirs = lib_2.fse.readdirSync(baseDir, { withFileTypes: true });
+                    for (const dir of subdirs) {
+                        if (dir.isDirectory() &&
+                            /(jdk|corretto|zulu|temurin)/i.test(dir.name)) {
+                            const versionMatch = dir.name.match(/(\d+(?:\.\d+)+)/);
+                            javaVersions.push({
+                                version: versionMatch?.[1] ?? dir.name,
+                                path: lib_2.path.join(baseDir, dir.name),
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        javaVersions = javaVersions
+            .filter(j => j.version !== 'unknown') // drop unknowns
+            .filter((j, index, self) => index ===
+            self.findIndex(other => lib_2.path.resolve(other.path) === lib_2.path.resolve(j.path)));
+        if (javaVersions.length === 0) {
+            console.log('❌ No installed Java versions found.');
+            return;
+        }
+        const selected = await lib_2.UtilsTerminal.select({
+            question: 'Select Java version for global usage:',
+            choices: javaVersions.map(j => ({
+                name: `${j.version}  —  ${j.path}`,
+                value: j,
+            })),
+        });
+        return selected.path;
+        //#endregion
+    };
+    //#endregion
+    UtilsJava.detectJavaVersionMacOS = (javaHome) => {
+        //#region @backendFunc
+        try {
+            // 1. Try to read "release" file shipped with every JDK
+            const releaseFile = lib_2.path.join(javaHome, 'release');
+            if (lib_2.fse.existsSync(releaseFile)) {
+                const content = lib_2.fse.readFileSync(releaseFile, 'utf8');
+                const match = content.match(/JAVA_VERSION="([^"]+)"/);
+                if (match) {
+                    return match[1];
+                }
+            }
+            // 2. Try folder name (amazon-corretto-21.jdk → 21, valhalla-ea-23 → 23)
+            const folder = lib_2.path.basename(javaHome);
+            const matchFolder = folder.match(/(\d+(?:\.\d+)?)/);
+            if (matchFolder) {
+                return matchFolder[1];
+            }
+            return folder; // fallback: show folder name
+        }
+        catch {
+            return 'unknown';
+        }
+        //#endregion
+    };
+    //#region update java home path
+    UtilsJava.updateJavaHomePath = (selectedPath) => {
+        //#region @backendFunc
+        const platform = lib_2.os.platform();
+        if (platform === 'darwin') {
+            try {
+                const shellPath = lib_2.path.resolve(lib_2.UtilsOs.getRealHomeDir(), '.zshrc'); // or .bash_profile
+                lib_2.child_process.execSync(`export JAVA_HOME="${selectedPath}"`);
+                console.log(`✅ JAVA_HOME set to ${selectedPath} (only in current session).`);
+                console.log(`To make permanent, add to your shell profile:\n\nexport JAVA_HOME="${selectedPath}"\n`);
+            }
+            catch (err) {
+                console.error('❌ Failed to set JAVA_HOME on macOS.');
+            }
+        }
+        else if (platform === 'linux') {
+            try {
+                lib_2.child_process.execSync(`export JAVA_HOME="${selectedPath}"`);
+                lib_2.child_process.execSync(`sudo update-alternatives --set java "${selectedPath}/bin/java"`);
+                console.log(`✅ Set global Java to ${selectedPath}`);
+            }
+            catch {
+                console.log(`⚠️ Could not update alternatives. Try manually:\nexport JAVA_HOME="${selectedPath}"`);
+            }
+        }
+        else if (platform === 'win32') {
+            try {
+                lib_2.child_process.execSync(`setx JAVA_HOME "${selectedPath}"`);
+                console.log(`✅ JAVA_HOME set globally to ${selectedPath}`);
+                console.log(`⚠️ Restart your terminal or computer to apply changes.`);
+            }
+            catch {
+                console.error('❌ Failed to set JAVA_HOME on Windows.');
+            }
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region api methods / selectTomcatVersion
+    UtilsJava.selectTomcatVersion = async () => {
+        //#region @backendFunc
+        const platform = lib_2.os.platform();
+        let currentTomcat = process.env.TOMCAT_HOME || '';
+        let tomcatVersions = [];
+        console.log('\n🔍 Searching for installed Tomcat versions...');
+        if (currentTomcat) {
+            console.log(`CURRENT TOMCAT_HOME: ${currentTomcat}\n`);
+        }
+        if (platform === 'darwin' || platform === 'linux') {
+            // Extended search directories for macOS/Linux
+            const searchDirs = [
+                '/usr/local', // will check for tomcat* here
+                '/opt',
+                '/usr/share',
+                (0, lib_2.crossPlatformPath)([lib_2.UtilsOs.getRealHomeDir(), 'tomcat']),
+            ];
+            for (const base of searchDirs) {
+                try {
+                    if (!lib_2.fse.existsSync(base))
+                        continue;
+                    const subdirs = lib_2.fse.readdirSync(base, { withFileTypes: true });
+                    for (const sub of subdirs) {
+                        if (sub.isDirectory() &&
+                            sub.name.toLowerCase().includes('tomcat')) {
+                            const foundPath = lib_2.path.join(base, sub.name);
+                            const versionGuess = sub.name.match(/(\d+\.\d+\.\d+)/)?.[1] || sub.name;
+                            tomcatVersions.push({
+                                version: versionGuess,
+                                path: foundPath,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // ignore errors
+                }
+            }
+        }
+        else if (platform === 'win32') {
+            const fallbackDirs = [
+                'C:\\Program Files\\Apache Software Foundation',
+                'C:\\Tomcat',
+            ];
+            for (const baseDir of fallbackDirs) {
+                try {
+                    if (!lib_2.fse.existsSync(baseDir))
+                        continue;
+                    const subdirs = lib_2.fse.readdirSync(baseDir, { withFileTypes: true });
+                    for (const dir of subdirs) {
+                        if (dir.isDirectory() &&
+                            dir.name.toLowerCase().includes('tomcat')) {
+                            const foundPath = lib_2.path.join(baseDir, dir.name);
+                            const versionGuess = dir.name.match(/(\d+\.\d+\.\d+)/)?.[1] || dir.name;
+                            tomcatVersions.push({
+                                version: versionGuess,
+                                path: foundPath,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        if (tomcatVersions.length === 0) {
+            console.log('❌ No Tomcat installations found.');
+            return;
+        }
+        const selected = await lib_2.UtilsTerminal.select({
+            question: 'Select Tomcat installation for global usage:',
+            choices: tomcatVersions.map(t => ({
+                name: `Tomcat ${t.version} — ${t.path}`,
+                value: t,
+            })),
+        });
+        const selectedPath = selected.path;
+        return selectedPath;
+        //#endregion
+    };
+    //#endregion
+    //#region update tomcat home path
+    UtilsJava.updateTomcatHomePath = (selectedPath) => {
+        //#region @backendFunc
+        const platform = lib_2.os.platform();
+        if (platform === 'darwin' || platform === 'linux') {
+            try {
+                lib_2.child_process.execSync(`export TOMCAT_HOME="${selectedPath}"`);
+                console.log(`✅ TOMCAT_HOME set to ${selectedPath} (current session only).`);
+                console.log(`To make permanent, add to your ~/.zshrc or ~/.bashrc:\n\nexport TOMCAT_HOME="${selectedPath}"\n`);
+            }
+            catch {
+                console.error('❌ Failed to set TOMCAT_HOME.');
+            }
+        }
+        else if (platform === 'win32') {
+            try {
+                lib_2.child_process.execSync(`setx TOMCAT_HOME "${selectedPath}"`);
+                console.log(`✅ TOMCAT_HOME set globally to ${selectedPath}`);
+                console.log(`⚠️ Restart your terminal or computer to apply changes.`);
+            }
+            catch {
+                console.error('❌ Failed to set TOMCAT_HOME on Windows.');
+            }
+        }
+        //#endregion
+    };
+    //#endregion
+})(UtilsJava || (exports.UtilsJava = UtilsJava = {}));
+//#endregion
 //# sourceMappingURL=utils.js.map