@maka/maka-cli 5.3.1 → 5.3.2

package/bundle/typescript/src/tools/fsi/fsi.class.js

@@ -0,0 +1,687 @@
+import path from 'path';
+import net from 'net';
+import tar from '@maka/tar';
+import fs from 'fs';
+import os from 'os';
+import { rimrafSync } from 'rimraf';
+import { exec } from 'child_process';
+import latestVersion from 'latest-version';
+import semver from 'semver';
+import { promises as fsPromises } from 'fs';
+import { Log } from '../log/log.class.js';
+import { Actions } from '../actions/actions.class.js';
+import { Progress } from '../progress/progress.class.js';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pjson = require('../../../package.json');
+// const pjson = {
+//   version: '5.1.23'
+// }
+const PROJECT_CONFIG = 'config.json';
+const GLOBAL_CACHE = 'cache.json';
+const homeDir = os.homedir();
+const errorHandler = (caller, error) => {
+    if (process.env['MAKA_DEV'] === 'True') {
+        Log.error(`Error in ${caller}`);
+    }
+    if (error) {
+        console.error(error);
+    }
+};
+export class FSI {
+    static instance;
+    constructor() {
+    }
+    // Static method to get the singleton instance
+    static getInstance() {
+        if (!FSI.instance) {
+            FSI.instance = new FSI();
+        }
+        return FSI.instance;
+    }
+    getUserDataDirectory() {
+        return path.join(homeDir);
+    }
+    getMeteorInstallPath() {
+        return path.join(homeDir, '.meteor');
+    }
+    meteorCommand() {
+        const isWin = process.platform === 'win32';
+        return path.join(this.getMeteorInstallPath(), isWin ? 'meteor.bat' : 'meteor');
+    }
+    // Gets a list of all directories in the given path.
+    getDirectories(dirPath) {
+        try {
+            return fs.readdirSync(dirPath).filter((file) => {
+                return fs.statSync(path.join(dirPath, file)).isDirectory();
+            });
+        }
+        catch (e) {
+            errorHandler('getDirectories()', e);
+            process.exit(1);
+        }
+    }
+    /**
+     * Create a file at the given filePath and write the given data
+     * to the file. Recursively creates the directory structure if
+     * needed.
+     */
+    async createFile({ filePath, data, opts }) {
+        const pathDisplay = (opts?.absolute)
+            ? path.join(process.cwd(), filePath)
+            : path.relative(process.cwd(), filePath);
+        try {
+            const pathParts = path.normalize(filePath).split(path.sep);
+            pathParts.pop();
+            const dirPath = pathParts.join(path.sep);
+            const shouldCreateDir = !this.isDirectory(dirPath);
+            if (shouldCreateDir) {
+                await this.createDirectory({ dirPath, force: opts?.force, silent: opts?.silent });
+            }
+            // if the file exists let's confirm with the user if we
+            // should override it
+            if (this.isFile(filePath) && !opts?.force) {
+                const overwrite = await Actions.confirm(filePath + ' already exists. Do you want to overwrite it?');
+                if (!overwrite) {
+                    if (opts?.ignore) {
+                        return;
+                    }
+                    else {
+                        throw Object.assign(new Error('File not written'), { msg: 'File not written', level: 'info', verbose: true });
+                    }
+                }
+                else {
+                    await fsPromises.unlink(filePath);
+                }
+            }
+            if (opts?.isImage) {
+                const buffer = Buffer.from(data, 'base64');
+                await fsPromises.writeFile(filePath, buffer);
+            }
+            else {
+                await fsPromises.writeFile(filePath, data);
+            }
+            if (!opts?.silent) {
+                Log.bright(` created file ${pathDisplay}`);
+            }
+        }
+        catch (e) {
+            if (e?.verbose) {
+                if (e.level === 'info') {
+                    Log.error(e.msg);
+                }
+                else {
+                    errorHandler('createFile()', e.msg);
+                }
+            }
+            else {
+                errorHandler('createFile()', e);
+            }
+        }
+    }
+    getFiles(dirPath, opts) {
+        try {
+            const files = fs.readdirSync(dirPath).filter((file) => {
+                const filePath = path.join(dirPath, file);
+                // If the file is a directory, it's not a match.
+                if (this.isDirectory(filePath))
+                    return false;
+                // Check against omitted files.
+                if (opts?.omit) {
+                    const omitPatterns = Array.isArray(opts.omit) ? opts.omit : [opts.omit];
+                    for (const pattern of omitPatterns) {
+                        if (file.includes(pattern))
+                            return false;
+                    }
+                }
+                if (opts?.extensions) {
+                    const ext = path.extname(filePath);
+                    // If the file has no extension, it's not a match.
+                    if (!ext)
+                        return false;
+                    // If the file extension is not in the list of extensions, it's not a match.
+                    if (!opts.extensions.includes(ext.replace('.', '')))
+                        return false;
+                    return true;
+                }
+                // If no extension filter is provided, include all files that aren't directories or in the omit list.
+                return true;
+            });
+            return files;
+        }
+        catch (e) {
+            errorHandler('getFiles()', e);
+            process.exit(1);
+        }
+    }
+    mkKeysDir({ configPath }) {
+        if (!this.isDirectory(configPath)) {
+            throw new Error('Invalid directory');
+        }
+        const keyDir = path.join(configPath, '_keys');
+        try {
+            fs.statSync(keyDir);
+        }
+        catch (e) {
+            Log.warn(e.message);
+            fs.mkdirSync(keyDir, { recursive: true });
+        }
+        return keyDir;
+    }
+    /**
+     * Create a file at the given filePath and write the given data
+     * to the file. Recursively creates the directory structure if
+     * needed.
+     */
+    writeToFile({ filePath, data, opts }) {
+        const pathDisplay = (opts?.absolute) ? path.join(process.cwd(), filePath) : path.relative(process.cwd(), filePath);
+        try {
+            if (this.isDirectory(filePath)) {
+                throw new Error('Cannot write data to a directory');
+            }
+            fs.writeFileSync(filePath, data);
+            if (!opts?.silent) {
+                Log.bright(`Updated file ${pathDisplay}`);
+            }
+        }
+        catch (e) {
+            errorHandler('writeToFile()', e);
+        }
+    }
+    /**
+     * Recursively creates a directory structure from the given
+     * dirpath.
+     */
+    async createDirectory({ dirPath, force, silent }) {
+        if (!dirPath) {
+            throw new Error('No directory path provided');
+        }
+        try {
+            if (force) {
+                rimrafSync(dirPath);
+            }
+            if (this.isFile(dirPath)) {
+                throw new Error('File exists at that location');
+            }
+            const exists = this.isDirectory(dirPath);
+            if (!exists) {
+                fs.mkdirSync(dirPath, { recursive: true });
+                // double check we exist now
+                if (!this.isDirectory(dirPath)) {
+                    throw new Error(`Uh-oh, the directory is not a directory ${dirPath}`);
+                }
+                if (!silent) {
+                    Log.success(`Created ${path.relative(process.cwd(), dirPath)}`);
+                }
+            }
+        }
+        catch (e) {
+            errorHandler('createDirectory()', e);
+        }
+    }
+    /**
+     * Given a startPath or process.cwd() search upwards calling the predicate
+     * function for each directory. If the predication function returns true,
+     * return the current path, otherwise keep searching up until we can't go
+     * any further. Returns undefined if no directory is found.
+     *
+     */
+    findDirectoryUp({ predicate, startPath }) {
+        try {
+            let testDir = startPath || process.cwd();
+            while (testDir) {
+                if (predicate(testDir)) {
+                    break;
+                }
+                const newDir = path.dirname(testDir);
+                if (newDir === testDir) {
+                    testDir = undefined;
+                }
+                else {
+                    testDir = newDir;
+                }
+            }
+            return testDir;
+        }
+        catch (e) {
+            errorHandler('findDirectoryUp()', e);
+            process.exit(1);
+        }
+    }
+    /**
+     * Given a starting filePath (process.cwd by default) returns the
+     * absolute path to the root of the project directory, which contains
+     * the .maka folder.
+     */
+    findProjectDirectory(filePath = process.cwd()) {
+        try {
+            const directoryUp = this.findDirectoryUp({
+                predicate: (curpath) => {
+                    return this.isFile(path.join(curpath, '.maka', PROJECT_CONFIG));
+                },
+                startPath: filePath || process.cwd()
+            });
+            if (!directoryUp) {
+                return '';
+            }
+            return directoryUp;
+        }
+        catch (e) {
+            errorHandler('findProjectDirectory()', e);
+            process.exit(1);
+        }
+    }
+    /**
+     * Given a starting filePath, returns the absolute path to
+     * the app directory of the project. If there is no project
+     * it returns an empty string.
+     */
+    findAppDirectory(filePath = process.cwd()) {
+        try {
+            const projectDirectory = this.findProjectDirectory(filePath);
+            return (projectDirectory && typeof projectDirectory === 'string') ? path.join(projectDirectory, 'app') : '';
+        }
+        catch (e) {
+            errorHandler('findAppDirectory()', e);
+            process.exit(1);
+        }
+    }
+    /**
+     * Returns the absolute path to the given filePath relative to the project
+     * directory (e.g. my-project/filePath). Returns an empty string if no path is found.
+     */
+    pathFromProject({ pathParts }) {
+        try {
+            const filePath = pathParts?.join(path.sep);
+            const projectDirectory = this.findProjectDirectory();
+            return (projectDirectory && typeof projectDirectory === 'string') ? path.join(projectDirectory, filePath || '') : '';
+        }
+        catch (e) {
+            errorHandler('pathFromProject()', e);
+            process.exit(1);
+        }
+    }
+    /**
+     * Returns true if the filePath is a file.
+     */
+    isFile(filePath) {
+        try {
+            // Resolve the filePath to expand ~ to the absolute path
+            const resolvedPath = path.resolve(filePath);
+            const stats = fs.statSync(resolvedPath);
+            return stats.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Returns true if the dirpath is a directory.
+     */
+    isDirectory(dirPath) {
+        try {
+            const stats = fs.statSync(dirPath);
+            return stats.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Given a file return an array of each line in the file.
+     */
+    readFileLines(filePath) {
+        try {
+            const raw = fs.readFileSync(filePath, 'utf8');
+            const lines = raw.split(/\r*\n\r*/);
+            while (lines.length) {
+                const line = lines[lines.length - 1];
+                if (line.match(/\S/))
+                    break;
+                lines.pop();
+            }
+            return lines;
+        }
+        catch (e) {
+            errorHandler('readFileLines()', e);
+            process.exit(1);
+        }
+    }
+    /**
+     * Retrieve the current projects meteor version (opposed to the global)
+     */
+    getProjectMeteorVersion() {
+        try {
+            const meteorReleaseFile = this.pathFromProject({ pathParts: ['app', '.meteor', 'release'] });
+            const meteorReleaseVersion = fs.readFileSync(meteorReleaseFile, 'utf8');
+            let customReleaseMessage = meteorReleaseVersion.replace('METEOR@', '').replace('\n', '');
+            const semVerNumberCount = customReleaseMessage.split(".").length;
+            if (semVerNumberCount < 3) {
+                customReleaseMessage = customReleaseMessage + '.0';
+            }
+            return customReleaseMessage;
+        }
+        catch (e) {
+            errorHandler('getProjectMeteorVersion()', e);
+            process.exit(1);
+        }
+    }
+    /**
+     * Retrieve the current projects meter node version (opposed to the global)
+     */
+    async getProjectsMeteorNodeVersion() {
+        try {
+            const meteorNodeReleaseFile = this.pathFromProject({ pathParts: ['app', '.meteor', 'local', 'build', '.node_version.txt'] });
+            if (!this.isFile(meteorNodeReleaseFile)) {
+                return 'N/A';
+            }
+            else {
+                const meteorNodeReleaseFile = this.pathFromProject({ pathParts: ['app', '.meteor', 'local', 'build', '.node_version.txt'] });
+                const meteorNodeReleaseVersion = fs.readFileSync(meteorNodeReleaseFile, 'utf8');
+                const customReleaseMessage = meteorNodeReleaseVersion.replace('v', '').replace('\n', '');
+                return customReleaseMessage;
+            }
+        }
+        catch (e) {
+            errorHandler('getProjectsMeteorNodeVersion()', e);
+            process.exit(1);
+        }
+    }
+    /**
+     * Gets latest version of Maka on NPM
+     */
+    async getLatestMakaVersion() {
+        const makaLatest = await latestVersion('@maka/maka-cli');
+        return makaLatest;
+    }
+    /**
+     * Compares and warns if maka is outdates
+     */
+    async compareMakaToLatest() {
+        const makaLatest = await this.getLatestMakaVersion();
+        if (semver.gt(makaLatest, pjson.version)) {
+            Log.warn(`Latest version of maka-cli is ${makaLatest}`);
+            Log.warn(`Please update with:
+
+          npm i -g @maka/maka-cli@latest
+
+      `);
+        }
+        return;
+    }
+    /**
+     * Returns an array of all directory entries recursively.
+     */
+    directoryEntries(srcPath) {
+        try {
+            let entries = [];
+            const directEntries = fs.readdirSync(srcPath);
+            for (const entry of directEntries) {
+                const fullEntryPath = path.join(srcPath, entry);
+                entries.push(fullEntryPath);
+                if (this.isDirectory(fullEntryPath)) {
+                    entries = entries.concat(this.directoryEntries(fullEntryPath));
+                }
+            }
+            return entries;
+        }
+        catch (e) {
+            errorHandler('directoryEntries()', e);
+            process.exit(1);
+        }
+    }
+    isMakaProject() {
+        const isMakaProject = this.findProjectDirectory();
+        return (isMakaProject !== '') ? true : false;
+    }
+    grep(iString, pattern) {
+        try {
+            const regexPatternToSearch = new RegExp("^.*(" + pattern + ").*$", "mg");
+            const grepMatch = iString.match(regexPatternToSearch);
+            return grepMatch || [];
+        }
+        catch (e) {
+            errorHandler('grep()', e);
+            process.exit(1);
+        }
+    }
+    async fileContainsString(filePath, searchString) {
+        try {
+            if (fs.existsSync(filePath) === false) {
+                return false;
+            }
+            const fileContent = await fs.promises.readFile(filePath, 'utf8');
+            return fileContent.includes(searchString);
+        }
+        catch (error) {
+            console.error(`Error reading file: ${error}`);
+            throw error;
+        }
+    }
+    getCachedResult(command) {
+        const cacheFilePath = path.join(this.getMeteorInstallPath(), '.maka', GLOBAL_CACHE);
+        try {
+            const cache = JSON.parse(fs.readFileSync(cacheFilePath, 'utf-8'));
+            return cache[command] || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    cacheResult(command, result) {
+        const cacheFilePath = path.join(this.getMeteorInstallPath(), '.maka', GLOBAL_CACHE);
+        try {
+            const cache = JSON.parse(fs.readFileSync(cacheFilePath, 'utf-8'));
+            cache[command] = result;
+            fs.writeFileSync(cacheFilePath, JSON.stringify(cache));
+        }
+        catch {
+            const cache = { [command]: result };
+            fs.writeFileSync(cacheFilePath, JSON.stringify(cache));
+        }
+    }
+    getGlobalMakaDir() {
+        return path.join(this.getMeteorInstallPath(), '.maka');
+    }
+    async saveInit(config, filePath) {
+        try {
+            const jsonBack = JSON.stringify(config, null, 2);
+            await this.createFile({ filePath, data: jsonBack, opts: { force: true } });
+        }
+        catch (e) {
+            errorHandler('saveInit()', e);
+            process.exit(1);
+        }
+    }
+    deepen(obj) {
+        const result = {};
+        // For each object path (property key) in the object
+        for (const objectPath in obj) {
+            // Split path into component parts
+            const parts = objectPath.split('.');
+            // Create sub-objects along path as needed
+            let target = result;
+            while (parts?.length > 1) {
+                const part = parts?.shift();
+                if (part) {
+                    target = target[part] = target[part] || {};
+                }
+            }
+            // Set value at end of path
+            target[parts[0]] = obj[objectPath];
+        }
+        return result;
+    }
+    deeperAssign(a, b) {
+        Object
+            .entries(b)
+            .forEach(([k, v]) => a[k] = v && typeof v === 'object'
+            ? this.deeperAssign(a[k] = a[k] || {}, v)
+            : v);
+        return a;
+    }
+    /**
+     * Installs a npm package in the app directory for the project. It doesn't
+     * matter where the cwd directory is, as long as you're in an maka project
+     * and there's an app folder. If the app folder isn't a meteor project the
+     * meteor cli will throw an error.
+     */
+    initNpm(opts) {
+        return new Promise((resolve, reject) => {
+            opts = opts || {};
+            opts.cwd = opts.cwd || '.';
+            // If this is a self test, no need to actually install anything.
+            if (!opts.isSelfTest) {
+                const appDirectory = this.findAppDirectory(opts.cwd);
+                if (!appDirectory) {
+                    Log.error("Couldn't find an app directory to init npm into.");
+                    reject(new Error("Couldn't find an app directory to init npm into."));
+                }
+                else {
+                    const spinHandle = Log.withSpinner();
+                    try {
+                        spinHandle.start('Setting up the npm packages');
+                        exec('npm init -f ', { cwd: appDirectory }, (error) => {
+                            if (error) {
+                                Log.error(`\n${error.message}`);
+                                reject(error);
+                                process.exit(1);
+                            }
+                            spinHandle.success();
+                            resolve();
+                        });
+                    }
+                    catch (e) {
+                        Log.error(e);
+                        spinHandle.failure();
+                        reject(e instanceof Error ? e : new Error(String(e)));
+                    }
+                }
+            }
+        });
+    }
+    async checkPortInUse(port) {
+        return new Promise((resolve, reject) => {
+            const server = net.createServer();
+            server.once('error', (err) => {
+                void (async () => {
+                    if (err.code === 'EADDRINUSE') {
+                        const shouldTry = await Actions.confirm(`Port ${port} is already in use, try another? [yN]`, false);
+                        if (!shouldTry) {
+                            Log.error(`Port ${port} is already in use, exiting ...`);
+                            process.exit(1);
+                        }
+                        Log.singleLine(`Port ${port} is already in use, trying ${port + 100} ...\n`);
+                        resolve(true);
+                    }
+                    else {
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                })();
+            });
+            server.once('listening', () => {
+                server.close();
+                resolve(false);
+            });
+            server.listen(port, '0.0.0.0');
+        });
+    }
+    async getAvailablePort(startPort) {
+        while (await this.checkPortInUse(startPort)) {
+            startPort += 100;
+        }
+        return startPort;
+    }
+    async extractTarGz(tarFilePath, destDirectory) {
+        function getFileSize(filePath) {
+            const stats = fs.statSync(filePath);
+            return stats.size;
+        }
+        // extract graphic
+        const graphic = (process.platform === 'win32') ? '>' : '\u{1F4E6}';
+        const totalSize = getFileSize(tarFilePath);
+        const progressBar = new Progress(totalSize, "Extracting", graphic);
+        return new Promise((resolve, reject) => {
+            fs.createReadStream(tarFilePath)
+                .on('data', (chunk) => {
+                progressBar.update(chunk.length);
+            })
+                .pipe(tar.x({
+                gzip: true,
+                cwd: destDirectory
+            }))
+                .on('end', () => {
+                progressBar.complete();
+                resolve();
+            })
+                .on('error', (err) => {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            });
+        });
+    }
+    /**
+     * Get the logs directory path for the current project
+     */
+    getLogsDirectory() {
+        const projectDir = this.findProjectDirectory();
+        if (!projectDir) {
+            throw new Error('Not in a Maka project');
+        }
+        return path.join(projectDir, '.maka', 'logs');
+    }
+    /**
+     * Ensure logs directory exists
+     */
+    ensureLogsDirectory() {
+        const logsDir = this.getLogsDirectory();
+        if (!fs.existsSync(logsDir)) {
+            fs.mkdirSync(logsDir, { recursive: true });
+        }
+        return logsDir;
+    }
+    /**
+     * Generate log file path with timestamp
+     */
+    getLogFilePath(env, prefix = 'run') {
+        const logsDir = this.ensureLogsDirectory();
+        const timestamp = new Date().toISOString().replace(/:/g, '-').split('.')[0];
+        return path.join(logsDir, `${prefix}-${env}-${timestamp}.log`);
+    }
+    /**
+     * Rotate logs - keep only the last N log files per environment
+     */
+    rotateLogs(env, prefix = 'run', keepCount = 10) {
+        try {
+            const logsDir = this.getLogsDirectory();
+            if (!fs.existsSync(logsDir)) {
+                return;
+            }
+            // Get all log files for this env and prefix
+            const pattern = `${prefix}-${env}-`;
+            const logFiles = fs.readdirSync(logsDir)
+                .filter(file => file.startsWith(pattern) && file.endsWith('.log'))
+                .map(file => ({
+                name: file,
+                path: path.join(logsDir, file),
+                mtime: fs.statSync(path.join(logsDir, file)).mtime.getTime()
+            }))
+                .sort((a, b) => b.mtime - a.mtime); // Sort by modified time, newest first
+            // Remove old log files
+            if (logFiles.length > keepCount) {
+                const filesToDelete = logFiles.slice(keepCount);
+                filesToDelete.forEach(file => {
+                    try {
+                        fs.unlinkSync(file.path);
+                    }
+                    catch {
+                        // Ignore errors when deleting old logs
+                    }
+                });
+            }
+        }
+        catch {
+            // Silently fail rotation - it's not critical
+        }
+    }
+}
+//# sourceMappingURL=fsi.class.js.map