@magentrix-corp/magentrix-cli 1.3.9 → 1.3.11

package/utils/iris/config-reader.js

@@ -1,5 +1,7 @@
 import { existsSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { validateSlug, validateUrl, validateAppName, detectExpression, MAX_LENGTHS } from './validation.js';
+import { formatError, detectErrorType, ErrorTypes } from './errors.js';
 
 /**
  * Common locations where config.ts might be found in a Vue project.
@@ -17,6 +19,11 @@ const CONFIG_LOCATIONS = [
  */
 const ENV_FILE = '.env.development';
 
+/**
+ * Maximum size of assets array before warning.
+ */
+const MAX_ASSETS_WARNING_THRESHOLD = 500;
+
 /**
  * Parse a .env file and return key-value pairs.
  *
@@ -68,7 +75,9 @@ function parseEnvFile(envPath) {
  *   siteUrl: string | null,
  *   assets: string[],
  *   refreshToken: string | null,
- *   envFileUsed: string | null
+ *   envFileUsed: string | null,
+ *   warnings: string[],
+ *   errors: string[]
  * }}
  */
 export function readEnvConfig(projectPath) {
@@ -76,7 +85,9 @@ export function readEnvConfig(projectPath) {
         siteUrl: null,
         assets: [],
         refreshToken: null,
-        envFileUsed: null
+        envFileUsed: null,
+        warnings: [],
+        errors: []
     };
 
     const envPath = join(projectPath, ENV_FILE);
@@ -85,23 +96,59 @@ export function readEnvConfig(projectPath) {
         return result;
     }
 
-    const envVars = parseEnvFile(envPath);
+    let envVars;
+    try {
+        envVars = parseEnvFile(envPath);
+    } catch (err) {
+        result.errors.push(`Failed to read ${ENV_FILE}: ${err.message}`);
+        return result;
+    }
+
     result.envFileUsed = ENV_FILE;
 
-    // Read VITE_SITE_URL
+    // Read and validate VITE_SITE_URL
     if (envVars.VITE_SITE_URL) {
-        result.siteUrl = envVars.VITE_SITE_URL;
+        const urlValue = envVars.VITE_SITE_URL;
+        const urlValidation = validateUrl(urlValue);
+
+        if (!urlValidation.valid) {
+            result.errors.push(`VITE_SITE_URL is invalid: ${urlValidation.error}`);
+            if (urlValidation.suggestion) {
+                result.warnings.push(`  Suggestion: ${urlValidation.suggestion}`);
+            }
+        } else {
+            result.siteUrl = urlValidation.normalized || urlValue;
+        }
     }
 
-    // Read VITE_ASSETS
+    // Read VITE_ASSETS with better error handling
     if (envVars.VITE_ASSETS) {
         try {
             const parsed = JSON.parse(envVars.VITE_ASSETS);
             if (Array.isArray(parsed)) {
                 result.assets = parsed;
+
+                // Warn if assets array is very large
+                if (parsed.length > MAX_ASSETS_WARNING_THRESHOLD) {
+                    result.warnings.push(
+                        `VITE_ASSETS contains ${parsed.length} items. ` +
+                        `Large arrays may cause performance issues.`
+                    );
+                }
+            } else {
+                result.warnings.push('VITE_ASSETS is not an array, ignoring');
+            }
+        } catch (err) {
+            // Provide helpful error for JSON parsing issues
+            if (envVars.VITE_ASSETS.includes("'") && !envVars.VITE_ASSETS.includes('"')) {
+                result.errors.push(
+                    'VITE_ASSETS contains invalid JSON. ' +
+                    'JSON requires double quotes for strings, not single quotes. ' +
+                    'Example: VITE_ASSETS = \'["url1", "url2"]\''
+                );
+            } else {
+                result.errors.push(`VITE_ASSETS contains invalid JSON: ${err.message}`);
             }
-        } catch {
-            // If not valid JSON, skip
         }
     }
 
@@ -129,6 +176,24 @@ export function findConfigFile(projectPath) {
     return null;
 }
 
+/**
+ * Strip comments from config file content to prevent parsing issues.
+ * Removes both single-line (//) and multi-line comments.
+ *
+ * @param {string} content - Raw config file content
+ * @returns {string} - Content with comments removed
+ */
+function stripComments(content) {
+    // Remove single-line comments (but not URLs with //)
+    // Match // that's not preceded by : (to avoid breaking URLs)
+    let result = content.replace(/(?<!:)\/\/.*$/gm, '');
+
+    // Remove multi-line comments
+    result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+
+    return result;
+}
+
 /**
  * Parse a config.ts file and extract Iris configuration.
  * Uses regex parsing to avoid TypeScript compilation.
@@ -141,7 +206,8 @@ export function findConfigFile(projectPath) {
  *   appIconId: string | null,
  *   siteUrl: string | null,
  *   assets: string[],
- *   raw: string
+ *   raw: string,
+ *   warnings: string[]
  * }}
  */
 export function parseConfigFile(configPath) {
@@ -152,24 +218,46 @@ export function parseConfigFile(configPath) {
         appIconId: null,
         siteUrl: null,
         assets: [],
-        raw: ''
+        raw: '',
+        warnings: []
     };
 
     if (!existsSync(configPath)) {
         return result;
     }
 
-    const content = readFileSync(configPath, 'utf-8');
+    let content;
+    try {
+        content = readFileSync(configPath, 'utf-8');
+    } catch (err) {
+        result.warnings.push(`Failed to read config file: ${err.message}`);
+        return result;
+    }
+
     result.raw = content;
 
+    // Strip comments before parsing to avoid regex issues
+    const cleanContent = stripComments(content);
+
     // Extract slug (various patterns)
-    // slug: "dashboard", appPath: "dashboard", app_path: "dashboard"
+    // slug: "dashboard", appSlug: "dashboard", app_slug: "dashboard"
     // Also handles: slug: env.slug || "fallback"
-    const slugMatch = content.match(/(?:slug|appPath|app_path)\s*:\s*["'`]([^"'`]+)["'`]/);
+    const slugMatch = cleanContent.match(/(?:slug|appSlug|app_slug)\s*:\s*["'`]([^"'`]+)["'`]/);
     if (slugMatch) {
         result.slug = slugMatch[1];
+
+        // Check for template literal expressions
+        const exprCheck = detectExpression(result.slug);
+        if (exprCheck.isExpression) {
+            result.warnings.push(
+                `slug appears to contain a ${exprCheck.type} (${result.slug}). ` +
+                `The CLI cannot evaluate dynamic values. ` +
+                `Use a static string value instead.`
+            );
+            result.slug = null;
+        }
     } else {
-        const slugFallbackMatch = content.match(/(?:slug|appPath|app_path)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
+        const slugFallbackMatch = cleanContent.match(/(?:slug|appSlug|app_slug)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
         if (slugFallbackMatch) {
             result.slug = slugFallbackMatch[1];
         }
@@ -178,11 +266,22 @@ export function parseConfigFile(configPath) {
     // Extract appName (various patterns)
     // appName: "Dashboard App", app_name: "Dashboard", name: "Dashboard"
     // Also handles: appName: env.appName || "fallback"
-    const appNameMatch = content.match(/(?:appName|app_name)\s*:\s*["'`]([^"'`]+)["'`]/);
+    const appNameMatch = cleanContent.match(/(?:appName|app_name)\s*:\s*["'`]([^"'`]+)["'`]/);
     if (appNameMatch) {
         result.appName = appNameMatch[1];
+
+        // Check for template literal expressions
+        const exprCheck = detectExpression(result.appName);
+        if (exprCheck.isExpression) {
+            result.warnings.push(
+                `appName appears to contain a ${exprCheck.type} (${result.appName}). ` +
+                `The CLI cannot evaluate dynamic values. ` +
+                `Use a static string value instead.`
+            );
+            result.appName = null;
+        }
     } else {
-        const appNameFallbackMatch = content.match(/(?:appName|app_name)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
+        const appNameFallbackMatch = cleanContent.match(/(?:appName|app_name)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
         if (appNameFallbackMatch) {
             result.appName = appNameFallbackMatch[1];
         }
@@ -190,14 +289,14 @@ export function parseConfigFile(configPath) {
 
     // Extract appDescription (optional)
     // appDescription: "Description text"
-    const appDescriptionMatch = content.match(/(?:appDescription|app_description)\s*:\s*["'`]([^"'`]*)["'`]/);
+    const appDescriptionMatch = cleanContent.match(/(?:appDescription|app_description)\s*:\s*["'`]([^"'`]*)["'`]/);
     if (appDescriptionMatch) {
         result.appDescription = appDescriptionMatch[1];
     }
 
     // Extract appIconId (optional)
     // appIconId: "icon-id-here"
-    const appIconIdMatch = content.match(/(?:appIconId|app_icon_id)\s*:\s*["'`]([^"'`]*)["'`]/);
+    const appIconIdMatch = cleanContent.match(/(?:appIconId|app_icon_id)\s*:\s*["'`]([^"'`]*)["'`]/);
     if (appIconIdMatch) {
         result.appIconId = appIconIdMatch[1];
     }
@@ -205,12 +304,12 @@ export function parseConfigFile(configPath) {
     // Extract siteUrl (various patterns)
     // siteUrl: "https://...", site_url: "https://...", baseUrl: "https://..."
     // Also handles: siteUrl: env.siteUrl || "https://..."
-    const siteUrlMatch = content.match(/(?:siteUrl|site_url|baseUrl|base_url)\s*:\s*["'`]([^"'`]+)["'`]/);
+    const siteUrlMatch = cleanContent.match(/(?:siteUrl|site_url|baseUrl|base_url)\s*:\s*["'`]([^"'`]+)["'`]/);
     if (siteUrlMatch) {
         result.siteUrl = siteUrlMatch[1];
     } else {
         // Try to match fallback pattern: siteUrl: env.x || "fallback"
-        const siteUrlFallbackMatch = content.match(/(?:siteUrl|site_url|baseUrl|base_url)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
+        const siteUrlFallbackMatch = cleanContent.match(/(?:siteUrl|site_url|baseUrl|base_url)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
         if (siteUrlFallbackMatch) {
             result.siteUrl = siteUrlFallbackMatch[1];
         }
@@ -218,7 +317,7 @@ export function parseConfigFile(configPath) {
 
     // Extract assets array
     // assets: ["url1", "url2"]
-    const assetsMatch = content.match(/assets\s*:\s*\[([\s\S]*?)\]/);
+    const assetsMatch = cleanContent.match(/assets\s*:\s*\[([\s\S]*?)\]/);
     if (assetsMatch) {
         const assetsContent = assetsMatch[1];
         // Extract all quoted strings from the array
@@ -282,11 +381,37 @@ export function readVueConfig(projectPath) {
 
     // Parse config.ts for slug, appName, appDescription, appIconId (always from config.ts)
     const parsed = parseConfigFile(configPath);
+
+    // Merge warnings from parsing
+    if (parsed.warnings?.length > 0) {
+        result.warnings.push(...parsed.warnings);
+    }
+
     result.slug = parsed.slug;
     result.appName = parsed.appName;
     result.appDescription = parsed.appDescription;
     result.appIconId = parsed.appIconId;
 
+    // Validate slug format if present
+    if (result.slug) {
+        const slugValidation = validateSlug(result.slug);
+        if (!slugValidation.valid) {
+            result.errors.push(`Invalid slug format: ${slugValidation.error}`);
+            if (slugValidation.suggestion) {
+                result.warnings.push(`  Suggestion: Use "${slugValidation.suggestion}" instead`);
+            }
+            // Keep the slug for reference but mark as invalid
+        }
+    }
+
+    // Validate appName if present
+    if (result.appName) {
+        const appNameValidation = validateAppName(result.appName);
+        if (!appNameValidation.valid) {
+            result.errors.push(`Invalid appName: ${appNameValidation.error}`);
+        }
+    }
+
     // Read .env.development for siteUrl, assets, and refreshToken (no fallback to config.ts)
     const envConfig = readEnvConfig(projectPath);
     result.envFileUsed = envConfig.envFileUsed;
@@ -294,9 +419,17 @@ export function readVueConfig(projectPath) {
     result.assets = envConfig.assets;
     result.refreshToken = envConfig.refreshToken;
 
+    // Merge env config errors and warnings
+    if (envConfig.errors?.length > 0) {
+        result.errors.push(...envConfig.errors);
+    }
+    if (envConfig.warnings?.length > 0) {
+        result.warnings.push(...envConfig.warnings);
+    }
+
     // Validate required fields in config.ts
     if (!result.slug) {
-        result.errors.push('Missing required field in config.ts: slug (appPath)');
+        result.errors.push('Missing required field in config.ts: slug (appSlug)');
     }
     if (!result.appName) {
         result.errors.push('Missing required field in config.ts: appName');
@@ -306,7 +439,7 @@ export function readVueConfig(projectPath) {
     if (!envConfig.envFileUsed) {
         result.warnings.push('No .env.development file found');
     } else {
-        if (!result.siteUrl) {
+        if (!result.siteUrl && !result.errors.some(e => e.includes('VITE_SITE_URL'))) {
             result.warnings.push('VITE_SITE_URL not set in .env.development');
         }
     }
@@ -364,17 +497,22 @@ export function getInjectionTarget(projectPath) {
  *
  * @param {string} projectPath - Path to the Vue project
  * @param {string[]} assets - Array of asset URLs to inject
- * @returns {{success: boolean, targetFile: string | null, targetName: string | null}}
+ * @returns {{success: boolean, targetFile: string | null, targetName: string | null, error: string | null}}
  */
 export function injectAssets(projectPath, assets) {
     const { targetFile, targetName } = getInjectionTarget(projectPath);
 
     if (!targetFile) {
-        return { success: false, targetFile: null, targetName: null };
+        return { success: false, targetFile: null, targetName: null, error: 'No .env.development file found' };
     }
 
-    const success = injectAssetsIntoEnv(targetFile, assets);
-    return { success, targetFile, targetName };
+    const result = injectAssetsIntoEnv(targetFile, assets);
+    return {
+        success: result.success,
+        targetFile,
+        targetName,
+        error: result.error
+    };
 }
 
 /**
@@ -382,16 +520,34 @@ export function injectAssets(projectPath, assets) {
  *
  * @param {string} envPath - Path to the .env file
  * @param {string[]} assets - Array of asset URLs to inject
- * @returns {boolean} - True if successful
+ * @returns {{success: boolean, error: string | null}}
  */
 export function injectAssetsIntoEnv(envPath, assets) {
     if (!existsSync(envPath)) {
-        return false;
+        return { success: false, error: 'File does not exist' };
+    }
+
+    let content;
+    try {
+        content = readFileSync(envPath, 'utf-8');
+    } catch (err) {
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                error: `Permission denied reading ${envPath}. Check file permissions.`
+            };
+        }
+        return { success: false, error: `Failed to read file: ${err.message}` };
     }
 
-    let content = readFileSync(envPath, 'utf-8');
+    // JSON stringify handles escaping properly
     const assetsJson = JSON.stringify(assets);
-    const newLine = `VITE_ASSETS = '${assetsJson}'`;
+
+    // Escape any single quotes in the JSON to prevent .env parsing issues
+    // This is extra safety - JSON.stringify shouldn't produce single quotes
+    const safeJson = assetsJson.replace(/'/g, "\\'");
+    const newLine = `VITE_ASSETS = '${safeJson}'`;
 
     // Check if VITE_ASSETS already exists
     const assetsPattern = /^VITE_ASSETS\s*=.*$/m;
@@ -403,8 +559,27 @@ export function injectAssetsIntoEnv(envPath, assets) {
         content = content.trimEnd() + '\n' + newLine + '\n';
     }
 
-    writeFileSync(envPath, content, 'utf-8');
-    return true;
+    try {
+        writeFileSync(envPath, content, 'utf-8');
+    } catch (err) {
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                error: `Permission denied writing to ${envPath}. ` +
+                       `Check file permissions or close any programs using this file.`
+            };
+        }
+        if (errorType === ErrorTypes.DISK_FULL) {
+            return {
+                success: false,
+                error: `Disk full - cannot write to ${envPath}. Free up disk space and try again.`
+            };
+        }
+        return { success: false, error: `Failed to write file: ${err.message}` };
+    }
+
+    return { success: true, error: null };
 }
 
 /**
@@ -422,7 +597,7 @@ Could not find config.ts in the Vue project.
 Expected location: ${join(projectPath, 'src/config.ts')}
 
 Required fields in config.ts:
-  - appPath (slug): App identifier (used as folder name)
+  - appSlug (slug): App identifier (used as folder name)
   - appName: Display name for navigation menu
 
 Required fields in .env.development:
@@ -432,7 +607,7 @@ Required fields in .env.development:
 
 Example config.ts:
   export const config = {
-    appPath: "my-app",
+    appSlug: "my-app",
     appName: "My Application"
   }
 

package/utils/iris/deleteHelper.js

@@ -2,6 +2,13 @@ import fs from 'fs';
 import path from 'path';
 import Config from '../config.js';
 import { deleteApp } from '../magentrix/api/iris.js';
+import {
+    detectErrorType,
+    ErrorTypes,
+    formatPermissionError,
+    formatFileLockError,
+    formatNetworkError
+} from './errors.js';
 
 const config = new Config();
 
@@ -53,14 +60,28 @@ export async function deleteIrisAppFromServer(instanceUrl, token, slug, options
         if (isNotFound) {
             // App doesn't exist on server, but clean up local cache anyway
             if (updateCache) {
-                config.removeKey(`iris-app:${slug}`, { filename: 'base.json' });
-                result.cleanedFromCache = true;
+                try {
+                    config.removeKey(`iris-app:${slug}`, { filename: 'base.json' });
+                    result.cleanedFromCache = true;
+                } catch {
+                    // Ignore cache update errors
+                }
             }
             result.success = true;
             result.error = 'App not found on server (already deleted)';
             return result;
         }
 
+        // Check for network errors and provide helpful messages
+        if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED' || error.code === 'ETIMEDOUT') {
+            result.error = formatNetworkError({
+                operation: 'delete app',
+                url: instanceUrl,
+                error
+            });
+            return result;
+        }
+
         result.error = errorMessage;
         return result;
     }
@@ -70,7 +91,7 @@ export async function deleteIrisAppFromServer(instanceUrl, token, slug, options
  * Delete local Iris app files.
  *
  * @param {string} appPath - Absolute path to the app folder
- * @returns {{success: boolean, existed: boolean, error: string | null, isPermissionError: boolean}}
+ * @returns {{success: boolean, existed: boolean, error: string | null, isPermissionError: boolean, isFileLocked: boolean}}
  */
 export function deleteLocalIrisAppFiles(appPath) {
     if (!fs.existsSync(appPath)) {
@@ -78,7 +99,8 @@ export function deleteLocalIrisAppFiles(appPath) {
             success: true,
             existed: false,
             error: null,
-            isPermissionError: false
+            isPermissionError: false,
+            isFileLocked: false
         };
     }
 
@@ -88,15 +110,41 @@ export function deleteLocalIrisAppFiles(appPath) {
             success: true,
             existed: true,
             error: null,
-            isPermissionError: false
+            isPermissionError: false,
+            isFileLocked: false
         };
     } catch (error) {
-        const isPermissionError = error.code === 'EACCES' || error.code === 'EPERM';
+        const errorType = detectErrorType(error);
+
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                existed: true,
+                error: formatPermissionError({
+                    operation: 'delete files',
+                    path: appPath
+                }),
+                isPermissionError: true,
+                isFileLocked: false
+            };
+        }
+
+        if (errorType === ErrorTypes.FILE_LOCKED) {
+            return {
+                success: false,
+                existed: true,
+                error: formatFileLockError({ path: appPath }),
+                isPermissionError: false,
+                isFileLocked: true
+            };
+        }
+
         return {
             success: false,
             existed: true,
             error: error.message,
-            isPermissionError
+            isPermissionError: false,
+            isFileLocked: false
         };
     }
 }