@magentrix-corp/magentrix-cli 1.2.1 → 1.3.0

package/actions/publish.js

@@ -11,6 +11,7 @@ import {
     ENTITY_TYPE_MAP,
     EXPORT_ROOT,
     TYPE_DIR_MAP,
+    IRIS_APPS_DIR,
 } from "../vars/global.js";
 import { getFileTag, setFileTag } from "../utils/filetag.js";
 import { sha256 } from "../utils/hash.js";
@@ -20,6 +21,11 @@ import { deleteEntity } from "../utils/magentrix/api/deleteEntity.js";
 import { removeFromBase, updateBase } from "../utils/updateFileBase.js";
 import { deleteAsset, uploadAsset, createFolder } from "../utils/magentrix/api/assets.js";
 import { toApiPath, toApiFolderPath } from "../utils/assetPaths.js";
+import { publishApp } from "../utils/magentrix/api/iris.js";
+import { createIrisZip, hashIrisAppFolder } from "../utils/iris/zipper.js";
+import { validateIrisAppFolder } from "../utils/iris/validator.js";
+import { getLinkedProjects } from "../utils/iris/linker.js";
+import { deleteIrisAppFromServer } from "../utils/iris/deleteHelper.js";
 
 const config = new Config();
 
@@ -120,6 +126,8 @@ const walkFolders = (dir) => {
  * Gets display name for an action in log messages.
  */
 const getActionDisplayName = (action) => {
+    // Iris app actions
+    if (action.slug) return `${action.appName || action.slug} (${action.slug})`;
     if (action.folderName) return action.folderName;
     if (action.names) return action.names.join(", ");
     if (action.type) return action.type;
@@ -273,6 +281,35 @@ const handleDeleteFolderAction = async (instanceUrl, apiKey, action) => {
     }
 };
 
+/**
+ * Handles CREATE_IRIS_APP or UPDATE_IRIS_APP action.
+ */
+const handlePublishIrisAppAction = async (instanceUrl, apiKey, action) => {
+    // Create zip from the app folder
+    const zipBuffer = await createIrisZip(action.appPath, action.slug);
+
+    // Publish via API with app-name parameter
+    const response = await publishApp(
+        instanceUrl,
+        apiKey,
+        zipBuffer,
+        `${action.slug}.zip`,
+        action.appName
+    );
+
+    return response;
+};
+
+/**
+ * Handles DELETE_IRIS_APP action.
+ */
+const handleDeleteIrisAppAction = async (instanceUrl, apiKey, action) => {
+    // Use shared delete utility for consistency
+    return await deleteIrisAppFromServer(instanceUrl, apiKey, action.slug, {
+        updateCache: true  // Cache will be updated by the utility
+    });
+};
+
 /**
  * Synchronizes class name in content with filename, or vice versa.
  */
@@ -425,6 +462,28 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
                 }
                 break;
             }
+
+            case "create_iris_app":
+            case "update_iris_app": {
+                // Update base.json with new/updated Iris app info including content hash
+                updateBase(action.appPath, {
+                    Id: `iris-app:${action.slug}`,
+                    Type: 'IrisApp',
+                    folderName: action.slug,
+                    appName: action.appName,
+                    modifiedOn: new Date().toISOString(),
+                    contentHash: action.contentHash  // Store hash for change detection
+                }, action.appPath);
+                break;
+            }
+
+            case "delete_iris_app": {
+                // Skip if already cleaned from cache during 404 handling
+                if (!operationResult?.cleanedFromCache) {
+                    removeFromBase(`iris-app:${action.slug}`);
+                }
+                break;
+            }
         }
     } catch (error) {
         console.warn(chalk.yellow(`Warning: Failed to update cache for ${action.action}: ${error.message}`));
@@ -444,8 +503,8 @@ const groupActionsByResource = (actionQueue) => {
     for (let i = 0; i < actionQueue.length; i++) {
         const action = { ...actionQueue[i], originalIndex: i };
 
-        // Asset operations don't need sequencing
-        if (['create_static_asset', 'delete_static_asset', 'create_folder', 'delete_folder'].includes(action.action)) {
+        // Asset and Iris app operations don't need sequencing
+        if (['create_static_asset', 'delete_static_asset', 'create_folder', 'delete_folder', 'create_iris_app', 'update_iris_app', 'delete_iris_app'].includes(action.action)) {
             assets.push(action);
             continue;
         }
@@ -544,6 +603,13 @@ const executeAction = async (instanceUrl, token, action) => {
         case "delete_folder":
             result = await handleDeleteFolderAction(instanceUrl, token, action);
             break;
+        case "create_iris_app":
+        case "update_iris_app":
+            result = await handlePublishIrisAppAction(instanceUrl, token, action);
+            break;
+        case "delete_iris_app":
+            result = await handleDeleteIrisAppAction(instanceUrl, token, action);
+            break;
         default:
             throw new Error(`Unknown action: ${action.action}`);
     }
@@ -587,7 +653,8 @@ const performNetworkRequestSequential = async (actionQueue) => {
             console.log();
             console.log(chalk.bgRed.bold.white('  ✖ Operation Failed  '));
             console.log(chalk.redBright('─'.repeat(48)));
-            console.log(chalk.red.bold(`[${i + 1}] ${action.action.toUpperCase()} ${displayName} (${action.filePath || action.folderPath || action.folder}):`));
+            const actionPath = action.filePath || action.folderPath || action.folder || action.appPath || action.slug || 'unknown';
+            console.log(chalk.red.bold(`[${i + 1}] ${action.action.toUpperCase()} ${displayName} (${actionPath}):`));
             console.log(formatMultilineError(error.message));
             console.log(chalk.redBright('─'.repeat(48)));
         }
@@ -693,7 +760,8 @@ const performNetworkRequestParallel = async (actionQueue) => {
                 console.log();
                 console.log(chalk.bgRed.bold.white('  ✖ Operation Failed  '));
                 console.log(chalk.redBright('─'.repeat(48)));
-                console.log(chalk.red.bold(`[${index + 1}] ${action.action.toUpperCase()} ${getActionDisplayName(action)} (${action.filePath || action.folderPath || action.folder}):`));
+                const actionPath = action.filePath || action.folderPath || action.folder || action.appPath || action.slug || 'unknown';
+                console.log(chalk.red.bold(`[${index + 1}] ${action.action.toUpperCase()} ${getActionDisplayName(action)} (${actionPath}):`));
                 console.log(formatMultilineError(error));
                 console.log(chalk.redBright('─'.repeat(48)));
             }
@@ -790,6 +858,7 @@ export const runPublish = async (options = {}) => {
         ...c,
         tag: c.recordId,
         filePath: c.filePath || c.lastKnownPath,
+        type: c.type || c.Type,  // Normalize Type/type property
     }));
     const mapTime = Date.now() - mapStart;
 
@@ -797,11 +866,16 @@ export const runPublish = async (options = {}) => {
         progress.completeStep('load', `✓ Loaded ${cachedFiles.length} entries (${loadTime}ms load, ${mapTime}ms map)`);
     }
 
-    // Step 3: Scan local workspace (excluding Assets folder)
+    // Step 3: Scan local workspace (excluding Assets and iris-apps folders)
     if (progress) progress.startStep('scan');
 
     const walkStart = Date.now();
-    const localPaths = await walkFiles(EXPORT_ROOT, { ignore: [path.join(EXPORT_ROOT, 'Assets')] });
+    const localPaths = await walkFiles(EXPORT_ROOT, {
+        ignore: [
+            path.join(EXPORT_ROOT, 'Assets'),
+            path.join(EXPORT_ROOT, IRIS_APPS_DIR)
+        ]
+    });
     const walkTime = Date.now() - walkStart;
 
     const tagStart = Date.now();
@@ -971,6 +1045,9 @@ export const runPublish = async (options = {}) => {
             // Skip folders - they're handled separately
             if (cacheFile?.type === 'Folder') continue;
 
+            // Skip Iris apps - they're handled separately (check both type and ID prefix)
+            if (cacheFile?.type === 'IrisApp' || id.startsWith('iris-app:')) continue;
+
             // Handle static asset files
             if (cacheFile?.type === 'File') {
                 // Use lastKnownActualPath which has the correct path (e.g., "src/Assets/...")
@@ -1066,6 +1143,94 @@ export const runPublish = async (options = {}) => {
         progress.completeStep('compare-code', `✓ Compared ${allIdsArray.length} code entities`);
     }
 
+    // Step 7b: Scan and compare Iris apps
+    const irisAppsPath = path.join(EXPORT_ROOT, IRIS_APPS_DIR);
+
+    // Get cached Iris apps (always check, even if local folder doesn't exist)
+    // Also include entries with iris-app: prefix in case type wasn't properly set
+    const cachedIrisApps = cachedFiles
+        .filter(cf => cf.type === 'IrisApp' || (cf.tag && cf.tag.startsWith('iris-app:')))
+        .map(cf => {
+            // Extract slug from folderName, or from the ID (iris-app:<slug>)
+            const slug = cf.folderName || (cf.tag && cf.tag.startsWith('iris-app:') ? cf.tag.replace('iris-app:', '') : null);
+            return {
+                slug,
+                appName: cf.appName || slug,
+                modifiedOn: cf.modifiedOn,
+                contentHash: cf.contentHash || null  // Track content hash for change detection
+            };
+        })
+        .filter(app => app.slug); // Filter out any entries without a valid slug
+
+    // Get local Iris apps (empty if folder doesn't exist)
+    const localIrisApps = fs.existsSync(irisAppsPath)
+        ? fs.readdirSync(irisAppsPath, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name)
+        : [];
+
+    const cachedIrisSlugs = new Set(cachedIrisApps.map(a => a.slug));
+    const localIrisSlugs = new Set(localIrisApps);
+
+    // Detect new and modified Iris apps
+    for (const slug of localIrisApps) {
+        const appPath = path.join(irisAppsPath, slug);
+
+        // Validate the app folder has required files
+        const validation = validateIrisAppFolder(appPath);
+        if (!validation.valid) {
+            if (!silent) {
+                console.log(chalk.yellow(`⚠ Skipping invalid Iris app '${slug}': ${validation.errors.join(', ')}`));
+            }
+            continue;
+        }
+
+        // Get app name from linked project config (stored globally) or use slug
+        const linkedProjects = getLinkedProjects();
+        const linkedProject = linkedProjects.find(p => p.slug === slug);
+        const appName = linkedProject?.appName || slug;
+
+        // Calculate content hash for change detection
+        const currentHash = hashIrisAppFolder(appPath);
+
+        // Check if this is a new or existing app
+        const isNew = !cachedIrisSlugs.has(slug);
+
+        if (isNew) {
+            actionQueue.push({
+                action: 'create_iris_app',
+                slug,
+                appName,
+                appPath,
+                contentHash: currentHash
+            });
+        } else {
+            // Only update if content has changed
+            const cachedApp = cachedIrisApps.find(a => a.slug === slug);
+            const contentChanged = !cachedApp?.contentHash || cachedApp.contentHash !== currentHash;
+
+            if (contentChanged) {
+                actionQueue.push({
+                    action: 'update_iris_app',
+                    slug,
+                    appName: linkedProject?.appName || cachedApp?.appName || slug,
+                    appPath,
+                    contentHash: currentHash
+                });
+            }
+        }
+    }
+
+    // Detect deleted Iris apps (works even if iris-apps folder doesn't exist)
+    for (const cachedApp of cachedIrisApps) {
+        if (!localIrisSlugs.has(cachedApp.slug)) {
+            actionQueue.push({
+                action: 'delete_iris_app',
+                slug: cachedApp.slug
+            });
+        }
+    }
+
     // Step 8: Handle brand-new, tag-less files
     if (progress) progress.startStep('prepare');
 
@@ -1146,19 +1311,28 @@ export const runPublish = async (options = {}) => {
                 const num = chalk.green(`[${i + 1}]`);
                 const act = chalk.yellow(a.action.toUpperCase());
 
-                let type, displayPath;
-                if (a.folderName) {
+                let type, displayPath, label;
+                if (a.slug) {
+                    // Iris app action
+                    type = chalk.cyan(`${a.appName || a.slug}`);
+                    displayPath = a.appPath || a.slug;
+                    label = "App";
+                } else if (a.folderName) {
                     type = chalk.cyan(a.folderName);
                     displayPath = a.folderPath;
+                    label = "Folder";
                 } else if (a.names) {
                     type = chalk.cyan(a.names.join(", "));
                     displayPath = a.folder;
+                    label = "File";
                 } else if (a.filePath) {
                     type = chalk.cyan(a.type || path.basename(a.filePath));
                     displayPath = a.filePath;
+                    label = a.type ? "Type" : "File";
                 } else {
                     type = chalk.cyan(a.type || "Unknown");
                     displayPath = a.folder || "Unknown";
+                    label = "File";
                 }
 
                 const idInfo = a.recordId ? ` ${chalk.magenta(a.recordId)}` : "";
@@ -1166,7 +1340,7 @@ export const runPublish = async (options = {}) => {
                     ? ` → ${chalk.gray(a.oldPath)} ${chalk.white("→")} ${chalk.gray(a.filePath)}`
                     : "";
 
-                console.log(`${num} ${act} | ${a.type ? "Type" : (a.folderName ? "Folder" : "File")}: ${type}${idInfo}${renameInfo} (${displayPath})`);
+                console.log(`${num} ${act} | ${label}: ${type}${idInfo}${renameInfo} (${displayPath})`);
             });
 
             console.log(chalk.blue("\n--- Publishing Changes ---"));

package/actions/pull.js

@@ -5,7 +5,7 @@ import fs from "fs";
 import { withSpinner } from "../utils/spinner.js";
 import { ProgressTracker } from "../utils/progress.js";
 import { createLogger, Logger } from "../utils/logger.js";
-import { EXPORT_ROOT, TYPE_DIR_MAP } from "../vars/global.js";
+import { EXPORT_ROOT, TYPE_DIR_MAP, IRIS_APPS_DIR } from "../vars/global.js";
 import { mapRecordToFile, writeRecords } from "../utils/cli/writeRecords.js";
 import { updateBase, removeFromBase, removeFromBaseBulk } from "../utils/updateFileBase.js";
 import { compareAllFilesAndLogStatus, promptConflictResolution, showCurrentConflicts } from "../utils/cli/helpers/compare.js";
@@ -15,6 +15,8 @@ import chalk from 'chalk';
 import { getFileTag, setFileTag } from "../utils/filetag.js";
 import { downloadAssetsZip, listAssets } from "../utils/magentrix/api/assets.js";
 import { downloadAssets, walkAssets } from "../utils/downloadAssets.js";
+import { listApps, downloadApp } from "../utils/magentrix/api/iris.js";
+import { extractIrisZip, hashIrisAppFolder } from "../utils/iris/zipper.js";
 import { v4 as uuidv4 } from 'uuid';
 import readlineSync from 'readline-sync';
 
@@ -55,6 +57,7 @@ export const pull = async () => {
     progress.addStep('load', 'Loading cached data...');
     progress.addStep('download-code', 'Downloading code entities...', { hasProgress: true });
     progress.addStep('download-assets', 'Downloading static assets...', { hasProgress: true });
+    progress.addStep('download-iris', 'Downloading Iris apps...', { hasProgress: true });
     progress.addStep('process', 'Processing files...', { hasProgress: true });
     progress.addStep('conflicts', 'Checking for conflicts...');
     progress.addStep('write', 'Writing files...', { hasProgress: true });
@@ -213,6 +216,92 @@ export const pull = async () => {
             progress.start();
         }
 
+        // Step 4c: Download Iris apps
+        progress.startStep('download-iris');
+        let irisApps = [];
+        const irisDownloadErrors = [];
+
+        try {
+            logger.info('Fetching Iris apps list');
+            const irisListResult = await listApps(instanceUrl, token.value);
+
+            if (irisListResult.success && irisListResult.apps && irisListResult.apps.length > 0) {
+                irisApps = irisListResult.apps;
+                const irisAppsDir = path.resolve(EXPORT_ROOT, IRIS_APPS_DIR);
+
+                // Ensure iris-apps directory exists
+                if (!fs.existsSync(irisAppsDir)) {
+                    fs.mkdirSync(irisAppsDir, { recursive: true });
+                }
+
+                logger.info(`Found ${irisApps.length} Iris apps to download`);
+
+                for (let i = 0; i < irisApps.length; i++) {
+                    const app = irisApps[i];
+                    progress.updateProgress('download-iris', i + 1, irisApps.length, `Downloading ${app.folderName}...`);
+
+                    try {
+                        // Download the app as a buffer
+                        const { buffer } = await downloadApp(instanceUrl, token.value, app.folderName);
+
+                        // Extract to iris-apps directory
+                        const appDir = path.join(irisAppsDir, app.folderName);
+
+                        // Remove existing app directory if it exists
+                        if (fs.existsSync(appDir)) {
+                            fs.rmSync(appDir, { recursive: true, force: true });
+                        }
+
+                        // Extract the zip (it contains a folder with the app name)
+                        await extractIrisZip(buffer, irisAppsDir);
+
+                        // Calculate content hash for change detection
+                        const contentHash = hashIrisAppFolder(appDir);
+
+                        // Update base.json for this Iris app
+                        updateBase(appDir, {
+                            Id: `iris-app:${app.folderName}`,
+                            Type: 'IrisApp',
+                            folderName: app.folderName,
+                            uploadedOn: app.uploadedOn,
+                            modifiedOn: app.modifiedOn,
+                            size: app.size,
+                            contentHash  // Store hash for change detection
+                        }, appDir);
+
+                        logger.info(`Downloaded Iris app: ${app.folderName}`);
+                    } catch (appError) {
+                        // Detect permission errors and provide helpful hint
+                        const isPermissionError = appError.code === 'EACCES' || appError.code === 'EPERM' ||
+                            appError.message?.includes('permission denied') || appError.message?.includes('EACCES');
+
+                        // Create a more informative error message
+                        const errorDetail = appError.message || String(appError);
+                        const errorMsg = `Failed to download Iris app ${app.folderName}: ${errorDetail}`;
+
+                        if (isPermissionError) {
+                            const hint = `Try: sudo chown -R $(whoami):staff "${irisAppsDir}"`;
+                            logger.error(errorMsg, appError, null, hint);
+                            irisDownloadErrors.push({ app: app.folderName, error: appError.message, isPermissionError: true, hint });
+                            progress.addIssue('error', errorMsg, hint);
+                        } else {
+                            logger.error(errorMsg, appError);
+                            irisDownloadErrors.push({ app: app.folderName, error: appError.message });
+                            progress.addIssue('error', errorMsg);
+                        }
+                    }
+                }
+
+                progress.completeStep('download-iris', `✓ Downloaded ${irisApps.length} Iris apps`);
+            } else {
+                progress.completeStep('download-iris', '✓ No Iris apps found');
+            }
+        } catch (error) {
+            logger.error('Error fetching Iris apps', error);
+            irisDownloadErrors.push({ stage: 'iris-list', error: error.message });
+            progress.completeStep('download-iris', '⚠ Iris apps skipped (API may not be available)');
+        }
+
         // Check if we have any data to continue with
         if (!activeClassResult?.Records?.length && !activePageResult?.Records?.length && !assets?.tree?.length) {
             throw new Error('Download failed completely. No data available to continue.');
@@ -300,8 +389,9 @@ export const pull = async () => {
             ]);
 
             // Find code entities in base.json that are no longer on server
+            // Exclude Files, Folders, and IrisApps - only ActiveClass and ActivePage
             const cachedCodeEntities = Object.values(cachedResults).filter(c =>
-                c.type !== 'File' && c.type !== 'Folder' && c.recordId
+                c.type !== 'File' && c.type !== 'Folder' && c.type !== 'IrisApp' && c.recordId
             );
 
             const codeEntitiesToDelete = [];
@@ -355,8 +445,18 @@ export const pull = async () => {
                         logger.info('Deleted code entity', { path: entityPath, type: entity.type });
                     }
                 } catch (err) {
-                    deletionLogs.push({ type: 'error', path: entityPath, error: err.message });
-                    logger.error(`Failed to delete code entity: ${entityPath}`, err);
+                    // Detect permission errors
+                    const isPermissionError = err.code === 'EACCES' || err.code === 'EPERM';
+                    deletionLogs.push({ type: 'error', path: entityPath, error: err.message, isPermissionError });
+
+                    if (isPermissionError) {
+                        const hint = `Try: sudo chown -R $(whoami):staff "${path.dirname(entityPath)}"`;
+                        logger.error(`Failed to delete code entity: ${entityPath}`, err, null, hint);
+                        progress.addIssue('error', `Failed to delete code entity: ${entityPath}`, hint);
+                    } else {
+                        logger.error(`Failed to delete code entity: ${entityPath}`, err);
+                        progress.addIssue('error', `Failed to delete code entity: ${entityPath}`);
+                    }
                 }
             }
 
@@ -546,6 +646,9 @@ export const pull = async () => {
         console.log(chalk.bold(`Summary:`));
         console.log(`   • ${activeClassResult.Records.length} ActiveClass records`);
         console.log(`   • ${activePageResult.Records.length} ActivePage records`);
+        if (irisApps.length > 0) {
+            console.log(`   • ${irisApps.length} Iris apps`);
+        }
         console.log(`   • ${deletionLogs.length} deletions`);
         console.log(`📁 Saved to: ./${EXPORT_ROOT}/`);
 

package/bin/magentrix.js

@@ -15,6 +15,7 @@ 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';
+import { irisLink, irisDev, irisDelete, irisRecover, vueBuildStage } from '../actions/iris/index.js';
 
 // ── Middleware ────────────────────────────────
 async function preMiddleware() {
@@ -60,7 +61,12 @@ program
                 { 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: 'update', desc: 'Update MagentrixCLI to the latest version', icon: '⬆️  ' }
+                { name: 'update', desc: 'Update MagentrixCLI to the latest version', icon: '⬆️  ' },
+                { name: 'iris-link', desc: 'Link a Vue project to the CLI', icon: '🔗 ' },
+                { name: 'vue-build-stage', desc: 'Build Vue project and stage for publish', icon: '🏗️  ' },
+                { name: 'iris-dev', desc: 'Start Vue dev server with platform assets', icon: '🌐 ' },
+                { name: 'iris-delete', desc: 'Delete an Iris app with backup', icon: '🗑️  ' },
+                { name: 'iris-recover', desc: 'Recover a deleted Iris app from backup', icon: '♻️  ' }
             ];
 
             const maxNameLen = Math.max(...commands.map(c => c.name.length));
@@ -191,6 +197,42 @@ program
     .description('Configure CLI settings')
     .action(configWizard);
 
+// Iris commands for Vue.js app management
+program
+    .command('iris-link')
+    .description('Link a Vue project to the CLI for deployment')
+    .option('--path <path>', 'Path to the Vue project')
+    .option('--unlink', 'Unlink a project instead of linking')
+    .option('--list', 'List all linked projects')
+    .option('--cleanup', 'Remove invalid (non-existent) linked projects')
+    .action(irisLink);
+
+program
+    .command('vue-build-stage')
+    .description('Build a Vue project and stage it for publishing')
+    .option('--path <path>', 'Path to the Vue project')
+    .option('--skip-build', 'Skip build step and use existing dist/')
+    .action(vueBuildStage);
+
+program
+    .command('iris-dev')
+    .description('Start Vue dev server with platform assets injected')
+    .option('--path <path>', 'Path to the Vue project')
+    .option('--no-inject', 'Skip asset injection')
+    .option('--restore', 'Restore config.ts from backup')
+    .action(irisDev);
+
+program
+    .command('iris-delete')
+    .description('Delete a published Iris app with recovery backup')
+    .action(irisDelete);
+
+program
+    .command('iris-recover')
+    .description('Recover a deleted Iris app from backup')
+    .option('--list', 'List available recovery backups')
+    .action(irisRecover);
+
 // ── Unknown Command Handler ──────────────────
 program.argument('[command]', 'command to run').action((cmd) => {
     const runMain = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magentrix-corp/magentrix-cli",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "CLI tool for synchronizing local files with Magentrix cloud platform",
   "main": "index.js",
   "type": "module",
@@ -36,6 +36,7 @@
   ],
   "dependencies": {
     "@inquirer/prompts": "^7.6.0",
+    "archiver": "^7.0.1",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",
     "commander": "^14.0.0",

package/utils/autopublishLock.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+
+const LOCK_FILE_NAME = 'autopublish.lock';
+const LOCK_EXPIRY_MS = 3600000; // 1 hour
+
+/**
+ * Get the path to the autopublish lock file.
+ * @returns {string} - Path to lock file
+ */
+export function getLockFilePath() {
+    return path.join(process.cwd(), '.magentrix', LOCK_FILE_NAME);
+}
+
+/**
+ * Check if autopublish is currently running.
+ * @returns {boolean} - True if autopublish is running (lock file exists and is not stale)
+ */
+export function isAutopublishRunning() {
+    const lockFile = getLockFilePath();
+
+    if (!fs.existsSync(lockFile)) return false;
+
+    try {
+        const lockData = JSON.parse(fs.readFileSync(lockFile, 'utf-8'));
+        const lockAge = Date.now() - lockData.timestamp;
+
+        // If lock is older than 1 hour, consider it stale
+        return lockAge < LOCK_EXPIRY_MS;
+    } catch {
+        // If we can't read the lock file, assume it's not running
+        return false;
+    }
+}
+
+/**
+ * Create a lock file to prevent multiple autopublish instances.
+ * @returns {boolean} - True if lock was acquired, false if already locked
+ */
+export function acquireAutopublishLock() {
+    const lockFile = getLockFilePath();
+
+    try {
+        if (fs.existsSync(lockFile)) {
+            // Check if the lock is stale (process might have crashed)
+            if (isAutopublishRunning()) {
+                return false; // Lock is active
+            }
+        }
+
+        // Create lock file
+        fs.mkdirSync(path.dirname(lockFile), { recursive: true });
+        fs.writeFileSync(lockFile, JSON.stringify({
+            pid: process.pid,
+            timestamp: Date.now()
+        }));
+
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+
+/**
+ * Release the autopublish lock file.
+ */
+export function releaseAutopublishLock() {
+    const lockFile = getLockFilePath();
+
+    try {
+        if (fs.existsSync(lockFile)) {
+            fs.unlinkSync(lockFile);
+        }
+    } catch {
+        // Ignore errors during cleanup
+    }
+}

package/utils/cli/helpers/compare.js

@@ -243,13 +243,12 @@ export async function showCurrentConflicts(rootDir, instanceUrl, token, forceCon
 export async function promptConflictResolution(fileIssues) {
     if (!fileIssues.length) return 'skip';
 
-    // Clear for better UX (skip in test mode to avoid clearing test output)
-    if (!process.env.MAGENTRIX_TEST_MODE) {
-        console.clear();
-    }
+    // Add spacing instead of clearing (clearing causes flickering with progress tracker)
+    console.log('\n');
+    console.log(chalk.gray('─'.repeat(48)));
     console.log(
         chalk.bold.yellow(
-            `\n${fileIssues.length} file${fileIssues.length > 1 ? 's' : ''} require conflict resolution:\n`
+            `${fileIssues.length} file${fileIssues.length > 1 ? 's' : ''} require conflict resolution:\n`
         )
     );