@magentrix-corp/magentrix-cli 1.1.4 → 1.2.0

package/actions/publish.js

@@ -2,6 +2,7 @@ import { walkFiles } from "../utils/cacher.js";
 import { ensureValidCredentials } from "../utils/cli/helpers/ensureCredentials.js";
 import Config from "../utils/config.js";
 import { withSpinner } from "../utils/spinner.js";
+import { ProgressTracker } from "../utils/progress.js";
 import fs from "fs";
 import path from "path";
 import chalk from "chalk";
@@ -22,6 +23,17 @@ import { toApiPath, toApiFolderPath } from "../utils/assetPaths.js";
 
 const config = new Config();
 
+/* ==================== CONFIGURATION ==================== */
+
+/**
+ * Set to true to process all operations sequentially (one at a time).
+ * Set to false to process operations in parallel with intelligent grouping.
+ *
+ * Sequential mode is slower but avoids any potential race conditions or
+ * server-side rate limiting issues.
+ */
+const USE_SEQUENTIAL_PROCESSING = true;
+
 /* ==================== UTILITY FUNCTIONS ==================== */
 
 /**
@@ -239,13 +251,15 @@ const handleDeleteFolderAction = async (instanceUrl, apiKey, action) => {
             const cachedResults = hits?.[0]?.value || {};
 
             for (const [recordId, cachedEntry] of Object.entries(cachedResults)) {
-                const entryPath = cachedEntry.filePath || cachedEntry.lastKnownPath;
+                // Check all possible path fields
+                const entryPath = cachedEntry.lastKnownActualPath || cachedEntry.filePath || cachedEntry.lastKnownPath;
                 if (entryPath && typeof entryPath === 'string') {
-                    const normalizedEntryPath = path.normalize(entryPath);
-                    const normalizedFolderPath = path.normalize(action.folderPath);
+                    const normalizedEntryPath = path.normalize(path.resolve(entryPath)).toLowerCase();
+                    const normalizedFolderPath = path.normalize(path.resolve(action.folderPath)).toLowerCase();
 
                     // Check if this entry is inside the deleted folder
-                    if (normalizedEntryPath.startsWith(normalizedFolderPath + path.sep)) {
+                    if (normalizedEntryPath.startsWith(normalizedFolderPath + path.sep) ||
+                        normalizedEntryPath === normalizedFolderPath) {
                         removeFromBase(recordId);
                     }
                 }
@@ -318,7 +332,7 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
             case "delete_folder": {
                 // Skip if already cleaned from cache during 404 handling
                 if (!operationResult?.cleanedFromCache) {
-                    // Remove the folder itself from base
+                    // Remove the folder itself from base using recordId (which is the folderPath)
                     removeFromBase(action.folderPath);
 
                     // Also remove all files and subfolders inside this folder from base
@@ -326,13 +340,15 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
                     const cachedResults = hits?.[0]?.value || {};
 
                     for (const [recordId, cachedEntry] of Object.entries(cachedResults)) {
-                        const entryPath = cachedEntry.filePath || cachedEntry.lastKnownPath;
+                        // Check all possible path fields
+                        const entryPath = cachedEntry.lastKnownActualPath || cachedEntry.filePath || cachedEntry.lastKnownPath;
                         if (entryPath && typeof entryPath === 'string') {
-                            const normalizedEntryPath = path.normalize(entryPath);
-                            const normalizedFolderPath = path.normalize(action.folderPath);
+                            const normalizedEntryPath = path.normalize(path.resolve(entryPath)).toLowerCase();
+                            const normalizedFolderPath = path.normalize(path.resolve(action.folderPath)).toLowerCase();
 
                             // Check if this entry is inside the deleted folder
-                            if (normalizedEntryPath.startsWith(normalizedFolderPath + path.sep)) {
+                            if (normalizedEntryPath.startsWith(normalizedFolderPath + path.sep) ||
+                                normalizedEntryPath === normalizedFolderPath) {
                                 removeFromBase(recordId);
                             }
                         }
@@ -349,54 +365,250 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
 /* ==================== NETWORK REQUEST HANDLER ==================== */
 
 /**
- * Executes all actions in the queue in parallel and handles results/errors.
+ * Groups actions by resource ID to detect conflicts and sequence operations.
+ * @returns {Object} { byResource: Map<recordId, actions[]>, assets: actions[] }
  */
-const performNetworkRequest = async (actionQueue) => {
-    const { instanceUrl, token } = await ensureValidCredentials();
+const groupActionsByResource = (actionQueue) => {
+    const byResource = new Map(); // recordId -> actions[]
+    const assets = []; // Asset operations (can run in parallel)
 
-    const results = await Promise.allSettled(
-        actionQueue.map(async (action, index) => {
-            try {
-                let result;
-                switch (action.action) {
-                    case "create":
-                        result = await handleCreateAction(instanceUrl, token.value, action);
-                        break;
-                    case "update":
-                        result = await handleUpdateAction(instanceUrl, token.value, action);
-                        break;
-                    case "delete":
-                        result = await handleDeleteAction(instanceUrl, token.value, action);
-                        break;
-                    case "create_static_asset":
-                        result = await handleCreateStaticAssetAction(instanceUrl, token.value, action);
-                        break;
-                    case "delete_static_asset":
-                        result = await handleDeleteStaticAssetAction(instanceUrl, token.value, action);
-                        break;
-                    case "create_folder":
-                        result = await handleCreateFolderAction(instanceUrl, token.value, action);
-                        break;
-                    case "delete_folder":
-                        result = await handleDeleteFolderAction(instanceUrl, token.value, action);
-                        break;
-                    default:
-                        throw new Error(`Unknown action: ${action.action}`);
-                }
-                return { index, action, result, success: true };
-            } catch (error) {
-                return { index, action, error: error.message, success: false };
+    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)) {
+            assets.push(action);
+            continue;
+        }
+
+        // Code entity operations - group by recordId
+        const resourceId = action.recordId;
+        if (!resourceId) {
+            // Create actions without recordId yet - treat as unique resource
+            assets.push(action);
+            continue;
+        }
+
+        if (!byResource.has(resourceId)) {
+            byResource.set(resourceId, []);
+        }
+        byResource.get(resourceId).push(action);
+    }
+
+    return { byResource, assets };
+};
+
+/**
+ * Resolves conflicts for a single resource and returns actions to execute in sequence.
+ * Rules:
+ * - If DELETE exists, drop all other actions (delete wins)
+ * - If multiple UPDATEs exist, keep them in order (will execute sequentially)
+ */
+const resolveResourceConflicts = (actions) => {
+    // Check if there's a delete action
+    const hasDelete = actions.some(a => a.action === 'delete');
+
+    if (hasDelete) {
+        // Delete wins - drop all other actions and only keep the delete
+        return actions.filter(a => a.action === 'delete');
+    }
+
+    // No delete - return all actions (they'll execute sequentially)
+    return actions;
+};
+
+/**
+ * Executes actions for a single resource sequentially.
+ */
+const executeResourceActions = async (instanceUrl, token, actions) => {
+    const results = [];
+
+    for (const action of actions) {
+        try {
+            let result;
+            switch (action.action) {
+                case "create":
+                    result = await handleCreateAction(instanceUrl, token, action);
+                    break;
+                case "update":
+                    result = await handleUpdateAction(instanceUrl, token, action);
+                    break;
+                case "delete":
+                    result = await handleDeleteAction(instanceUrl, token, action);
+                    break;
+                default:
+                    throw new Error(`Unknown action: ${action.action}`);
             }
-        })
+            results.push({ index: action.originalIndex, action, result, success: true });
+        } catch (error) {
+            results.push({ index: action.originalIndex, action, error: error.message, success: false });
+        }
+    }
+
+    return results;
+};
+
+/**
+ * Executes a single action and returns the result.
+ */
+const executeAction = async (instanceUrl, token, action) => {
+    let result;
+    switch (action.action) {
+        case "create":
+            result = await handleCreateAction(instanceUrl, token, action);
+            break;
+        case "update":
+            result = await handleUpdateAction(instanceUrl, token, action);
+            break;
+        case "delete":
+            result = await handleDeleteAction(instanceUrl, token, action);
+            break;
+        case "create_static_asset":
+            result = await handleCreateStaticAssetAction(instanceUrl, token, action);
+            break;
+        case "delete_static_asset":
+            result = await handleDeleteStaticAssetAction(instanceUrl, token, action);
+            break;
+        case "create_folder":
+            result = await handleCreateFolderAction(instanceUrl, token, action);
+            break;
+        case "delete_folder":
+            result = await handleDeleteFolderAction(instanceUrl, token, action);
+            break;
+        default:
+            throw new Error(`Unknown action: ${action.action}`);
+    }
+    return result;
+};
+
+/**
+ * Executes all actions sequentially (one at a time) with progress messages.
+ */
+const performNetworkRequestSequential = async (actionQueue) => {
+    const { instanceUrl, token } = await ensureValidCredentials();
+
+    console.log(chalk.blue(`\n🔄 Sequential processing mode (${actionQueue.length} operations)\n`));
+
+    const results = [];
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (let i = 0; i < actionQueue.length; i++) {
+        const action = { ...actionQueue[i], originalIndex: i };
+        const displayName = getActionDisplayName(action);
+
+        // Show progress message
+        console.log(chalk.gray(`[${i + 1}/${actionQueue.length}] Processing ${action.action.toUpperCase()} ${displayName}...`));
+
+        try {
+            const result = await executeAction(instanceUrl, token.value, action);
+            results.push({ index: i, action, result, success: true });
+
+            successCount++;
+            console.log(
+                chalk.green(`✓ [${i + 1}]`) +
+                ` ${chalk.yellow(action.action.toUpperCase())} ${chalk.cyan(displayName)} ` +
+                (result?.recordId ? chalk.magenta(result.recordId) : "")
+            );
+            await updateCacheAfterSuccess(action, result);
+        } catch (error) {
+            results.push({ index: i, action, error: error.message, success: false });
+
+            errorCount++;
+            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}):`));
+            console.log(formatMultilineError(error.message));
+            console.log(chalk.redBright('─'.repeat(48)));
+        }
+
+        console.log(); // Add spacing between operations
+    }
+
+    // Summary
+    console.log(chalk.blue("--- Publish Summary ---"));
+    console.log(chalk.green(`✓ Successful: ${successCount}`));
+    if (errorCount > 0) {
+        console.log(chalk.red(`✗ Failed: ${errorCount}`));
+    } else {
+        console.log(chalk.green("All operations completed successfully! 🎉"));
+    }
+};
+
+/**
+ * Executes all actions in the queue with proper sequencing and conflict resolution (parallel mode).
+ */
+const performNetworkRequestParallel = async (actionQueue) => {
+    const { instanceUrl, token } = await ensureValidCredentials();
+
+    // Group actions by resource
+    const { byResource, assets } = groupActionsByResource(actionQueue);
+
+    // Resolve conflicts for each resource
+    const sequencedCodeActions = [];
+    const droppedActions = [];
+
+    for (const [resourceId, actions] of byResource.entries()) {
+        const resolved = resolveResourceConflicts(actions);
+        sequencedCodeActions.push(resolved);
+
+        // Track dropped actions
+        const droppedCount = actions.length - resolved.length;
+        if (droppedCount > 0) {
+            const dropped = actions.filter(a => !resolved.includes(a));
+            droppedActions.push(...dropped);
+        }
+    }
+
+    // Log dropped actions
+    if (droppedActions.length > 0) {
+        console.log(chalk.yellow(`\n⚠️  Dropped ${droppedActions.length} redundant operation(s) due to delete:`));
+        droppedActions.forEach(action => {
+            console.log(chalk.gray(`   • ${action.action.toUpperCase()} on ${getActionDisplayName(action)} (superseded by DELETE)`));
+        });
+    }
+
+    // Execute asset operations in parallel (they don't conflict)
+    const assetPromises = assets.map(async (action) => {
+        try {
+            const result = await executeAction(instanceUrl, token.value, action);
+            return { index: action.originalIndex, action, result, success: true };
+        } catch (error) {
+            return { index: action.originalIndex, action, error: error.message, success: false };
+        }
+    });
+
+    // Execute code entity operations sequentially per resource (but resources in parallel)
+    const codePromises = sequencedCodeActions.map(actions =>
+        executeResourceActions(instanceUrl, token.value, actions)
     );
 
+    // Wait for all operations
+    const assetResults = await Promise.allSettled(assetPromises);
+    const codeResults = await Promise.allSettled(codePromises);
+
+    // Flatten code results
+    const allCodeResults = codeResults
+        .filter(r => r.status === 'fulfilled')
+        .flatMap(r => r.value);
+
+    const allAssetResults = assetResults
+        .map(r => r.status === 'fulfilled' ? r.value : { status: 'rejected', reason: r.reason });
+
+    // Combine all results
+    const allResults = [...allCodeResults, ...allAssetResults];
+
+    // Sort by original index to maintain order
+    allResults.sort((a, b) => (a.index || 0) - (b.index || 0));
+
     // Process and display results
     let successCount = 0;
     let errorCount = 0;
 
-    for (const result of results) {
-        if (result.status === "fulfilled") {
-            const { index, action, success, error, result: operationResult } = result.value;
+    for (const result of allResults) {
+        if (result.success !== undefined) {
+            const { index, action, success, error, result: operationResult } = result;
 
             if (success) {
                 successCount++;
@@ -416,7 +628,7 @@ const performNetworkRequest = async (actionQueue) => {
                 console.log(formatMultilineError(error));
                 console.log(chalk.redBright('─'.repeat(48)));
             }
-        } else {
+        } else if (result.status === 'rejected') {
             errorCount++;
             console.log();
             console.log(chalk.bgRed.bold.white('  ✖ Unexpected Error  '));
@@ -429,6 +641,9 @@ const performNetworkRequest = async (actionQueue) => {
     // Summary
     console.log(chalk.blue("\n--- Publish Summary ---"));
     console.log(chalk.green(`✓ Successful: ${successCount}`));
+    if (droppedActions.length > 0) {
+        console.log(chalk.yellow(`⊝ Dropped: ${droppedActions.length} (redundant)`));
+    }
     if (errorCount > 0) {
         console.log(chalk.red(`✗ Failed: ${errorCount}`));
     } else {
@@ -436,6 +651,17 @@ const performNetworkRequest = async (actionQueue) => {
     }
 };
 
+/**
+ * Executes all actions in the queue (dispatcher function).
+ */
+const performNetworkRequest = async (actionQueue) => {
+    if (USE_SEQUENTIAL_PROCESSING) {
+        return await performNetworkRequestSequential(actionQueue);
+    } else {
+        return await performNetworkRequestParallel(actionQueue);
+    }
+};
+
 /* ==================== MAIN PUBLISH LOGIC ==================== */
 
 /**
@@ -447,34 +673,69 @@ const performNetworkRequest = async (actionQueue) => {
 export const runPublish = async (options = {}) => {
     const { silent = false } = options;
 
+    // Create progress tracker
+    const progress = silent ? null : new ProgressTracker('Publish to Magentrix');
+    if (progress) {
+        progress.addStep('auth', 'Authenticating...');
+        progress.addStep('load', 'Loading cached data...');
+        progress.addStep('scan', 'Scanning local files...');
+        progress.addStep('compare-assets', 'Comparing assets...', { hasProgress: true });
+        progress.addStep('compare-code', 'Comparing code entities...', { hasProgress: true });
+        progress.addStep('prepare', 'Preparing action queue...');
+        progress.start();
+        // Start first step immediately so UI shows up
+        progress.startStep('auth');
+    }
+
     // Step 1: Authenticate
     await ensureValidCredentials().catch((err) => {
-        if (!silent) {
+        if (progress) {
+            progress.abort(err.message);
+        } else if (!silent) {
             console.error(chalk.red.bold("Authentication failed:"), chalk.white(err.message));
         }
         throw err;
     });
+    if (progress) progress.completeStep('auth', '✓ Authenticated');
 
     // Step 2: Load cached file state
+    if (progress) progress.startStep('load');
+
+    const loadStart = Date.now();
     const hits = await config.searchObject({}, { filename: "base.json", global: false });
     const cachedResults = hits?.[0]?.value || {};
+    const loadTime = Date.now() - loadStart;
 
     if (!Object.keys(cachedResults).length) {
-        if (!silent) {
+        if (progress) {
+            progress.abort('No file cache found');
+        } else if (!silent) {
             console.log(chalk.red.bold("No file cache found!"));
             console.log(`Run ${chalk.cyan("magentrix pull")} to initialize your workspace.`);
         }
         throw new Error("No file cache found");
     }
 
+    const mapStart = Date.now();
     const cachedFiles = Object.values(cachedResults).map((c) => ({
         ...c,
         tag: c.recordId,
         filePath: c.filePath || c.lastKnownPath,
     }));
+    const mapTime = Date.now() - mapStart;
+
+    if (progress) {
+        progress.completeStep('load', `✓ Loaded ${cachedFiles.length} entries (${loadTime}ms load, ${mapTime}ms map)`);
+    }
 
     // Step 3: Scan local workspace (excluding Assets folder)
+    if (progress) progress.startStep('scan');
+
+    const walkStart = Date.now();
     const localPaths = await walkFiles(EXPORT_ROOT, { ignore: [path.join(EXPORT_ROOT, 'Assets')] });
+    const walkTime = Date.now() - walkStart;
+
+    const tagStart = Date.now();
     const localFiles = await Promise.all(
         localPaths.map(async (p) => {
             try {
@@ -485,19 +746,59 @@ export const runPublish = async (options = {}) => {
             }
         })
     );
+    const tagTime = Date.now() - tagStart;
+
+    if (progress) {
+        progress.completeStep('scan', `✓ Found ${localPaths.length} files (${walkTime}ms walk, ${tagTime}ms tags)`);
+    }
 
     // Step 4: Create lookup maps
+    if (progress) progress.startStep('compare-assets');
+
+    const mapBuildStart = Date.now();
     const cacheById = Object.fromEntries(cachedFiles.map((c) => [c.tag, c]));
     const localById = Object.fromEntries(localFiles.filter((f) => f.tag).map((f) => [f.tag, f]));
     const newLocalNoId = localFiles.filter((f) => !f.tag);
     const allIds = new Set([...Object.keys(cacheById), ...Object.keys(localById)]);
+    const mapBuildTime = Date.now() - mapBuildStart;
 
     const actionQueue = [];
 
-    // Step 5: Handle static asset files
+    // Step 5: Handle static asset files - Build fast lookup map first (O(n) instead of O(n²))
+    const assetWalkStart = Date.now();
     const assetPaths = await walkFiles(path.join(EXPORT_ROOT, 'Assets'));
-    for (const assetPath of assetPaths) {
-        if (cachedFiles.find(cr => cr.filePath?.toLowerCase() === assetPath.toLowerCase())) {
+    const assetWalkTime = Date.now() - assetWalkStart;
+
+    // Build a Set of normalized cached asset paths for O(1) lookup
+    const setStart = Date.now();
+    const cachedAssetPaths = new Set();
+    cachedFiles
+        .filter(cf => cf.type === 'File' || cf.type === 'Folder')
+        .forEach(cf => {
+            if (cf.lastKnownActualPath) {
+                cachedAssetPaths.add(path.normalize(path.resolve(cf.lastKnownActualPath)).toLowerCase());
+            }
+            if (cf.filePath) {
+                cachedAssetPaths.add(path.normalize(path.resolve(cf.filePath)).toLowerCase());
+            }
+            if (cf.lastKnownPath) {
+                cachedAssetPaths.add(path.normalize(path.resolve(cf.lastKnownPath)).toLowerCase());
+            }
+        });
+    const setTime = Date.now() - setStart;
+
+    // Now compare assets with O(1) lookup
+    for (let i = 0; i < assetPaths.length; i++) {
+        const assetPath = assetPaths[i];
+        const normalizedAssetPath = path.normalize(path.resolve(assetPath)).toLowerCase();
+
+        // Update progress every 100 files
+        if (progress && i % 100 === 0) {
+            progress.updateProgress('compare-assets', i, assetPaths.length, `Checking ${i}/${assetPaths.length} assets`);
+        }
+
+        // O(1) lookup instead of O(n) find()
+        if (cachedAssetPaths.has(normalizedAssetPath)) {
             continue;
         }
 
@@ -508,17 +809,43 @@ export const runPublish = async (options = {}) => {
         });
     }
 
-    // Step 6: Handle folder creation and deletion
+    if (progress) {
+        progress.completeStep('compare-assets', `✓ Compared ${assetPaths.length} assets (walk:${assetWalkTime}ms, set:${setTime}ms, map:${mapBuildTime}ms)`);
+    }
+
+    // Step 6: Handle folder creation and deletion - Also optimized with Set
     const assetsDir = path.join(EXPORT_ROOT, 'Assets');
     if (fs.existsSync(assetsDir)) {
         const localFolders = walkFolders(assetsDir);
         const cachedFolders = cachedFiles
-            .filter(c => c.type === 'Folder' && (c.filePath || c.lastKnownPath))
-            .map(c => c.filePath || c.lastKnownPath);
+            .filter(c => c.type === 'Folder' && (c.filePath || c.lastKnownPath || c.lastKnownActualPath));
+
+        // Build Set of cached folder paths for O(1) lookup
+        const cachedFolderPaths = new Set();
+        cachedFolders.forEach(cf => {
+            if (cf.lastKnownActualPath) {
+                cachedFolderPaths.add(path.normalize(path.resolve(cf.lastKnownActualPath)).toLowerCase());
+            }
+            if (cf.lastKnownPath) {
+                cachedFolderPaths.add(path.normalize(path.resolve(cf.lastKnownPath)).toLowerCase());
+            }
+            if (cf.filePath) {
+                cachedFolderPaths.add(path.normalize(path.resolve(cf.filePath)).toLowerCase());
+            }
+        });
+
+        // Build Set of local folder paths for O(1) lookup
+        const localFolderPaths = new Set(
+            localFolders.map(lf => path.normalize(path.resolve(lf)).toLowerCase())
+        );
 
-        // New folders
+        // New folders - O(1) lookup
         for (const folderPath of localFolders) {
-            if (!folderPath || cachedFolders.find(cf => cf?.toLowerCase() === folderPath.toLowerCase())) {
+            if (!folderPath) continue;
+
+            const normalizedFolderPath = path.normalize(path.resolve(folderPath)).toLowerCase();
+
+            if (cachedFolderPaths.has(normalizedFolderPath)) {
                 continue;
             }
 
@@ -533,27 +860,41 @@ export const runPublish = async (options = {}) => {
             });
         }
 
-        // Deleted folders
+        // Deleted folders - O(1) lookup
         for (const cachedFolder of cachedFolders) {
-            if (!cachedFolder || typeof cachedFolder !== 'string') continue;
-            if (localFolders.find(lf => lf?.toLowerCase() === cachedFolder.toLowerCase())) {
+            const cachedPath = cachedFolder.lastKnownActualPath || cachedFolder.lastKnownPath || cachedFolder.filePath;
+            if (!cachedPath || typeof cachedPath !== 'string') continue;
+
+            const normalizedCachedPath = path.normalize(path.resolve(cachedPath)).toLowerCase();
+
+            if (localFolderPaths.has(normalizedCachedPath)) {
                 continue;
             }
 
-            const parentDir = path.dirname(cachedFolder);
-            if (!parentDir || parentDir === '.' || parentDir === cachedFolder) continue;
+            const parentDir = path.dirname(cachedPath);
+            if (!parentDir || parentDir === '.' || parentDir === cachedPath) continue;
 
             actionQueue.push({
                 action: "delete_folder",
-                folderPath: cachedFolder,
+                folderPath: cachedPath,
                 parentPath: toApiFolderPath(parentDir),
-                folderName: path.basename(cachedFolder)
+                folderName: path.basename(cachedPath)
             });
         }
     }
 
     // Step 7: Process code entities (ActiveClass/ActivePage) and static assets
-    for (const id of allIds) {
+    if (progress) progress.startStep('compare-code');
+
+    const allIdsArray = Array.from(allIds);
+    for (let idx = 0; idx < allIdsArray.length; idx++) {
+        const id = allIdsArray[idx];
+
+        // Update progress every 50 items
+        if (progress && idx % 50 === 0) {
+            progress.updateProgress('compare-code', idx, allIdsArray.length, `Checking ${idx}/${allIdsArray.length} entities`);
+        }
+
         try {
             const cacheFile = cacheById[id];
             const curFile = localById[id];
@@ -563,24 +904,26 @@ export const runPublish = async (options = {}) => {
 
             // Handle static asset files
             if (cacheFile?.type === 'File') {
-                const localAssetExists = fs.existsSync(cacheFile.filePath);
+                // Use lastKnownActualPath which has the correct path (e.g., "src/Assets/...")
+                const actualPath = cacheFile.lastKnownActualPath || cacheFile.filePath;
+                const localAssetExists = fs.existsSync(actualPath);
 
                 if (!localAssetExists) {
                     actionQueue.push({
                         action: 'delete_static_asset',
-                        folder: toApiPath(cacheFile.filePath),
-                        names: [path.basename(cacheFile.filePath)],
-                        filePath: cacheFile.filePath // Store actual file path for filtering
+                        folder: toApiPath(actualPath),
+                        names: [path.basename(actualPath)],
+                        filePath: actualPath // Store actual file path for filtering
                     });
                     continue;
                 }
 
-                const contentHash = sha256(fs.readFileSync(cacheFile.filePath, 'utf-8'));
+                const contentHash = sha256(fs.readFileSync(actualPath, 'utf-8'));
                 if (contentHash !== cacheFile.contentHash) {
                     actionQueue.push({
                         action: "create_static_asset",
-                        folder: toApiPath(cacheFile.filePath),
-                        filePath: cacheFile.filePath
+                        folder: toApiPath(actualPath),
+                        filePath: actualPath
                     });
                 }
                 continue;
@@ -644,15 +987,25 @@ export const runPublish = async (options = {}) => {
                 }
             }
         } catch (err) {
-            console.error(chalk.yellow(`Warning: Error processing file with ID ${id}:`), err.message);
+            if (!silent) {
+                console.error(chalk.yellow(`Warning: Error processing file with ID ${id}:`), err.message);
+            }
         }
     }
 
+    if (progress) {
+        progress.completeStep('compare-code', `✓ Compared ${allIdsArray.length} code entities`);
+    }
+
     // Step 8: Handle brand-new, tag-less files
+    if (progress) progress.startStep('prepare');
+
     for (const f of newLocalNoId) {
         const safe = readFileSafe(f.path);
         if (!safe) {
-            console.log(chalk.yellow(`Skipping unreadable file: ${f.path}`));
+            if (!silent) {
+                console.log(chalk.yellow(`Skipping unreadable file: ${f.path}`));
+            }
             continue;
         }
 
@@ -709,6 +1062,11 @@ export const runPublish = async (options = {}) => {
         return true;
     });
 
+    if (progress) {
+        progress.completeStep('prepare', `✓ Prepared ${filteredActionQueue.length} actions`);
+        progress.finish();
+    }
+
     // Step 10: Display and execute action queue
     if (!silent) {
         console.log(chalk.blue("\n--- Publish Action Queue ---"));