@magentrix-corp/magentrix-cli 1.1.5 → 1.2.1

package/utils/magentrix/api/auth.js

@@ -1,4 +1,5 @@
 import { fetchMagentrix } from "../fetch.js";
+import chalk from "chalk";
 
 /**
  * Authenticates with Magentrix and retrieves an access token using the API key as a refresh token.
@@ -45,12 +46,50 @@ export const tryAuthenticate = async (apiKey, instanceUrl) => {
     try {
         return await getAccessToken(apiKey, instanceUrl);
     } catch (error) {
-        throw new Error(
-            `❌ Failed to authenticate with Magentrix:\n` +
-            `The API key and/or instance URL you provided are incorrect or do not match.\n` +
-            `Please double-check both values and try again.\n\n` +
-            `Details: ${error.message || error}`
-        );
+        const errorMessage = error.message || String(error);
+
+        // Build formatted error message with colors and spacing
+        let formattedMessage = '\n' + chalk.red.bold('✖ Authentication Failed') + '\n';
+        formattedMessage += chalk.dim('─'.repeat(50)) + '\n\n';
+
+        if (errorMessage.includes('Network error')) {
+            formattedMessage += chalk.cyan.bold('🌐 Unable to reach the Magentrix instance') + '\n\n';
+            formattedMessage += chalk.yellow('  Possible causes:') + '\n';
+            formattedMessage += chalk.gray('  • Check your internet connection') + '\n';
+            formattedMessage += chalk.gray('  • Verify the instance URL is correct') + '\n';
+            formattedMessage += chalk.gray('  • Ensure the server is online and accessible') + '\n';
+        } else if (errorMessage.includes('HTTP 401') || errorMessage.includes('HTTP 403') || errorMessage.includes('Unauthorized')) {
+            formattedMessage += chalk.cyan.bold('🔑 Invalid API Key') + '\n\n';
+            formattedMessage += chalk.yellow('  What to do:') + '\n';
+            formattedMessage += chalk.gray('  • The API key you entered is incorrect') + '\n';
+            formattedMessage += chalk.gray('  • Verify your API key from the Magentrix admin panel') + '\n';
+        } else if (errorMessage.includes('HTTP 404')) {
+            formattedMessage += chalk.cyan.bold('🔍 Invalid Magentrix Instance URL') + '\n\n';
+            formattedMessage += chalk.yellow('  What to do:') + '\n';
+            formattedMessage += chalk.gray('  • The URL does not appear to be a valid Magentrix server') + '\n';
+            formattedMessage += chalk.gray('  • Verify the URL matches your Magentrix instance') + '\n';
+        } else if (errorMessage.includes('HTTP 5')) {
+            formattedMessage += chalk.cyan.bold('⚠️  Magentrix Server Error') + '\n\n';
+            formattedMessage += chalk.yellow('  What to do:') + '\n';
+            formattedMessage += chalk.gray('  • The server is experiencing issues') + '\n';
+            formattedMessage += chalk.gray('  • Please try again in a few moments') + '\n';
+            formattedMessage += chalk.gray('  • Contact support if the issue persists') + '\n';
+        } else if (errorMessage.includes('timeout') || errorMessage.includes('ETIMEDOUT')) {
+            formattedMessage += chalk.cyan.bold('⏱️  Connection Timeout') + '\n\n';
+            formattedMessage += chalk.yellow('  What to do:') + '\n';
+            formattedMessage += chalk.gray('  • The server took too long to respond') + '\n';
+            formattedMessage += chalk.gray('  • Check your internet connection') + '\n';
+            formattedMessage += chalk.gray('  • Try again in a moment') + '\n';
+        } else {
+            formattedMessage += chalk.cyan.bold('❓ Unable to Authenticate') + '\n\n';
+            formattedMessage += chalk.yellow('  What to do:') + '\n';
+            formattedMessage += chalk.gray('  • Verify both your API key and instance URL are correct') + '\n';
+            formattedMessage += chalk.gray('  • Ensure the API key matches the instance URL') + '\n';
+        }
+
+        formattedMessage += '\n' + chalk.dim('─'.repeat(50)) + '\n';
+
+        throw new Error(formattedMessage);
     }
 };
 

package/utils/progress.js

@@ -0,0 +1,383 @@
+import chalk from 'chalk';
+
+/**
+ * Comprehensive progress tracker for multi-step operations with sub-progress.
+ *
+ * Features:
+ * - Multiple step tracking
+ * - Progress bars for individual steps
+ * - Nested progress (e.g., batches within a step)
+ * - Time tracking
+ * - Dynamic message updates
+ *
+ * @example
+ * const progress = new ProgressTracker('Pull Operation');
+ * progress.addStep('auth', 'Authenticating...');
+ * progress.addStep('download', 'Downloading files...');
+ * progress.addStep('process', 'Processing files...');
+ *
+ * progress.start();
+ * progress.startStep('auth');
+ * // ... do auth work
+ * progress.completeStep('auth', 'Authenticated');
+ *
+ * progress.startStep('download');
+ * progress.updateProgress('download', 0, 100);
+ * // ... download files
+ * progress.updateProgress('download', 50, 100);
+ * progress.completeStep('download', 'Downloaded 100 files');
+ *
+ * progress.finish();
+ */
+export class ProgressTracker {
+    constructor(title = 'Operation') {
+        this.title = title;
+        this.steps = new Map();
+        this.currentStep = null;
+        this.startTime = null;
+        this.spinnerChars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        this.spinnerIndex = 0;
+        this.interval = null;
+        this.lastRenderLength = 0;
+        this.isFinished = false;
+    }
+
+    /**
+     * Add a step to track
+     * @param {string} id - Unique identifier for the step
+     * @param {string} label - Display label for the step
+     * @param {object} options - Optional configuration
+     * @param {boolean} options.hasProgress - Whether this step has progress (0-100%)
+     */
+    addStep(id, label, options = {}) {
+        this.steps.set(id, {
+            id,
+            label,
+            status: 'pending', // pending, active, completed, failed
+            hasProgress: options.hasProgress || false,
+            progress: { current: 0, total: 100 },
+            message: '',
+            startTime: null,
+            endTime: null,
+            error: null
+        });
+    }
+
+    /**
+     * Start the progress tracker
+     */
+    start() {
+        this.startTime = Date.now();
+        this.isFinished = false;
+        this.render();
+        this.startSpinner();
+    }
+
+    /**
+     * Start a specific step
+     * @param {string} id - Step identifier
+     * @param {string} message - Optional custom message
+     */
+    startStep(id, message = '') {
+        const step = this.steps.get(id);
+        if (!step) {
+            throw new Error(`Step '${id}' not found`);
+        }
+
+        // Complete previous step if any
+        if (this.currentStep && this.steps.get(this.currentStep).status === 'active') {
+            this.completeStep(this.currentStep);
+        }
+
+        step.status = 'active';
+        step.startTime = Date.now();
+        step.message = message || step.label;
+        this.currentStep = id;
+        this.render();
+    }
+
+    /**
+     * Update progress for a step
+     * @param {string} id - Step identifier
+     * @param {number} current - Current progress value
+     * @param {number} total - Total progress value
+     * @param {string} message - Optional message to display
+     */
+    updateProgress(id, current, total, message = '') {
+        const step = this.steps.get(id);
+        if (!step) return;
+
+        step.progress.current = current;
+        step.progress.total = total;
+        if (message) {
+            step.message = message;
+        }
+        this.render();
+    }
+
+    /**
+     * Complete a step
+     * @param {string} id - Step identifier
+     * @param {string} message - Optional completion message
+     */
+    completeStep(id, message = '') {
+        const step = this.steps.get(id);
+        if (!step) return;
+
+        step.status = 'completed';
+        step.endTime = Date.now();
+        if (message) {
+            step.message = message;
+        }
+        this.render();
+    }
+
+    /**
+     * Mark a step as failed
+     * @param {string} id - Step identifier
+     * @param {string} error - Error message
+     */
+    failStep(id, error) {
+        const step = this.steps.get(id);
+        if (!step) return;
+
+        step.status = 'failed';
+        step.endTime = Date.now();
+        step.error = error;
+        this.render();
+    }
+
+    /**
+     * Update the message for the current step
+     * @param {string} message - New message
+     */
+    updateMessage(message) {
+        if (!this.currentStep) return;
+        const step = this.steps.get(this.currentStep);
+        if (step) {
+            step.message = message;
+            this.render();
+        }
+    }
+
+    /**
+     * Render the progress display
+     */
+    render() {
+        if (this.isFinished) return;
+
+        // Clear previous render
+        if (this.lastRenderLength > 0) {
+            for (let i = 0; i < this.lastRenderLength; i++) {
+                process.stdout.write('\x1B[1A\x1B[2K'); // Move up and clear line
+            }
+        }
+
+        const lines = [];
+
+        // Title with elapsed time
+        const elapsed = this.formatDuration(Date.now() - this.startTime);
+        lines.push(chalk.bold.blue(`\n${this.title}`) + chalk.gray(` (${elapsed})`));
+        lines.push('');
+
+        // Render each step
+        for (const [id, step] of this.steps) {
+            const prefix = this.getStepPrefix(step);
+            const label = step.status === 'active'
+                ? chalk.cyan(step.label)
+                : step.status === 'completed'
+                ? chalk.gray(step.label)
+                : step.status === 'failed'
+                ? chalk.red(step.label)
+                : chalk.gray(step.label);
+
+            let line = `${prefix} ${label}`;
+
+            // Add progress bar if applicable
+            if (step.hasProgress && step.status === 'active' && step.progress.total > 0) {
+                const percentage = Math.floor((step.progress.current / step.progress.total) * 100);
+                const progressBar = this.renderProgressBar(percentage);
+                line += ` ${progressBar} ${percentage}%`;
+            }
+
+            // Add message or duration
+            if (step.message && step.status === 'active') {
+                line += chalk.gray(` - ${step.message}`);
+            } else if (step.status === 'completed' && step.endTime && step.startTime) {
+                const duration = this.formatDuration(step.endTime - step.startTime);
+                line += chalk.gray(` (${duration})`);
+                if (step.message) {
+                    line += chalk.gray(` - ${step.message}`);
+                }
+            } else if (step.status === 'failed' && step.error) {
+                line += chalk.red(` - ${step.error}`);
+            }
+
+            lines.push(line);
+        }
+
+        lines.push(''); // Empty line at the end
+
+        this.lastRenderLength = lines.length;
+        process.stdout.write(lines.join('\n'));
+    }
+
+    /**
+     * Get the prefix icon for a step
+     */
+    getStepPrefix(step) {
+        switch (step.status) {
+            case 'pending':
+                return chalk.gray('◯');
+            case 'active':
+                return chalk.cyan(this.spinnerChars[this.spinnerIndex]);
+            case 'completed':
+                return chalk.green('✓');
+            case 'failed':
+                return chalk.red('✗');
+            default:
+                return chalk.gray('◯');
+        }
+    }
+
+    /**
+     * Render a progress bar
+     * @param {number} percentage - Progress percentage (0-100)
+     */
+    renderProgressBar(percentage) {
+        const width = 20;
+        // Clamp percentage between 0 and 100 to prevent negative values
+        const clampedPercentage = Math.max(0, Math.min(100, percentage));
+        const filled = Math.floor((clampedPercentage / 100) * width);
+        const empty = width - filled;
+
+        const bar = chalk.cyan('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+        return `[${bar}]`;
+    }
+
+    /**
+     * Format duration in ms to human readable format
+     */
+    formatDuration(ms) {
+        if (ms < 1000) return `${ms}ms`;
+        if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+        const minutes = Math.floor(ms / 60000);
+        const seconds = Math.floor((ms % 60000) / 1000);
+        return `${minutes}m ${seconds}s`;
+    }
+
+    /**
+     * Start the spinner animation
+     */
+    startSpinner() {
+        this.interval = setInterval(() => {
+            this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerChars.length;
+            this.render();
+        }, 80);
+    }
+
+    /**
+     * Stop the spinner animation
+     */
+    stopSpinner() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+
+    /**
+     * Finish the progress tracker
+     * @param {string} message - Optional final message
+     */
+    finish(message = '') {
+        this.stopSpinner();
+        this.isFinished = true;
+
+        // Complete any active steps
+        if (this.currentStep && this.steps.get(this.currentStep).status === 'active') {
+            this.completeStep(this.currentStep);
+        }
+
+        this.render();
+
+        // Print summary
+        const totalTime = this.formatDuration(Date.now() - this.startTime);
+        const completed = Array.from(this.steps.values()).filter(s => s.status === 'completed').length;
+        const failed = Array.from(this.steps.values()).filter(s => s.status === 'failed').length;
+
+        if (message) {
+            console.log(chalk.bold.green(`\n${message}`));
+        }
+
+        console.log(chalk.gray(`Total time: ${totalTime}`));
+
+        if (failed > 0) {
+            console.log(chalk.red(`✗ ${failed} step(s) failed`));
+        } else {
+            console.log(chalk.green(`✓ All ${completed} step(s) completed successfully`));
+        }
+        console.log('');
+    }
+
+    /**
+     * Abort the progress tracker with an error
+     * @param {string} error - Error message
+     */
+    abort(error) {
+        this.stopSpinner();
+        this.isFinished = true;
+
+        if (this.currentStep) {
+            this.failStep(this.currentStep, error);
+        }
+
+        this.render();
+        console.log(chalk.bold.red(`\n✗ ${error}\n`));
+    }
+}
+
+/**
+ * Helper function to create and use a simple progress tracker
+ * @param {string} title - Title of the operation
+ * @param {Array} steps - Array of step definitions
+ * @param {Function} fn - Async function that receives the progress tracker
+ * @returns {Promise} Result of the function
+ *
+ * @example
+ * await withProgress('Pull Operation', [
+ *   { id: 'auth', label: 'Authenticating...' },
+ *   { id: 'download', label: 'Downloading files...', hasProgress: true },
+ *   { id: 'process', label: 'Processing files...' }
+ * ], async (progress) => {
+ *   progress.startStep('auth');
+ *   await authenticate();
+ *   progress.completeStep('auth');
+ *
+ *   progress.startStep('download');
+ *   for (let i = 0; i <= 100; i += 10) {
+ *     progress.updateProgress('download', i, 100);
+ *     await downloadBatch(i);
+ *   }
+ *   progress.completeStep('download');
+ * });
+ */
+export async function withProgress(title, steps, fn) {
+    const progress = new ProgressTracker(title);
+
+    // Add all steps
+    for (const step of steps) {
+        progress.addStep(step.id, step.label, step);
+    }
+
+    progress.start();
+
+    try {
+        const result = await fn(progress);
+        progress.finish();
+        return result;
+    } catch (error) {
+        progress.abort(error.message);
+        throw error;
+    }
+}

package/utils/updateFileBase.js

@@ -53,7 +53,8 @@ export const updateBase = (filePath, record, actualPath = '', contentSnapshot =
     const fileSystemLocation = actualPath || path.resolve(filePath);
 
     if (!fs.existsSync(fileSystemLocation)) {
-        console.error(`❌ File does not exist: ${filePath}`);
+        // Silently skip files that don't exist - they may have failed to download
+        // This is expected behavior for files that returned 404 during download
         return;
     }
 
@@ -106,3 +107,7 @@ export const updateBase = (filePath, record, actualPath = '', contentSnapshot =
 export const removeFromBase = (recordId) => {
     config.removeKey(recordId, { filename: "base.json" });
 }
+
+export const removeFromBaseBulk = (recordIds) => {
+    config.removeKeys(recordIds, { filename: "base.json" });
+}