@magentrix-corp/magentrix-cli 1.0.1 → 1.1.0

package/actions/publish.js

@@ -11,196 +11,114 @@ import {
     EXPORT_ROOT,
     TYPE_DIR_MAP,
 } from "../vars/global.js";
-import {
-    getFileTag,
-} from "../utils/filetag.js";
+import { getFileTag, setFileTag } from "../utils/filetag.js";
 import { sha256 } from "../utils/hash.js";
 import { createEntity } from "../utils/magentrix/api/createEntity.js";
 import { updateEntity } from "../utils/magentrix/api/updateEntity.js";
 import { deleteEntity } from "../utils/magentrix/api/deleteEntity.js";
-import { setFileTag } from "../utils/filetag.js";
 import { removeFromBase, updateBase } from "../utils/updateFileBase.js";
-import { deleteAsset, uploadAsset } from "../utils/magentrix/api/assets.js";
-import { decompressString } from "../utils/compress.js";
+import { deleteAsset, uploadAsset, createFolder } from "../utils/magentrix/api/assets.js";
+import { toApiPath, toApiFolderPath } from "../utils/assetPaths.js";
 
 const config = new Config();
 
-/* ---------- Helper utilities ---------- */
+/* ==================== UTILITY FUNCTIONS ==================== */
 
 /**
- * Given a file path, return { type, entity, contentField } for Magentrix.
+ * Infers Magentrix entity metadata from a file path by walking up the directory tree.
+ * @param {string} filePath - The file path to analyze
+ * @returns {Object} { type, entity, contentField } for Magentrix API
  */
 const inferMeta = (filePath) => {
-    const parentFolder = path.basename(path.dirname(filePath));
-    const type = Object.keys(TYPE_DIR_MAP).find(
-        (k) => TYPE_DIR_MAP[k].directory === parentFolder
-    );
-    return {
-        type,
-        entity: ENTITY_TYPE_MAP[type],
-        contentField: ENTITY_FIELD_MAP[type],
-    };
+    let currentPath = path.dirname(filePath);
+    const exportRootAbs = path.resolve(EXPORT_ROOT);
+
+    while (currentPath.startsWith(exportRootAbs)) {
+        const folderName = path.basename(currentPath);
+        const type = Object.keys(TYPE_DIR_MAP).find(
+            (k) => TYPE_DIR_MAP[k].directory === folderName
+        );
+
+        if (type) {
+            return {
+                type,
+                entity: ENTITY_TYPE_MAP[type],
+                contentField: ENTITY_FIELD_MAP[type],
+            };
+        }
+
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) break; // Reached root
+        currentPath = parentPath;
+    }
+
+    return { type: undefined, entity: undefined, contentField: undefined };
 };
 
 /**
- * Safely read file content and hash; returns null on failure.
+ * Safely reads file content and computes hash.
+ * @param {string} filePath - Path to the file
+ * @returns {Object|null} { content, hash } or null on error
  */
 const readFileSafe = (filePath) => {
     try {
         const content = fs.readFileSync(filePath, "utf-8");
         return { content, hash: sha256(content) };
     } catch (err) {
-        console.error(
-            chalk.red.bold("Error:") +
-            " Unable to read file " +
-            chalk.white.bold(filePath)
-        );
-        console.error(
-            chalk.gray("→ Please verify the file exists and you have read permissions.")
-        );
+        console.error(chalk.red.bold("Error:") + " Unable to read file " + chalk.white.bold(filePath));
+        console.error(chalk.gray("→ Please verify the file exists and you have read permissions."));
         return null;
     }
 };
 
+/**
+ * Formats multiline error messages with proper indentation.
+ */
 const formatMultilineError = (err) => {
-    // Ensure it's a string and split into lines
     const lines = String(err).split(/\r?\n/);
-    // First line gets the bullet, rest get indentation
     return lines
         .map((line, i) => {
-            const prefix = i === 0 ? `${chalk.redBright('  •')} ` : '    '; // 4 spaces indent
+            const prefix = i === 0 ? `${chalk.redBright('  •')} ` : '    ';
             return prefix + chalk.whiteBright(line);
         })
         .join('\n');
 };
 
-const getFolderFromPath = (filePath) => {
-    const fileFolderPath = filePath
-        .split("/")
-        .filter((x, i) => !(x === EXPORT_ROOT && i === 0))
-        .slice(0, -1)
-        .join("/");
-
-    return fileFolderPath;
-}
-
-/* ---------- Network operations ---------- */
-
 /**
- * Executes all actions in the queue in parallel and handles results/errors.
- * Updates cache after successful operations.
+ * Recursively walks a directory and returns all subdirectory paths.
  */
-const performNetworkRequest = async (actionQueue) => {
-    const { instanceUrl, token } = await ensureValidCredentials();
-
-    // Execute all operations 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;
-                    default:
-                        throw new Error(`Unknown action: ${action.action}`);
-                }
-                return { index, action, result, success: true };
-            } catch (error) {
-                return { index, action, error: error.message, success: false };
-            }
-        })
-    );
-
-    // Process results
-    let successCount = 0;
-    let errorCount = 0;
-    const errors = [];
+const walkFolders = (dir) => {
+    if (!fs.existsSync(dir)) return [];
 
-    for (const result of results) {
-        if (result.status === "fulfilled") {
-            const { index, action, success, error, result: operationResult } = result.value;
-            if (success) {
-                successCount++;
-                console.log(
-                    chalk.green(`✓ [${index + 1}]`) +
-                    ` ${chalk.yellow(action.action.toUpperCase())} ${chalk.cyan(action.type || action?.names?.join(", ") || path.basename(action.filePath) || '')} ` +
-                    (operationResult?.recordId ? chalk.magenta(operationResult.recordId) : "")
-                );
+    const folders = [];
+    const items = fs.readdirSync(dir, { withFileTypes: true });
 
-                // Update cache and file tags after successful operations
-                await updateCacheAfterSuccess(action, operationResult);
-            } else {
-                errorCount++;
-                errors.push({ index: index + 1, action, error });
-
-                // Enhanced error display matching autopublish.js style
-                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()} ${action.type || action?.names?.join(", ") || ''} (${action.filePath || action.folder}):`)
-                );
-                // console.log(`${chalk.redBright('  •')} ${chalk.whiteBright(error)}`);
-                console.log(formatMultilineError(error));
-                console.log(chalk.redBright('─'.repeat(48)));
-            }
-        } else {
-            // Promise rejection (shouldn't happen with allSettled, but just in case)
-            errorCount++;
-            console.log();
-            console.log(chalk.bgRed.bold.white('  ✖ Unexpected Error  '));
-            console.log(chalk.redBright('─'.repeat(48)));
-            console.log(`${chalk.redBright('  •')} ${chalk.whiteBright(result.reason)}`);
-            console.log(chalk.redBright('─'.repeat(48)));
+    for (const item of items) {
+        if (item.isDirectory()) {
+            const fullPath = path.join(dir, item.name);
+            folders.push(fullPath);
+            folders.push(...walkFolders(fullPath));
         }
     }
 
-    // Summary
-    console.log(chalk.blue("\n--- Publish Summary ---"));
-    console.log(chalk.green(`✓ Successful: ${successCount}`));
-    if (errorCount > 0) {
-        console.log(chalk.red(`✗ Failed: ${errorCount}`));
-        // console.log(chalk.yellow("\nErrors encountered:"));
-        // errors.forEach(({ index, action, error }) => {
-        //     console.log(`  [${index}] ${action.action.toUpperCase()} ${action.type}: ${error}`);
-        // });
-    } else {
-        console.log(chalk.green("All operations completed successfully! 🎉"));
-    }
+    return folders;
 };
 
-const handleCreateStaticAssetAction = async (instanceUrl, apiKey, action) => {
-    const r = await uploadAsset(
-        instanceUrl,
-        apiKey,
-        `/${action.folder}`,
-        [action.filePath]
-    ).catch(err => ({ error: err.message }));
-    if (r?.error) throw new Error(r.error);
-    return r;
-}
+/**
+ * Gets display name for an action in log messages.
+ */
+const getActionDisplayName = (action) => {
+    if (action.folderName) return action.folderName;
+    if (action.names) return action.names.join(", ");
+    if (action.type) return action.type;
+    if (action.filePath) return path.basename(action.filePath);
+    return '';
+};
 
-const handleDeleteStaticAssetAction = async (instanceUrl, apiKey, action) => {
-    const response = await deleteAsset(instanceUrl, apiKey, `/${action.folder}`, action.names).catch(err => ({ error: err.message }));
-    if (response?.error) throw new Error(response.error);
-    return response;
-}
+/* ==================== ACTION HANDLERS ==================== */
 
 /**
- * Handle create action
+ * Handles CREATE action for code entities (ActiveClass/ActivePage).
  */
 const handleCreateAction = async (instanceUrl, apiKey, action) => {
     const data = {
@@ -214,38 +132,69 @@ const handleCreateAction = async (instanceUrl, apiKey, action) => {
 };
 
 /**
- * Handle update action
+ * Handles UPDATE action for code entities (ActiveClass/ActivePage).
  */
 const handleUpdateAction = async (instanceUrl, apiKey, action) => {
-    const data = {
-        ...action.fields
-    };
+    const data = { ...action.fields };
 
-    // If renamed, update the Name field
     if (action.renamed) {
         data.Name = path.basename(action.filePath, path.extname(action.filePath));
     }
 
-    const result = await updateEntity(instanceUrl, apiKey, action.entity, action.recordId, data);
+    await updateEntity(instanceUrl, apiKey, action.entity, action.recordId, data);
     return { recordId: action.recordId };
 };
 
 /**
- * Handle delete action
+ * Handles DELETE action for code entities (ActiveClass/ActivePage).
  */
 const handleDeleteAction = async (instanceUrl, apiKey, action) => {
-    const r = await deleteEntity(instanceUrl, apiKey, action.entity, action.recordId);
-    return r;
+    return await deleteEntity(instanceUrl, apiKey, action.entity, action.recordId);
+};
+
+/**
+ * Handles CREATE_STATIC_ASSET action.
+ */
+const handleCreateStaticAssetAction = async (instanceUrl, apiKey, action) => {
+    const response = await uploadAsset(instanceUrl, apiKey, `/${action.folder}`, [action.filePath]);
+    if (response?.error) throw new Error(response.error);
+    return response;
+};
+
+/**
+ * Handles DELETE_STATIC_ASSET action.
+ */
+const handleDeleteStaticAssetAction = async (instanceUrl, apiKey, action) => {
+    const response = await deleteAsset(instanceUrl, apiKey, `/${action.folder}`, action.names);
+    if (response?.error) throw new Error(response.error);
+    return response;
 };
 
 /**
- * Update cache and file tags after successful operations
+ * Handles CREATE_FOLDER action.
+ */
+const handleCreateFolderAction = async (instanceUrl, apiKey, action) => {
+    const response = await createFolder(instanceUrl, apiKey, action.parentPath, action.folderName);
+    if (response?.error) throw new Error(response.error);
+    return response;
+};
+
+/**
+ * Handles DELETE_FOLDER action.
+ */
+const handleDeleteFolderAction = async (instanceUrl, apiKey, action) => {
+    const response = await deleteAsset(instanceUrl, apiKey, action.parentPath, [action.folderName]);
+    if (response?.error) throw new Error(response.error);
+    return response;
+};
+
+/**
+ * Updates cache after successful operations.
  */
 const updateCacheAfterSuccess = async (action, operationResult) => {
     try {
         switch (action.action) {
-            case "create":
-                // Tag the file and update base with the content that was actually published
+            case "create": {
                 const createSnapshot = action.fields && Object.values(action.fields)[0]
                     ? { content: Object.values(action.fields)[0], hash: action.contentHash }
                     : null;
@@ -257,19 +206,21 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
                     createSnapshot
                 );
                 break;
+            }
 
-            case "update":
-                // Pass the content snapshot that was actually published to prevent race conditions
+            case "update": {
                 const updateSnapshot = action.fields && Object.values(action.fields)[0]
                     ? { content: Object.values(action.fields)[0], hash: sha256(Object.values(action.fields)[0]) }
                     : null;
+                const type = Object.keys(ENTITY_TYPE_MAP).find(key => ENTITY_TYPE_MAP[key] === action.entity);
                 updateBase(
                     action.filePath,
-                    { Id: action.recordId, Type: Object.keys(ENTITY_TYPE_MAP).find(key => ENTITY_TYPE_MAP[key] === action.entity) },
+                    { Id: action.recordId, Type: type },
                     '',
                     updateSnapshot
                 );
                 break;
+            }
 
             case "delete":
                 removeFromBase(action.recordId);
@@ -284,51 +235,137 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
             case "create_static_asset":
                 updateBase(action.filePath, { Id: action.filePath, Type: "File" });
                 break;
+
+            case "create_folder":
+                updateBase(action.folderPath, { Id: action.folderPath, Type: "Folder" });
+                break;
+
+            case "delete_folder":
+                removeFromBase(action.folderPath);
+                break;
         }
     } catch (error) {
         console.warn(chalk.yellow(`Warning: Failed to update cache for ${action.action}: ${error.message}`));
     }
 };
 
-/* ---------- Main publish routine ---------- */
+/* ==================== NETWORK REQUEST HANDLER ==================== */
 
 /**
- * Core publish logic - can be called from autopublish or directly
- * @param {Object} options - Configuration options
- * @param {boolean} options.silent - If true, suppress summary output
- * @param {boolean} options.skipAuth - If true, skip authentication (caller handles it)
- * @param {Object} options.credentials - Pre-authenticated credentials {instanceUrl, token}
- * @returns {Promise<{actionQueue: Array, results: Object}>}
+ * Executes all actions in the queue in parallel and handles results/errors.
  */
-export const runPublish = async (options = {}) => {
-    const { silent = false, skipAuth = false, credentials = null } = options;
+const performNetworkRequest = async (actionQueue) => {
+    const { instanceUrl, token } = await ensureValidCredentials();
 
-    /* 1 — Authenticate (unless skipped) */
-    let authCreds;
-    if (skipAuth && credentials) {
-        authCreds = credentials;
-    } else {
-        authCreds = await ensureValidCredentials().catch((err) => {
-            if (!silent) {
-                console.error(
-                    chalk.red.bold("Authentication failed:"),
-                    chalk.white(err.message)
+    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 };
+            }
+        })
+    );
+
+    // 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;
+
+            if (success) {
+                successCount++;
+                const displayName = getActionDisplayName(action);
+                console.log(
+                    chalk.green(`✓ [${index + 1}]`) +
+                    ` ${chalk.yellow(action.action.toUpperCase())} ${chalk.cyan(displayName)} ` +
+                    (operationResult?.recordId ? chalk.magenta(operationResult.recordId) : "")
                 );
+                await updateCacheAfterSuccess(action, operationResult);
+            } else {
+                errorCount++;
+                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}):`));
+                console.log(formatMultilineError(error));
+                console.log(chalk.redBright('─'.repeat(48)));
             }
-            throw err;
-        });
+        } else {
+            errorCount++;
+            console.log();
+            console.log(chalk.bgRed.bold.white('  ✖ Unexpected Error  '));
+            console.log(chalk.redBright('─'.repeat(48)));
+            console.log(`${chalk.redBright('  •')} ${chalk.whiteBright(result.reason)}`);
+            console.log(chalk.redBright('─'.repeat(48)));
+        }
     }
 
-    /* 2 — Load previous cache */
+    // Summary
+    console.log(chalk.blue("\n--- 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! 🎉"));
+    }
+};
+
+/* ==================== MAIN PUBLISH LOGIC ==================== */
+
+/**
+ * Core publish logic - can be called from autopublish or directly.
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.silent - If true, suppress summary output
+ * @returns {Promise<{actionQueue: Array, hasChanges: boolean}>}
+ */
+export const runPublish = async (options = {}) => {
+    const { silent = false } = options;
+
+    // Step 1: Authenticate
+    await ensureValidCredentials().catch((err) => {
+        if (!silent) {
+            console.error(chalk.red.bold("Authentication failed:"), chalk.white(err.message));
+        }
+        throw err;
+    });
+
+    // Step 2: Load cached file state
     const hits = await config.searchObject({}, { filename: "base.json", global: false });
     const cachedResults = hits?.[0]?.value || {};
 
     if (!Object.keys(cachedResults).length) {
         if (!silent) {
             console.log(chalk.red.bold("No file cache found!"));
-            console.log(
-                `Run ${chalk.cyan("magentrix pull")} to initialize your workspace.`
-            );
+            console.log(`Run ${chalk.cyan("magentrix pull")} to initialize your workspace.`);
         }
         throw new Error("No file cache found");
     }
@@ -336,99 +373,124 @@ export const runPublish = async (options = {}) => {
     const cachedFiles = Object.values(cachedResults).map((c) => ({
         ...c,
         tag: c.recordId,
+        filePath: c.filePath || c.lastKnownPath,
     }));
 
-    /* 3 — Scan current local workspace */
-    const localPaths = await walkFiles(EXPORT_ROOT, { ignore: [path.join(EXPORT_ROOT, 'Contents')] });
+    // Step 3: Scan local workspace (excluding Assets folder)
+    const localPaths = await walkFiles(EXPORT_ROOT, { ignore: [path.join(EXPORT_ROOT, 'Assets')] });
     const localFiles = await Promise.all(
         localPaths.map(async (p) => {
             try {
                 const tag = await getFileTag(p);
                 return { tag, path: p };
             } catch {
-                // console.log(
-                //     chalk.yellow(
-                //         `Warning: Could not retrieve tag for ${p}. Treating as new file.`
-                //     )
-                // );
                 return { tag: null, path: p };
             }
         })
     );
 
-    /* 4 — Fast lookup maps */
-    const cacheById = Object.fromEntries(
-        cachedFiles.map((c) => [c.tag, c])
-    );
-    const localById = Object.fromEntries(
-        localFiles.filter((f) => f.tag).map((f) => [f.tag, f])
-    );
+    // Step 4: Create lookup maps
+    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)]);
 
-    /* 5 — Determine action per recordId */
-    const allIds = new Set([
-        ...Object.keys(cacheById),
-        ...Object.keys(localById),
-    ]);
     const actionQueue = [];
 
-    // HANDLE ASSET CREATION SEPERATELY
-    const assetPaths = await walkFiles(path.join(EXPORT_ROOT, 'Contents/Assets'));
+    // Step 5: Handle static asset files
+    const assetPaths = await walkFiles(path.join(EXPORT_ROOT, 'Assets'));
     for (const assetPath of assetPaths) {
-        // The file is already being handled in the next part
-        if (cachedFiles.find(cr => cr.filePath.toLowerCase() === assetPath.toLowerCase())) {
+        if (cachedFiles.find(cr => cr.filePath?.toLowerCase() === assetPath.toLowerCase())) {
             continue;
         }
 
-        const fileFolderPath = getFolderFromPath(assetPath);
-
         actionQueue.push({
             action: "create_static_asset",
-            folder: fileFolderPath,
+            folder: toApiPath(assetPath),
             filePath: assetPath
         });
     }
 
+    // Step 6: Handle folder creation and deletion
+    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);
+
+        // New folders
+        for (const folderPath of localFolders) {
+            if (!folderPath || cachedFolders.find(cf => cf?.toLowerCase() === folderPath.toLowerCase())) {
+                continue;
+            }
+
+            const parentDir = path.dirname(folderPath);
+            if (!parentDir || parentDir === '.' || parentDir === folderPath) continue;
+
+            actionQueue.push({
+                action: "create_folder",
+                folderPath: folderPath,
+                parentPath: toApiFolderPath(parentDir),
+                folderName: path.basename(folderPath)
+            });
+        }
+
+        // Deleted folders
+        for (const cachedFolder of cachedFolders) {
+            if (!cachedFolder || typeof cachedFolder !== 'string') continue;
+            if (localFolders.find(lf => lf?.toLowerCase() === cachedFolder.toLowerCase())) {
+                continue;
+            }
+
+            const parentDir = path.dirname(cachedFolder);
+            if (!parentDir || parentDir === '.' || parentDir === cachedFolder) continue;
+
+            actionQueue.push({
+                action: "delete_folder",
+                folderPath: cachedFolder,
+                parentPath: toApiFolderPath(parentDir),
+                folderName: path.basename(cachedFolder)
+            });
+        }
+    }
+
+    // Step 7: Process code entities (ActiveClass/ActivePage) and static assets
     for (const id of allIds) {
         try {
             const cacheFile = cacheById[id];
             const curFile = localById[id];
 
-            // This is an asset so it needs to be treated differently
-            // Assets only have CREATE & DELETE & UPDATE actions no rename, if a files content is changed just reupload it essentially.
-            // We may have to explore the option of listing all the files from the server first and validating against those instead of the cache
-            if (cacheFile.type === 'File') {
+            // Skip folders - they're handled separately
+            if (cacheFile?.type === 'Folder') continue;
+
+            // Handle static asset files
+            if (cacheFile?.type === 'File') {
                 const localAssetExists = fs.existsSync(cacheFile.filePath);
 
-                // DELETE
                 if (!localAssetExists) {
                     actionQueue.push({
                         action: 'delete_static_asset',
-                        folder: getFolderFromPath(cacheFile.filePath),
+                        folder: toApiPath(cacheFile.filePath),
                         names: [path.basename(cacheFile.filePath)]
                     });
-
                     continue;
                 }
 
-                // UPDATE
                 const contentHash = sha256(fs.readFileSync(cacheFile.filePath, 'utf-8'));
                 if (contentHash !== cacheFile.contentHash) {
-                    // This can be handled as a file creation since the Magentrix Upload API will just overwrite the file
                     actionQueue.push({
-                        aliasAction: 'update_static_asset',
                         action: "create_static_asset",
-                        folder: getFolderFromPath(cacheFile.filePath),
+                        folder: toApiPath(cacheFile.filePath),
                         filePath: cacheFile.filePath
                     });
                 }
-
                 continue;
             }
 
-            /* DELETE */
+            // Handle code entity deletion
             if (cacheFile && !curFile) {
-                const { type, entity } = inferMeta(cacheFile.lastKnownPath);
+                const { type, entity } = inferMeta(path.resolve(cacheFile.lastKnownPath));
                 actionQueue.push({
                     action: "delete",
                     recordId: id,
@@ -439,12 +501,14 @@ export const runPublish = async (options = {}) => {
                 continue;
             }
 
-            /* CREATE */
+            // Handle code entity creation
             if (!cacheFile && curFile) {
                 const safe = readFileSafe(curFile.path);
                 if (!safe) continue;
+
                 const { content, hash } = safe;
-                const { type, entity, contentField } = inferMeta(curFile.path);
+                const { type, entity, contentField } = inferMeta(path.resolve(curFile.path));
+
                 actionQueue.push({
                     action: "create",
                     filePath: curFile.path,
@@ -457,16 +521,18 @@ export const runPublish = async (options = {}) => {
                 continue;
             }
 
-            /* UPDATE */
+            // Handle code entity update
             if (cacheFile && curFile) {
                 const safe = readFileSafe(curFile.path);
                 if (!safe) continue;
-                const { content, hash } = safe;
 
+                const { content, hash } = safe;
                 const renamed = cacheFile.lastKnownPath !== path.resolve(curFile.path);
                 const contentChanged = hash !== cacheFile.contentHash;
+
                 if (renamed || contentChanged) {
-                    const { type, entity, contentField } = inferMeta(curFile.path);
+                    const { type, entity, contentField } = inferMeta(path.resolve(curFile.path));
+
                     actionQueue.push({
                         action: "update",
                         recordId: id,
@@ -480,23 +546,24 @@ export const runPublish = async (options = {}) => {
                 }
             }
         } catch (err) {
-            console.log(err)
+            console.error(chalk.yellow(`Warning: Error processing file with ID ${id}:`), err.message);
         }
     }
 
-    /* 6 — Handle brand-new, tag-less files */
+    // Step 8: Handle brand-new, tag-less files
     for (const f of newLocalNoId) {
         const safe = readFileSafe(f.path);
         if (!safe) {
-            console.log(
-                chalk.yellow(`Skipping unreadable file: ${f.path}`)
-            );
+            console.log(chalk.yellow(`Skipping unreadable file: ${f.path}`));
             continue;
         }
+
         const { content, hash } = safe;
-        const { type, entity, contentField } = inferMeta(f.path);
+        const { type, entity, contentField } = inferMeta(path.resolve(f.path));
+
         actionQueue.push({
             action: "create",
+            filePath: f.path,
             recordId: null,
             type,
             entity,
@@ -505,55 +572,83 @@ export const runPublish = async (options = {}) => {
         });
     }
 
-    /* 7 — Summary and execution */
+    // Step 9: Filter out redundant file deletions
+    const foldersBeingDeleted = actionQueue
+        .filter(a => a.action === 'delete_folder')
+        .map(a => a.folderPath);
+
+    const filteredActionQueue = actionQueue.filter(action => {
+        if (action.action === 'delete_static_asset') {
+            const fileFolder = path.join(EXPORT_ROOT, action.folder);
+            for (const deletedFolder of foldersBeingDeleted) {
+                if (fileFolder.startsWith(deletedFolder)) {
+                    return false; // Skip - covered by folder deletion
+                }
+            }
+        }
+        return true;
+    });
+
+    // Step 10: Display and execute action queue
     if (!silent) {
         console.log(chalk.blue("\n--- Publish Action Queue ---"));
-        if (!actionQueue.length) {
-            console.log(
-                chalk.green("All files are in sync — nothing to publish!")
-            );
+        if (!filteredActionQueue.length) {
+            console.log(chalk.green("All files are in sync — nothing to publish!"));
         } else {
-            actionQueue.forEach((a, i) => {
+            filteredActionQueue.forEach((a, i) => {
                 const num = chalk.green(`[${i + 1}]`);
                 const act = chalk.yellow(a.action.toUpperCase());
-                const type = chalk.cyan(a.type || a?.names?.join(", ") || path.basename(a.filePath));
+
+                let type, displayPath;
+                if (a.folderName) {
+                    type = chalk.cyan(a.folderName);
+                    displayPath = a.folderPath;
+                } else if (a.names) {
+                    type = chalk.cyan(a.names.join(", "));
+                    displayPath = a.folder;
+                } else if (a.filePath) {
+                    type = chalk.cyan(a.type || path.basename(a.filePath));
+                    displayPath = a.filePath;
+                } else {
+                    type = chalk.cyan(a.type || "Unknown");
+                    displayPath = a.folder || "Unknown";
+                }
+
                 const idInfo = a.recordId ? ` ${chalk.magenta(a.recordId)}` : "";
                 const renameInfo = a.renamed
                     ? ` → ${chalk.gray(a.oldPath)} ${chalk.white("→")} ${chalk.gray(a.filePath)}`
                     : "";
 
-                console.log(`${num} ${act} | ${a.type ? "Type" : "File"}: ${type}${idInfo}${renameInfo} (${a.filePath || a.folder})`);
+                console.log(`${num} ${act} | ${a.type ? "Type" : (a.folderName ? "Folder" : "File")}: ${type}${idInfo}${renameInfo} (${displayPath})`);
             });
 
             console.log(chalk.blue("\n--- Publishing Changes ---"));
         }
     }
 
-    // Execute the action queue if there are changes
-    if (actionQueue.length > 0) {
+    // Execute actions
+    if (filteredActionQueue.length > 0) {
         if (silent) {
-            await performNetworkRequest(actionQueue);
+            await performNetworkRequest(filteredActionQueue);
         } else {
             await withSpinner(
                 "Working...",
                 async () => {
-                    await performNetworkRequest(actionQueue)
+                    await performNetworkRequest(filteredActionQueue)
                 },
-                {
-                    showCompletion: false
-                }
+                { showCompletion: false }
             );
         }
     }
 
     return {
-        actionQueue,
-        hasChanges: actionQueue.length > 0
+        actionQueue: filteredActionQueue,
+        hasChanges: filteredActionQueue.length > 0
     };
 };
 
 /**
- * CLI command wrapper for publish
+ * CLI command wrapper for publish.
  */
 export const publish = async () => {
     process.stdout.write("\x1Bc"); // clear console