@maka/maka-cli 5.2.4 → 5.2.6

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

@@ -1,685 +0,0 @@
-import path from 'path';
-import net from 'net';
-import tar from '@maka/tar';
-import fs from 'fs';
-import os from 'os';
-import del from 'delete';
-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;
-    appName;
-    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() {
-        return path.join(this.getMeteorInstallPath(), '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 { 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 '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 Log.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 Log.error('No directory path provided');
-        }
-        try {
-            if (force) {
-                del.sync(dirPath);
-            }
-            if (this.isFile(dirPath)) {
-                throw Log.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 `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 (e) {
-            return false;
-        }
-    }
-    /**
-     * Returns true if the dirpath is a directory.
-     */
-    isDirectory(dirPath) {
-        try {
-            const stats = fs.statSync(dirPath);
-            return stats.isDirectory();
-        }
-        catch (e) {
-            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 (e) {
-            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 (e) {
-            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();
-                }
-                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();
-                                process.exit(1);
-                            }
-                            spinHandle.success();
-                            resolve();
-                        });
-                    }
-                    catch (e) {
-                        Log.error(e);
-                        spinHandle.failure();
-                        reject();
-                    }
-                }
-            }
-        });
-    }
-    async checkPortInUse(port) {
-        return new Promise((resolve, reject) => {
-            const server = net.createServer();
-            server.once('error', async (err) => {
-                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);
-                }
-            });
-            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);
-            });
-        });
-    }
-    /**
-     * 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 (err) {
-                        // Ignore errors when deleting old logs
-                    }
-                });
-            }
-        }
-        catch (err) {
-            // Silently fail rotation - it's not critical
-        }
-    }
-}
-//# sourceMappingURL=fsi.class.js.map