@magentrix-corp/magentrix-cli 1.1.5 → 1.2.1

package/actions/setup.js

@@ -4,6 +4,7 @@ import Config from "../utils/config.js";
 import { getAccessToken, tryAuthenticate } from "../utils/magentrix/api/auth.js";
 import { ensureVSCodeFileAssociation } from "../utils/preferences.js";
 import { EXPORT_ROOT, HASHED_CWD } from "../vars/global.js";
+import { select } from "@inquirer/prompts";
 
 const config = new Config();
 
@@ -23,7 +24,7 @@ const config = new Config();
  */
 export const setup = async (cliOptions = {}) => {
     // Validation for CLI-provided values
-    const urlRegex = /^https:\/\/[a-zA-Z0-9-]+\.magentrix(cloud)?\.com$/;
+    const urlRegex = /^https:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
 
     if (cliOptions.apiKey) {
         if (cliOptions.apiKey.trim().length < 12) {
@@ -35,24 +36,70 @@ export const setup = async (cliOptions = {}) => {
     }
 
     if (cliOptions.instanceUrl) {
-        const trimmedUrl = cliOptions.instanceUrl.trim();
+        let trimmedUrl = cliOptions.instanceUrl.trim();
+        // Automatically strip trailing slashes
+        trimmedUrl = trimmedUrl.replace(/\/+$/, '');
+
         if (!urlRegex.test(trimmedUrl)) {
-            throw new Error('--instance-url must be in the form: https://subdomain.magentrixcloud.com (NO http, NO trailing /, NO extra path)');
+            throw new Error('--instance-url must be in the form: https://subdomain.domain.com (no http, no extra path)');
         }
+        // Update the option with the cleaned URL
+        cliOptions.instanceUrl = trimmedUrl;
     }
 
-    // Get API key (from CLI or prompt)
-    const apiKey = cliOptions.apiKey
-        ? cliOptions.apiKey.trim()
-        : await ensureApiKey(true);
-
-    // Get instance URL (from CLI or prompt)
-    const instanceUrl = cliOptions.instanceUrl
-        ? cliOptions.instanceUrl.trim()
-        : await ensureInstanceUrl(true);
-
-    // Validate credentials by attempting to fetch an access token
-    const tokenData = await tryAuthenticate(apiKey, instanceUrl);
+    // Retry loop for authentication
+    let authSuccess = false;
+    let apiKey, instanceUrl, tokenData;
+
+    while (!authSuccess) {
+        // Get API key (from CLI or prompt)
+        apiKey = cliOptions.apiKey
+            ? cliOptions.apiKey.trim()
+            : await ensureApiKey(true);
+
+        // Get instance URL (from CLI or prompt)
+        instanceUrl = cliOptions.instanceUrl
+            ? cliOptions.instanceUrl.trim()
+            : await ensureInstanceUrl(true);
+
+        // Validate credentials by attempting to fetch an access token
+        try {
+            tokenData = await tryAuthenticate(apiKey, instanceUrl);
+            authSuccess = true;
+        } catch (error) {
+            console.log(error.message);
+            console.log();
+
+            // Ask user if they want to retry
+            try {
+                const retry = await select({
+                    message: 'What would you like to do?',
+                    choices: [
+                        { name: 'Try again', value: 'retry' },
+                        { name: 'Exit setup', value: 'exit' }
+                    ],
+                    default: 'retry'
+                });
+
+                if (retry !== 'retry') {
+                    console.log('❌ Setup cancelled.');
+                    process.exit(0);
+                }
+
+                // Reset CLI options so user can re-enter them
+                cliOptions.apiKey = null;
+                cliOptions.instanceUrl = null;
+                console.log(); // Blank line for spacing
+            } catch (error) {
+                // Handle Ctrl+C or other cancellation
+                if (error.name === 'ExitPromptError') {
+                    console.log('\n❌ Setup cancelled.');
+                    process.exit(0);
+                }
+                throw error;
+            }
+        }
+    }
 
     console.log(); // Blank line for spacing
 
@@ -69,7 +116,7 @@ export const setup = async (cliOptions = {}) => {
         { global: true, pathHash: HASHED_CWD }
     );
 
-    // Set up the editor 
+    // Set up the editor
     await ensureVSCodeFileAssociation('./');
 
     console.log(); // Blank line for spacing

package/actions/update.js

@@ -0,0 +1,248 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { withSpinner } from '../utils/spinner.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Detects how the CLI was installed (global npm, local npm, or development).
+ * @returns {Object} { method: 'global'|'local'|'dev', packagePath: string }
+ */
+const detectInstallationMethod = () => {
+    try {
+        // Get the real path of the binary (resolves symlinks)
+        const binaryPath = path.resolve(__dirname, '../bin/magentrix.js');
+        const realBinaryPath = fs.realpathSync(binaryPath);
+
+        // Check if running from node_modules
+        const isInNodeModules = realBinaryPath.includes('node_modules');
+
+        if (!isInNodeModules) {
+            // Running from source (development)
+            return { method: 'dev', packagePath: path.resolve(__dirname, '..') };
+        }
+
+        // Check if it's a global installation by looking at the path structure
+        // Global npm packages on Unix: /usr/local/lib/node_modules or ~/.npm-global/lib/node_modules
+        // Global npm packages on Windows: %APPDATA%\npm\node_modules
+        const isGlobal = realBinaryPath.includes('/lib/node_modules/') ||
+                        realBinaryPath.includes('\\npm\\node_modules\\') ||
+                        realBinaryPath.includes('/.npm-global/') ||
+                        realBinaryPath.includes('\\.npm-global\\');
+
+        if (isGlobal) {
+            return { method: 'global', packagePath: null };
+        }
+
+        // Local installation - find the nearest package.json in node_modules
+        let currentPath = realBinaryPath;
+        while (currentPath !== path.dirname(currentPath)) {
+            if (path.basename(currentPath) === 'node_modules') {
+                return { method: 'local', packagePath: path.dirname(currentPath) };
+            }
+            currentPath = path.dirname(currentPath);
+        }
+
+        return { method: 'local', packagePath: process.cwd() };
+    } catch (error) {
+        console.warn(chalk.yellow(`Warning: Could not detect installation method: ${error.message}`));
+        return { method: 'unknown', packagePath: null };
+    }
+};
+
+/**
+ * Gets the current installed version from package.json.
+ * @returns {string} Version string
+ */
+const getCurrentVersion = () => {
+    try {
+        const packageJsonPath = path.resolve(__dirname, '../package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        return packageJson.version;
+    } catch (error) {
+        return 'unknown';
+    }
+};
+
+/**
+ * Gets the latest available version from npm registry.
+ * @param {string} packageName - NPM package name
+ * @returns {Promise<string>} Latest version string
+ */
+const getLatestVersion = async (packageName) => {
+    try {
+        const result = execSync(`npm view ${packageName} version`, { encoding: 'utf-8' });
+        return result.trim();
+    } catch (error) {
+        throw new Error(`Failed to check latest version: ${error.message}`);
+    }
+};
+
+/**
+ * Attempts to update the package based on installation method.
+ * @param {string} method - Installation method ('global', 'local', or 'dev')
+ * @param {string} packagePath - Path to package directory (for local installs)
+ * @returns {Promise<Object>} { success: boolean, message: string }
+ */
+const performUpdate = async (method, packagePath) => {
+    const packageName = '@magentrix-corp/magentrix-cli';
+
+    try {
+        let command;
+        let cwd = process.cwd();
+
+        switch (method) {
+            case 'global':
+                command = `npm install -g ${packageName}@latest`;
+                break;
+
+            case 'local':
+                command = `npm install ${packageName}@latest`;
+                cwd = packagePath || process.cwd();
+                break;
+
+            case 'dev':
+                return {
+                    success: false,
+                    isDev: true,
+                    message: 'Cannot auto-update: Running from source code (development mode)'
+                };
+
+            default:
+                return {
+                    success: false,
+                    message: 'Cannot auto-update: Unable to detect installation method'
+                };
+        }
+
+        // Execute the update command
+        execSync(command, {
+            cwd,
+            stdio: 'inherit', // Show npm output to user
+            encoding: 'utf-8'
+        });
+
+        return { success: true, message: 'Update completed successfully!' };
+    } catch (error) {
+        // Parse the error to provide helpful messages
+        const errorMessage = error.message || String(error);
+
+        // Check for common error patterns
+        if (errorMessage.includes('EACCES') || errorMessage.includes('permission denied')) {
+            return {
+                success: false,
+                needsSudo: true,
+                message: 'Update failed: Permission denied'
+            };
+        }
+
+        if (errorMessage.includes('ENOTFOUND') || errorMessage.includes('network')) {
+            return {
+                success: false,
+                message: 'Update failed: Network error (check your internet connection)'
+            };
+        }
+
+        return {
+            success: false,
+            message: `Update failed: ${errorMessage}`
+        };
+    }
+};
+
+/**
+ * Main update command handler.
+ */
+export const update = async () => {
+    console.log(chalk.bold.cyan('\n🔄 MagentrixCLI Updater\n'));
+
+    // Step 1: Detect installation method
+    const { method, packagePath } = detectInstallationMethod();
+    const currentVersion = getCurrentVersion();
+
+    console.log(chalk.gray('Current version:'), chalk.white(currentVersion));
+    console.log(chalk.gray('Installation method:'), chalk.white(method));
+
+    if (method === 'dev') {
+        console.log();
+        console.log(chalk.yellow('⚠️  Development Mode Detected'));
+        console.log(chalk.gray('You are running from source code.'));
+        console.log(chalk.gray('To update, use:'), chalk.cyan('git pull'));
+        return;
+    }
+
+    // Step 2: Check for latest version
+    console.log();
+    const latestVersion = await withSpinner('Checking for updates...', async () => {
+        return await getLatestVersion('@magentrix-corp/magentrix-cli');
+    });
+
+    console.log(chalk.gray('Latest version:'), chalk.white(latestVersion));
+
+    // Step 3: Compare versions
+    if (currentVersion === latestVersion) {
+        console.log();
+        console.log(chalk.green('✓ You are already on the latest version!'));
+        return;
+    }
+
+    console.log();
+    console.log(chalk.yellow(`📦 Update available: ${currentVersion} → ${latestVersion}`));
+    console.log();
+
+    // Step 4: Attempt update
+    console.log(chalk.blue('Starting update...\n'));
+
+    const result = await performUpdate(method, packagePath);
+
+    console.log();
+
+    if (result.success) {
+        console.log(chalk.green('✅ ' + result.message));
+        console.log(chalk.gray('\nRun'), chalk.cyan('magentrix --version'), chalk.gray('to verify the update.'));
+    } else {
+        console.log(chalk.bgRed.bold.white('  ✖ Update Failed  '));
+        console.log(chalk.redBright('─'.repeat(60)));
+        console.log(chalk.red(result.message));
+        console.log();
+
+        // Show helpful troubleshooting tips
+        console.log(chalk.yellow('Common solutions:'));
+        console.log();
+
+        if (result.needsSudo || result.message.includes('Permission')) {
+            console.log(chalk.white('1. ') + chalk.gray('Try running with elevated permissions:'));
+            if (method === 'global') {
+                console.log(chalk.cyan('   sudo npm install -g @magentrix-corp/magentrix-cli@latest'));
+            } else {
+                console.log(chalk.cyan('   sudo npm install @magentrix-corp/magentrix-cli@latest'));
+            }
+            console.log();
+        }
+
+        console.log(chalk.white('2. ') + chalk.gray('Manually update using npm:'));
+        if (method === 'global') {
+            console.log(chalk.cyan('   npm install -g @magentrix-corp/magentrix-cli@latest'));
+        } else {
+            console.log(chalk.cyan('   npm install @magentrix-corp/magentrix-cli@latest'));
+        }
+        console.log();
+
+        console.log(chalk.white('3. ') + chalk.gray('Check npm configuration:'));
+        console.log(chalk.cyan('   npm config list'));
+        console.log();
+
+        console.log(chalk.white('4. ') + chalk.gray('Verify you have write access to npm directories'));
+        console.log();
+
+        console.log(chalk.white('5. ') + chalk.gray('If using a proxy, ensure npm is configured correctly:'));
+        console.log(chalk.cyan('   npm config set proxy http://your-proxy:port'));
+        console.log();
+
+        console.log(chalk.redBright('─'.repeat(60)));
+    }
+};

package/bin/magentrix.js

@@ -13,6 +13,8 @@ import { status } from '../actions/status.js';
 import { cacheDir, recacheFileIdIndex } from '../utils/cacher.js';
 import { EXPORT_ROOT } from '../vars/global.js';
 import { publish } from '../actions/publish.js';
+import { update } from '../actions/update.js';
+import { configWizard } from '../actions/config.js';
 
 // ── Middleware ────────────────────────────────
 async function preMiddleware() {
@@ -52,11 +54,13 @@ program
             help += `${chalk.bold.yellow('COMMANDS')}\n`;
             const commands = [
                 { name: 'setup', desc: 'Configure your Magentrix API key', icon: '⚙️  ' },
+                { name: 'config', desc: 'Manage CLI settings', icon: '🔧 ' },
                 { name: 'pull', desc: 'Pull files from the remote server', icon: '📥 ' },
                 { name: 'create', desc: 'Create files locally', icon: '✨ ' },
                 { name: 'status', desc: 'Show file conflicts and sync status', icon: '📊 ' },
                 { name: 'publish', desc: 'Publish pending changes to the remote server', icon: '📤 ' },
-                { name: 'autopublish', desc: 'Watch & sync changes in real time', icon: '🔄 ' }
+                { name: 'autopublish', desc: 'Watch & sync changes in real time', icon: '🔄 ' },
+                { name: 'update', desc: 'Update MagentrixCLI to the latest version', icon: '⬆️  ' }
             ];
 
             const maxNameLen = Math.max(...commands.map(c => c.name.length));
@@ -177,7 +181,15 @@ createCommand.configureHelp({
 });
 program.command('status').description('Show file conflicts').action(withDefault(status));
 program.command('autopublish').description('Watch & sync changes in real time').action(withDefault(autoPublish));
+// Publish does its own comprehensive file scanning, so skip the pre-cache middleware
 program.command('publish').description('Publish pending changes to the remote server').action(withDefault(publish));
+program.command('update').description('Update MagentrixCLI to the latest version').action(update);
+
+// Config command - interactive wizard
+program
+    .command('config')
+    .description('Configure CLI settings')
+    .action(configWizard);
 
 // ── Unknown Command Handler ──────────────────
 program.argument('[command]', 'command to run').action((cmd) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magentrix-corp/magentrix-cli",
-  "version": "1.1.5",
+  "version": "1.2.1",
   "description": "CLI tool for synchronizing local files with Magentrix cloud platform",
   "main": "index.js",
   "type": "module",

package/utils/assetPaths.js

@@ -27,9 +27,19 @@ export const toApiPath = (localPath) => {
         return '/contents/assets';
     }
 
-    // Normalize the path and remove the EXPORT_ROOT
+    // Normalize the path
     const normalized = path.normalize(localPath);
-    const relative = normalized.replace(new RegExp(`^${EXPORT_ROOT}[\\\\/]?`), '');
+
+    // Remove EXPORT_ROOT from path (handle both absolute and relative paths)
+    let relative;
+    if (path.isAbsolute(normalized)) {
+        // For absolute paths, find and remove everything up to and including EXPORT_ROOT
+        const exportRootPattern = new RegExp(`.*[\\\\/]${EXPORT_ROOT}[\\\\/]`);
+        relative = normalized.replace(exportRootPattern, '');
+    } else {
+        // For relative paths, just remove EXPORT_ROOT prefix
+        relative = normalized.replace(new RegExp(`^${EXPORT_ROOT}[\\\\/]?`), '');
+    }
 
     // Replace 'Assets' with 'contents/assets' (case insensitive search, but replace with lowercase)
     const apiPath = relative.replace(/^Assets/i, 'contents/assets');
@@ -84,9 +94,19 @@ export const toApiFolderPath = (localFolderPath) => {
         return '/contents/assets';
     }
 
-    // Normalize the path and remove the EXPORT_ROOT
+    // Normalize the path
     const normalized = path.normalize(localFolderPath);
-    const relative = normalized.replace(new RegExp(`^${EXPORT_ROOT}[\\\\/]?`), '');
+
+    // Remove EXPORT_ROOT from path (handle both absolute and relative paths)
+    let relative;
+    if (path.isAbsolute(normalized)) {
+        // For absolute paths, find and remove everything up to and including EXPORT_ROOT
+        const exportRootPattern = new RegExp(`.*[\\\\/]${EXPORT_ROOT}[\\\\/]`);
+        relative = normalized.replace(exportRootPattern, '');
+    } else {
+        // For relative paths, just remove EXPORT_ROOT prefix
+        relative = normalized.replace(new RegExp(`^${EXPORT_ROOT}[\\\\/]?`), '');
+    }
 
     // Replace 'Assets' with 'contents/assets' (case insensitive search, but replace with lowercase)
     let apiPath = relative.replace(/^Assets/i, 'contents/assets');

package/utils/cacher.js

@@ -10,6 +10,7 @@ const config = new Config();
 
 /**
  * Recursively caches all files in a directory with tagging and content snapshotting
+ * OPTIMIZED: Parallel processing + mtime checks for maximum speed
  * @param {string} dir - Directory to cache
  * @returns {Promise<void>}
  */
@@ -17,69 +18,135 @@ export const cacheDir = async (dir) => {
     if (!fs.existsSync(dir)) return;
 
     const absDir = path.resolve(dir);
-    const files = await walkFiles(absDir);
 
-    const cache = config.read('cachedFiles', { global: false, filename: 'fileCache.json' }) || {};
-
-    for (const file of files) {
-        const stats = fs.statSync(file);
-        if (!stats.isFile()) continue;
+    // Walk files but exclude Assets folder (tracked separately in base.json)
+    const files = await walkFiles(absDir, { ignore: [path.join(absDir, 'Assets')] });
 
-        const checkFileTag = async (retry = true) => {
-            // Check file tag
-            const tag = await getFileTag(file);
+    const cache = config.read('cachedFiles', { global: false, filename: 'fileCache.json' }) || {};
 
-            if (!tag) {
-                // Try to repair if there is a tag linked to that path
-                const dirLinkedTag = isPathLinkedToTagByLastKnownPath(file);
-                if (dirLinkedTag && retry) {
-                    await setFileTag(file, dirLinkedTag);
-                    return await checkFileTag(false);
+    // Process files in parallel batches
+    const BATCH_SIZE = 50;
+    const updates = [];
+
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+        const batch = files.slice(i, i + BATCH_SIZE);
+
+        // Process batch in parallel
+        const batchResults = await Promise.all(
+            batch.map(async (file) => {
+                try {
+                    const stats = fs.statSync(file);
+                    if (!stats.isFile()) return null;
+
+                    const checkFileTag = async (retry = true) => {
+                        const tag = await getFileTag(file);
+                        if (!tag) {
+                            const dirLinkedTag = isPathLinkedToTagByLastKnownPath(file);
+                            if (dirLinkedTag && retry) {
+                                await setFileTag(file, dirLinkedTag);
+                                return await checkFileTag(false);
+                            }
+                            return null;
+                        }
+                        return tag;
+                    }
+
+                    const tag = await checkFileTag();
+                    if (!tag) return null;
+
+                    const objectId = tag;
+
+                    // OPTIMIZATION: Only read/hash/compress if file changed (mtime check)
+                    const existingCache = cache[objectId];
+                    if (existingCache &&
+                        existingCache.mtimeMs === stats.mtimeMs &&
+                        existingCache.size === stats.size &&
+                        existingCache.lastKnownPath === file) {
+                        // File hasn't changed, skip expensive operations
+                        return null;
+                    }
+
+                    // File is new or changed - do the expensive operations
+                    const content = fs.readFileSync(file, 'utf8');
+
+                    return {
+                        objectId,
+                        data: {
+                            tag,
+                            lastKnownPath: file,
+                            contentHash: sha256(content),
+                            compressedContent: compressString(content),
+                            size: stats.size,
+                            mtimeMs: stats.mtimeMs,
+                            dev: stats.dev,
+                            ino: stats.ino
+                        }
+                    };
+                } catch (err) {
+                    return null;
                 }
-                return null;
-            }
+            })
+        );
 
-            return tag;
-        }
+        // Collect updates
+        updates.push(...batchResults.filter(r => r !== null));
+    }
 
-        const tag = await checkFileTag();
-        if (!tag) {
-            // There may not be a tag if the user manually created a file
-            // console.warn(`Warning: failed to tag file: ${file}`);
-            continue;
+    // Apply all updates to cache
+    if (updates.length > 0) {
+        for (const { objectId, data } of updates) {
+            cache[objectId] = data;
         }
-
-        const content = fs.readFileSync(file, 'utf8');
-        const objectId = tag; // Use the tag so we don't get duplicates
-
-        cache[objectId] = {
-            tag,
-            lastKnownPath: file,
-            contentHash: sha256(content),
-            compressedContent: compressString(content),
-            size: stats.size,
-            mtimeMs: stats.mtimeMs,
-            dev: stats.dev,
-            ino: stats.ino
-        };
+        config.save('cachedFiles', cache, { global: false, filename: 'fileCache.json' });
     }
-
-    config.save('cachedFiles', cache, { global: false, filename: 'fileCache.json' });
 };
 
+/**
+ * Recaches file ID index by walking files and updating tags
+ * OPTIMIZED: Parallel processing with batching for speed
+ * @param {string} dir - Directory to recache
+ * @returns {Promise<void>}
+ */
 export const recacheFileIdIndex = async (dir) => {
-    const files = await walkFiles(dir);
+    // Exclude Assets folder - they don't use file tags, tracked in base.json instead
+    const absDir = path.resolve(dir);
+    const ignorePath = path.join(absDir, 'Assets');
+    const files = await walkFiles(absDir, { ignore: [ignorePath] });
     if (!files || files?.length < 1) return;
-    
-    for (const file of files) {
-        const tag = await getFileTag(file);
-        if (!tag) continue;
-        
-        // Update the index id cache
-        const lastKnownPath = findFileByTag(tag);
-        if (lastKnownPath !== file) {
-            await setFileTag(file, tag);
-        }
+
+    // Process files in parallel batches of 50 for speed
+    const BATCH_SIZE = 50;
+    const updates = [];
+
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+        const batch = files.slice(i, i + BATCH_SIZE);
+
+        // Process batch in parallel
+        const batchResults = await Promise.all(
+            batch.map(async (file) => {
+                try {
+                    const tag = await getFileTag(file);
+                    if (!tag) return null;
+
+                    // Check if path changed
+                    const lastKnownPath = findFileByTag(tag);
+                    if (lastKnownPath !== file) {
+                        return { file, tag };
+                    }
+                    return null;
+                } catch (err) {
+                    return null;
+                }
+            })
+        );
+
+        // Collect updates
+        updates.push(...batchResults.filter(r => r !== null));
+    }
+
+    // Apply all updates at once
+    for (const { file, tag } of updates) {
+        await setFileTag(file, tag);
     }
 }
 
@@ -96,11 +163,13 @@ export async function walkFiles(dir, settings) {
     let paths = [];
 
     for (const entry of entries) {
-        if (ignore.find(p => entry.path.startsWith(p) || entry.path === p)) {
+        const fullPath = path.join(dir, entry.name);
+
+        // Check if this path should be ignored
+        if (ignore.find(p => fullPath.startsWith(p) || fullPath === p)) {
             continue;
         }
 
-        const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
             const subPaths = await walkFiles(fullPath, settings);
             if (subPaths && subPaths.length > 0) {