@magentrix-corp/magentrix-cli 1.3.11 → 1.3.13

package/actions/iris/buildStage.js

@@ -435,11 +435,23 @@ async function buildFromVueProject(options) {
     // This ensures pull doesn't overwrite our staged files
     console.log();
     console.log(chalk.gray('Checking workspace sync status...'));
+
+    // Check for a previous incomplete pull first — `magentrix status` only checks
+    // code entities, so a partial pull that synced code but not assets would falsely
+    // report "in sync". The marker file catches this case.
+    const workspaceConfig = new Config({ projectDir: workspacePath });
+    const hadIncompletePull = workspaceConfig.read('pullIncomplete', { global: false, filename: 'config.json' });
+
     const syncStatus = await checkWorkspaceSyncStatus(workspacePath);
+    const needsPull = syncStatus.needsPull || !!hadIncompletePull;
 
-    if (syncStatus.needsPull) {
+    if (needsPull) {
         console.log();
-        console.log(chalk.yellow('⚠ Your workspace may be out of sync with the server.'));
+        if (hadIncompletePull && !syncStatus.needsPull) {
+            console.log(chalk.yellow('⚠ A previous pull did not complete. Your workspace may be out of sync.'));
+        } else {
+            console.log(chalk.yellow('⚠ Your workspace may be out of sync with the server.'));
+        }
 
         const shouldPull = await confirm({
             message: 'Would you like to pull latest changes first?',
@@ -451,9 +463,16 @@ async function buildFromVueProject(options) {
             console.log(chalk.blue('Running pull from workspace...'));
             console.log();
 
+            // Mark pull as in-progress before starting
+            workspaceConfig.save('pullIncomplete', true, { global: false, filename: 'config.json' });
+
             const pullSuccess = await runCommandFromWorkspace(workspacePath, 'pull');
 
-            if (!pullSuccess) {
+            if (pullSuccess) {
+                // Pull completed successfully — clear the marker
+                workspaceConfig.removeKey('pullIncomplete', { filename: 'config.json' });
+            } else {
+                // Pull failed or was cancelled — marker stays for next run
                 console.log();
                 console.log(chalk.yellow('Pull encountered issues. You may want to resolve them manually.'));
 

package/actions/publish.js

@@ -12,6 +12,7 @@ import {
     EXPORT_ROOT,
     TYPE_DIR_MAP,
     IRIS_APPS_DIR,
+    ALLOWED_SRC_DIRS,
 } from "../vars/global.js";
 import { getFileTag, setFileTag } from "../utils/filetag.js";
 import { sha256 } from "../utils/hash.js";
@@ -198,9 +199,14 @@ const handleDeleteStaticAssetAction = async (instanceUrl, apiKey, action) => {
 
         if (isNotFound) {
             // Clean up base.json since file doesn't exist on server
-            for (const name of action.names) {
-                const filePath = action.filePath || `${EXPORT_ROOT}/${action.folder}/${name}`;
-                removeFromBase(filePath);
+            // Use the original base.json key if available (avoids path format mismatches)
+            if (action.baseKey) {
+                removeFromBase(action.baseKey);
+            } else {
+                for (const name of action.names) {
+                    const filePath = action.filePath || `${EXPORT_ROOT}/${action.folder}/${name}`;
+                    removeFromBase(filePath);
+                }
             }
             return { cleanedFromCache: true };
         }
@@ -252,7 +258,8 @@ const handleDeleteFolderAction = async (instanceUrl, apiKey, action) => {
 
         if (isNotFound) {
             // Clean up base.json since folder doesn't exist on server
-            removeFromBase(action.folderPath);
+            // Use original base.json key if available (avoids path format mismatches)
+            removeFromBase(action.baseKey || action.folderPath);
 
             // Also remove all files and subfolders inside this folder from base
             const hits = await config.searchObject({}, { filename: "base.json", global: false });
@@ -288,14 +295,19 @@ 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 metadata
+    // For updates, don't send app-name/description/icon to avoid triggering
+    // metadata modification that may require permissions the user doesn't have.
+    // The server already has the correct metadata from the original create.
+    // For creates, send all metadata so the app is properly registered.
+    const isUpdate = action.action === 'update_iris_app';
+
     const response = await publishApp(
         instanceUrl,
         apiKey,
         zipBuffer,
         `${action.slug}.zip`,
-        action.appName,
-        {
+        isUpdate ? null : action.appName,
+        isUpdate ? {} : {
             appDescription: action.appDescription,
             appIconId: action.appIconId
         }
@@ -424,9 +436,14 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
             case "delete_static_asset":
                 // Skip if already cleaned from cache during 404 handling
                 if (!operationResult?.cleanedFromCache) {
-                    for (const name of action.names) {
-                        const filePath = action.filePath || `${EXPORT_ROOT}/${action.folder}/${name}`;
-                        removeFromBase(filePath);
+                    // Use the original base.json key if available (avoids path format mismatches)
+                    if (action.baseKey) {
+                        removeFromBase(action.baseKey);
+                    } else {
+                        for (const name of action.names) {
+                            const filePath = action.filePath || `${EXPORT_ROOT}/${action.folder}/${name}`;
+                            removeFromBase(filePath);
+                        }
                     }
                 }
                 break;
@@ -442,8 +459,8 @@ 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 using recordId (which is the folderPath)
-                    removeFromBase(action.folderPath);
+                    // Remove the folder itself from base using the original base.json key
+                    removeFromBase(action.baseKey || action.folderPath);
 
                     // Also remove all files and subfolders inside this folder from base
                     const hits = await config.searchObject({}, { filename: "base.json", global: false });
@@ -870,16 +887,19 @@ 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 and iris-apps folders)
+    // Step 3: Scan local workspace (only whitelisted code entity directories)
     if (progress) progress.startStep('scan');
 
     const walkStart = Date.now();
-    const localPaths = await walkFiles(EXPORT_ROOT, {
-        ignore: [
-            path.join(EXPORT_ROOT, 'Assets'),
-            path.join(EXPORT_ROOT, IRIS_APPS_DIR)
-        ]
-    });
+    // Only scan whitelisted directories for code entities (exclude Assets and iris-apps, handled separately)
+    const codeEntityDirs = ALLOWED_SRC_DIRS.filter(dir => dir !== 'Assets' && dir !== IRIS_APPS_DIR);
+    const localPathArrays = await Promise.all(
+        codeEntityDirs.map(dir => {
+            const dirPath = path.join(EXPORT_ROOT, dir);
+            return fs.existsSync(dirPath) ? walkFiles(dirPath) : Promise.resolve([]);
+        })
+    );
+    const localPaths = localPathArrays.flat();
     const walkTime = Date.now() - walkStart;
 
     const tagStart = Date.now();
@@ -1025,7 +1045,8 @@ export const runPublish = async (options = {}) => {
                 action: "delete_folder",
                 folderPath: cachedPath,
                 parentPath: toApiFolderPath(parentDir),
-                folderName: path.basename(cachedPath)
+                folderName: path.basename(cachedPath),
+                baseKey: cachedFolder.tag // The original base.json key for correct cache cleanup
             });
         }
     }
@@ -1063,7 +1084,8 @@ export const runPublish = async (options = {}) => {
                         action: 'delete_static_asset',
                         folder: toApiPath(actualPath),
                         names: [path.basename(actualPath)],
-                        filePath: actualPath // Store actual file path for filtering
+                        filePath: actualPath, // Store actual file path for filtering
+                        baseKey: id // The original base.json key for correct cache cleanup
                     });
                     continue;
                 }

package/actions/pull.js

@@ -128,9 +128,12 @@ export const pull = async () => {
         progress.startStep('load');
         const hits = await config.searchObject({}, { filename: "base.json", global: false });
         const cachedResults = hits?.[0]?.value || {};
-        const cachedAssets = Object.values(cachedResults).filter(c =>
-            c.type === 'File' || c.type === 'Folder'
-        );
+        // Include the base.json key (_baseKey) alongside each entry so we can
+        // use the correct key for removeFromBaseBulk later. The keys may differ
+        // from lastKnownActualPath/filePath due to path format inconsistencies.
+        const cachedAssets = Object.entries(cachedResults)
+            .filter(([, c]) => c.type === 'File' || c.type === 'Folder')
+            .map(([key, c]) => ({ ...c, _baseKey: key }));
         progress.completeStep('load', `✓ Loaded ${Object.keys(cachedResults).length} cached entries`);
 
         // Step 4a: Download code entities (ActiveClass and ActivePage)
@@ -338,7 +341,7 @@ export const pull = async () => {
 
                 // If this asset was in base.json but not returned from server, it was deleted
                 if (!serverAssetPaths.has(cachedPath)) {
-                    assetsToDelete.push(cachedPath);
+                    assetsToDelete.push({ path: cachedPath, baseKey: cached._baseKey });
                 }
 
                 processedCount++;
@@ -402,33 +405,35 @@ export const pull = async () => {
             // Delete local files/folders that were deleted on server
             logger.info(`Starting deletion of ${assetsToDelete.length} assets`);
             const deletionLogs = [];
-            for (const assetPath of assetsToDelete) {
+            // Track base.json keys for entries that need removal
+            const assetBaseKeysToRemove = [];
+            for (const asset of assetsToDelete) {
                 try {
-                    if (fs.existsSync(assetPath)) {
-                        const stats = fs.statSync(assetPath);
+                    if (fs.existsSync(asset.path)) {
+                        const stats = fs.statSync(asset.path);
                         if (stats.isDirectory()) {
-                            fs.rmSync(assetPath, { recursive: true, force: true });
-                            deletionLogs.push({ type: 'folder', path: assetPath });
-                            logger.info('Deleted folder', { path: assetPath });
+                            fs.rmSync(asset.path, { recursive: true, force: true });
+                            deletionLogs.push({ type: 'folder', path: asset.path });
+                            logger.info('Deleted folder', { path: asset.path });
                         } else {
-                            fs.unlinkSync(assetPath);
-                            deletionLogs.push({ type: 'file', path: assetPath });
-                            logger.info('Deleted file', { path: assetPath });
+                            fs.unlinkSync(asset.path);
+                            deletionLogs.push({ type: 'file', path: asset.path });
+                            logger.info('Deleted file', { path: asset.path });
                         }
                     }
+                    // Always remove from base.json regardless of whether the local file
+                    // existed — the server confirmed deletion, so the cache entry is stale.
+                    assetBaseKeysToRemove.push(asset.baseKey);
                 } catch (err) {
-                    deletionLogs.push({ type: 'error', path: assetPath, error: err.message });
-                    logger.error(`Failed to delete asset: ${assetPath}`, err);
+                    deletionLogs.push({ type: 'error', path: asset.path, error: err.message });
+                    logger.error(`Failed to delete asset: ${asset.path}`, err);
                 }
             }
 
-            // Bulk remove from base.json
-            const assetPathsToRemove = deletionLogs
-                .filter(l => l.type === 'file' || l.type === 'folder')
-                .map(l => l.path);
-
-            if (assetPathsToRemove.length > 0) {
-                removeFromBaseBulk(assetPathsToRemove);
+            // Bulk remove from base.json using the original base.json keys
+            // (not the normalized paths, which may have a different format)
+            if (assetBaseKeysToRemove.length > 0) {
+                removeFromBaseBulk(assetBaseKeysToRemove);
             }
 
             // Delete local code entity files that were deleted on server
@@ -639,6 +644,10 @@ export const pull = async () => {
         logger.close();
         progress.finish('Pull completed successfully!');
 
+        // Clear any incomplete-pull marker (set by vue-run-build when a pull is
+        // started but cancelled/fails). A successful pull means we're fully synced.
+        config.removeKey('pullIncomplete', { filename: 'config.json' });
+
         // Summary
         console.log(chalk.bold(`Summary:`));
         console.log(`   • ${activeClassResult.Records.length} ActiveClass records`);

package/bin/magentrix.js

@@ -20,6 +20,7 @@ import { configWizard } from '../actions/config.js';
 import { irisLink, irisDev, irisDelete, irisRecover, vueBuildStage } from '../actions/iris/index.js';
 import Config from '../utils/config.js';
 import { registerWorkspace, getRegisteredWorkspaces } from '../utils/workspaces.js';
+import { ensureVSCodeFileAssociation } from '../utils/preferences.js';
 
 const config = new Config();
 
@@ -102,6 +103,13 @@ function ensureWorkspaceRegistered() {
 
 async function preMiddleware() {
     ensureWorkspaceRegistered();
+
+    // Ensure .vscode folder exists in project root (not in src/) for Magentrix projects
+    const magentrixDir = join(CWD, '.magentrix');
+    if (existsSync(magentrixDir)) {
+        await ensureVSCodeFileAssociation(CWD);
+    }
+
     await recacheFileIdIndex(EXPORT_ROOT);
     await cacheDir(EXPORT_ROOT);
 }

package/package.json

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

package/utils/cacher.js

@@ -4,10 +4,13 @@ import Config from './config.js';
 import { findFileByTag, getFileTag, isPathLinkedToTagByLastKnownPath, setFileTag } from './filetag.js';
 import { compressString } from './compress.js';
 import { sha256 } from './hash.js';
-import { EXPORT_ROOT } from '../vars/global.js';
+import { EXPORT_ROOT, ALLOWED_SRC_DIRS, IRIS_APPS_DIR } from '../vars/global.js';
 
 const config = new Config();
 
+// System/hidden files that should never be synced
+const IGNORED_FILES = new Set(['.DS_Store', 'Thumbs.db', 'desktop.ini']);
+
 /**
  * Recursively caches all files in a directory with tagging and content snapshotting
  * OPTIMIZED: Parallel processing + mtime checks for maximum speed
@@ -19,8 +22,15 @@ export const cacheDir = async (dir) => {
 
     const absDir = path.resolve(dir);
 
-    // Walk files but exclude Assets folder (tracked separately in base.json)
-    const files = await walkFiles(absDir, { ignore: [path.join(absDir, 'Assets')] });
+    // Only walk whitelisted code entity directories (exclude Assets and iris-apps, handled separately)
+    const codeEntityDirs = ALLOWED_SRC_DIRS.filter(d => d !== 'Assets' && d !== IRIS_APPS_DIR);
+    const fileArrays = await Promise.all(
+        codeEntityDirs.map(d => {
+            const dirPath = path.join(absDir, d);
+            return fs.existsSync(dirPath) ? walkFiles(dirPath) : Promise.resolve([]);
+        })
+    );
+    const files = fileArrays.flat();
 
     const cache = config.read('cachedFiles', { global: false, filename: 'fileCache.json' }) || {};
 
@@ -108,10 +118,17 @@ export const cacheDir = async (dir) => {
  * @returns {Promise<void>}
  */
 export const recacheFileIdIndex = async (dir) => {
-    // Exclude Assets folder - they don't use file tags, tracked in base.json instead
     const absDir = path.resolve(dir);
-    const ignorePath = path.join(absDir, 'Assets');
-    const files = await walkFiles(absDir, { ignore: [ignorePath] });
+
+    // Only walk whitelisted code entity directories (exclude Assets and iris-apps, handled separately)
+    const codeEntityDirs = ALLOWED_SRC_DIRS.filter(d => d !== 'Assets' && d !== IRIS_APPS_DIR);
+    const fileArrays = await Promise.all(
+        codeEntityDirs.map(d => {
+            const dirPath = path.join(absDir, d);
+            return fs.existsSync(dirPath) ? walkFiles(dirPath) : Promise.resolve([]);
+        })
+    );
+    const files = fileArrays.flat();
     if (!files || files?.length < 1) return;
 
     // Process files in parallel batches of 50 for speed
@@ -165,6 +182,11 @@ export async function walkFiles(dir, settings) {
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
 
+        // Skip OS-generated system files (.DS_Store, Thumbs.db, etc.)
+        if (IGNORED_FILES.has(entry.name)) {
+            continue;
+        }
+
         // Check if this path should be ignored
         if (ignore.find(p => fullPath.startsWith(p) || fullPath === p)) {
             continue;

package/utils/cli/writeRecords.js

@@ -245,7 +245,7 @@ export const writeRecords = async (records, resolutionMethod, progress = null, l
                     updateBase(filePath, record, cachedFilePath);
                 }
             } catch (err) {
-                const msg = `Failed to write file ${cachedFilePath}: ${err.message}`;
+                const msg = `Failed to write file ${filePath}: ${err.message}`;
                 if (logger) {
                     logger.error(msg, err);
                 } else {

package/utils/iris/zipper.js

@@ -5,6 +5,9 @@ import { randomUUID, createHash } from 'node:crypto';
 import archiver from 'archiver';
 import extractZip from 'extract-zip';
 
+// System/hidden files that should never be included in IRIS app zips or hashes
+const IGNORED_FILES = new Set(['.DS_Store', 'Thumbs.db', 'desktop.ini']);
+
 /**
  * Recursively fix permissions on extracted files.
  * Sets directories to 0o755 and files to 0o644.
@@ -61,7 +64,10 @@ export async function createIrisZip(distPath, appSlug) {
 
         // Add the dist directory contents under the app slug folder
         // This creates the structure: appSlug/remoteEntry.js, appSlug/assets/...
-        archive.directory(distPath, appSlug);
+        // Filter out OS-generated system files (.DS_Store, Thumbs.db, etc.)
+        archive.directory(distPath, appSlug, (entry) =>
+            IGNORED_FILES.has(basename(entry.name)) ? false : entry
+        );
 
         archive.finalize();
     });
@@ -195,6 +201,9 @@ export function getFilesRecursive(dir, basePath = dir) {
     function walk(currentDir) {
         const entries = readdirSync(currentDir);
         for (const entry of entries) {
+            // Skip OS-generated system files
+            if (IGNORED_FILES.has(entry)) continue;
+
             const fullPath = join(currentDir, entry);
             const stat = statSync(fullPath);
             if (stat.isDirectory()) {

package/utils/magentrix/api/iris.js

@@ -48,10 +48,6 @@ export const publishApp = async (instanceUrl, token, zipBuffer, filename, appNam
         throw new Error('filename is required');
     }
 
-    if (!appName) {
-        throw new Error('appName is required for navigation menu updates');
-    }
-
     // Create a File object from the buffer for FormData
     const file = new File([zipBuffer], filename, { type: 'application/zip' });
 
@@ -59,8 +55,14 @@ export const publishApp = async (instanceUrl, token, zipBuffer, filename, appNam
     formData.append('file', file);
 
     // Build query parameters
+    // Note: app-name is only sent when provided (required for creates, optional for updates)
+    // Sending app-name on updates can trigger a rename attempt that fails if the user
+    // lacks metadata-edit permissions on the server
     const params = new URLSearchParams();
-    params.append('app-name', appName);
+
+    if (appName) {
+        params.append('app-name', appName);
+    }
 
     if (options.appDescription) {
         params.append('app-description', options.appDescription);

package/vars/global.js

@@ -6,6 +6,22 @@ export const EXPORT_ROOT = "src";
 export const ASSETS_DIR = "Assets"; // Local directory name for static assets (API uses /contents/assets)
 export const IRIS_APPS_DIR = "iris-apps"; // Local directory for Iris Vue.js apps
 
+/**
+ * Whitelist of allowed directories inside EXPORT_ROOT.
+ * Only these folders will be scanned during publish/cache operations.
+ * This prevents accidental processing of hidden folders (.magentrix, .vscode, etc.)
+ * or any other unexpected directories users might create.
+ */
+export const ALLOWED_SRC_DIRS = [
+    "Assets",
+    "Classes",
+    "Controllers",
+    "iris-apps",
+    "Pages",
+    "Templates",
+    "Triggers"
+];
+
 /**
      * Maps Magentrix Type fields to local folder names and extensions.
      * Extensions chosen to avoid collisions and clearly indicate type.