@magentrix-corp/magentrix-cli 1.2.1 → 1.3.0

package/utils/magentrix/api/iris.js

@@ -0,0 +1,235 @@
+import { fetchMagentrix } from "../fetch.js";
+import { File } from "node:buffer";
+
+/**
+ * List all deployed Iris applications.
+ * @param {string} instanceUrl - Magentrix instance base URL
+ * @param {string} token - OAuth2 bearer token
+ * @returns {Promise<{success: boolean, apps: Array<{folderName: string, uploadedOn: string, modifiedOn: string, size: number}>}>}
+ */
+export const listApps = async (instanceUrl, token) => {
+    if (!instanceUrl || !token) {
+        throw new Error('Missing required Magentrix instanceUrl or token');
+    }
+
+    const response = await fetchMagentrix({
+        instanceUrl,
+        token,
+        path: '/iris/listapps',
+        method: 'GET',
+        returnErrorObject: true
+    });
+
+    return response;
+};
+
+/**
+ * Publish (upload) an Iris Vue.js application.
+ * @param {string} instanceUrl - Magentrix instance base URL
+ * @param {string} token - OAuth2 bearer token
+ * @param {Buffer} zipBuffer - The zip file as a Buffer
+ * @param {string} filename - The filename for the zip (e.g., "my-app.zip")
+ * @param {string} appName - The user-friendly display name (required for navigation)
+ * @returns {Promise<{success: boolean, message: string, folderName: string}>}
+ */
+export const publishApp = async (instanceUrl, token, zipBuffer, filename, appName) => {
+    if (!instanceUrl || !token) {
+        throw new Error('Missing required Magentrix instanceUrl or token');
+    }
+
+    if (!zipBuffer || !Buffer.isBuffer(zipBuffer)) {
+        throw new Error('zipBuffer must be a valid Buffer');
+    }
+
+    if (!filename) {
+        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' });
+
+    const formData = new FormData();
+    formData.append('file', file);
+
+    // app-name is passed as URL parameter (required for navigation)
+    const response = await fetchMagentrix({
+        instanceUrl,
+        token,
+        path: `/iris/publishapp?app-name=${encodeURIComponent(appName)}`,
+        method: 'POST',
+        body: formData,
+        ignoreContentType: true,
+        returnErrorObject: true
+    });
+
+    return response;
+};
+
+/**
+ * Delete an Iris application.
+ * @param {string} instanceUrl - Magentrix instance base URL
+ * @param {string} token - OAuth2 bearer token
+ * @param {string} folderName - The folder name of the app to delete
+ * @returns {Promise<{success: boolean, message: string}>}
+ */
+export const deleteApp = async (instanceUrl, token, folderName) => {
+    if (!instanceUrl || !token) {
+        throw new Error('Missing required Magentrix instanceUrl or token');
+    }
+
+    if (!folderName) {
+        throw new Error('folderName is required');
+    }
+
+    const response = await fetchMagentrix({
+        instanceUrl,
+        token,
+        path: `/iris/deleteapp?folderName=${encodeURIComponent(folderName)}`,
+        method: 'POST',
+        returnErrorObject: true
+    });
+
+    return response;
+};
+
+/**
+ * Download a single Iris application as a buffer.
+ * @param {string} instanceUrl - Magentrix instance base URL
+ * @param {string} token - OAuth2 bearer token
+ * @param {string} folderName - The folder name of the app to download
+ * @returns {Promise<{buffer: Buffer, filename: string}>}
+ */
+export const downloadApp = async (instanceUrl, token, folderName) => {
+    if (!instanceUrl || !token) {
+        throw new Error('Missing required Magentrix instanceUrl or token');
+    }
+
+    if (!folderName) {
+        throw new Error('folderName is required');
+    }
+
+    const url = `${instanceUrl.replace(/\/$/, '')}/iris/downloadapp?folderName=${encodeURIComponent(folderName)}`;
+
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        let errorMessage = `Download failed (${response.status})`;
+        try {
+            const errorData = await response.json();
+            if (errorData.message) {
+                errorMessage = errorData.message;
+            }
+        } catch {
+            errorMessage = `Download failed: ${response.statusText}`;
+        }
+        throw new Error(errorMessage);
+    }
+
+    // Get filename from Content-Disposition header
+    const contentDisposition = response.headers.get('content-disposition') || '';
+    const filenameMatch = /filename\*?=(?:UTF-8'')?["']?([^"';]+)["']?/i.exec(contentDisposition);
+    const filename = filenameMatch ? decodeURIComponent(filenameMatch[1]) : `${folderName}.zip`;
+
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+
+    return { buffer, filename };
+};
+
+/**
+ * Download all Iris applications as a single zip buffer.
+ * @param {string} instanceUrl - Magentrix instance base URL
+ * @param {string} token - OAuth2 bearer token
+ * @returns {Promise<{buffer: Buffer, filename: string}>}
+ */
+export const downloadAllApps = async (instanceUrl, token) => {
+    if (!instanceUrl || !token) {
+        throw new Error('Missing required Magentrix instanceUrl or token');
+    }
+
+    const url = `${instanceUrl.replace(/\/$/, '')}/iris/downloadallapps`;
+
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        let errorMessage = `Download failed (${response.status})`;
+        try {
+            const errorData = await response.json();
+            if (errorData.message) {
+                errorMessage = errorData.message;
+            }
+        } catch {
+            errorMessage = `Download failed: ${response.statusText}`;
+        }
+        throw new Error(errorMessage);
+    }
+
+    // Get filename from Content-Disposition header
+    const contentDisposition = response.headers.get('content-disposition') || '';
+    const filenameMatch = /filename\*?=(?:UTF-8'')?["']?([^"';]+)["']?/i.exec(contentDisposition);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const filename = filenameMatch ? decodeURIComponent(filenameMatch[1]) : `iris-apps_${timestamp}.zip`;
+
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+
+    return { buffer, filename };
+};
+
+/**
+ * Get platform assets for local development (CSS, fonts, etc.).
+ * @param {string} siteUrl - Magentrix instance base URL (from Vue config.ts)
+ * @param {string} token - OAuth2 bearer token
+ * @returns {Promise<{success: boolean, assets: string[]}>}
+ */
+export const getIrisAssets = async (siteUrl, token) => {
+    if (!siteUrl) {
+        throw new Error('Missing required siteUrl');
+    }
+
+    const url = `${siteUrl.replace(/\/$/, '')}/iris/getirisassets`;
+
+    const headers = {
+        'Accept': 'application/json'
+    };
+
+    // Token is optional for this endpoint (might be public)
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    const response = await fetch(url, {
+        method: 'GET',
+        headers
+    });
+
+    if (!response.ok) {
+        let errorMessage = `Failed to fetch Iris assets (${response.status})`;
+        try {
+            const errorData = await response.json();
+            if (errorData.message) {
+                errorMessage = errorData.message;
+            }
+        } catch {
+            errorMessage = `Failed to fetch Iris assets: ${response.statusText}`;
+        }
+        throw new Error(errorMessage);
+    }
+
+    const data = await response.json();
+    return data;
+};

package/utils/permissionError.js

@@ -0,0 +1,70 @@
+import chalk from 'chalk';
+import os from 'os';
+
+/**
+ * Display a user-friendly permission error message with platform-specific guidance.
+ *
+ * @param {object} options - Options for the error message
+ * @param {string} options.operation - What operation failed ('delete' or 'restore')
+ * @param {string} options.targetPath - The path that couldn't be accessed
+ * @param {string} [options.backupPath] - Optional backup path (for restore operations)
+ * @param {string} [options.slug] - Optional app slug (for restore operations)
+ */
+export function showPermissionError({ operation, targetPath, backupPath, slug }) {
+    const platform = os.platform();
+    const username = os.userInfo().username;
+    const group = platform === 'darwin' ? 'staff' : username;
+
+    console.log();
+    console.log(chalk.bgYellow.bold.black('  ⚠ Permission Denied  '));
+    console.log(chalk.yellow('─'.repeat(48)));
+    console.log(chalk.white(`Cannot ${operation} files due to permission issues.`));
+    console.log();
+    console.log(chalk.white('This may happen if:'));
+    console.log(chalk.gray('  • A process has the folder locked'));
+    console.log(chalk.gray('  • The folder is owned by another user (e.g., root)'));
+    if (platform === 'darwin') {
+        console.log(chalk.gray('  • macOS Gatekeeper is blocking the operation'));
+    }
+    console.log();
+    console.log(chalk.white('To fix this, try:'));
+    console.log(chalk.cyan('  1. Close any editors that have the folder open'));
+    console.log(chalk.cyan('  2. Run the command again'));
+    console.log();
+
+    // Platform-specific ownership fix
+    if (platform === 'win32') {
+        console.log(chalk.white('If the folder has wrong ownership, run as Administrator:'));
+        console.log(chalk.cyan(`  icacls "${targetPath}" /grant ${username}:F /T`));
+    } else {
+        console.log(chalk.white('If the folder has wrong ownership, run:'));
+        console.log(chalk.cyan(`  sudo chown -R ${username}:${group} "${targetPath}"`));
+    }
+    console.log();
+
+    // Operation-specific manual commands
+    if (operation === 'delete') {
+        console.log(chalk.white('Or delete manually:'));
+        if (platform === 'win32') {
+            console.log(chalk.cyan(`  rmdir /s /q "${targetPath}"`));
+        } else {
+            console.log(chalk.cyan(`  rm -rf "${targetPath}"`));
+        }
+    } else if (operation === 'restore' && backupPath && slug) {
+        console.log(chalk.white('Or manually restore:'));
+        const zipPath = `${backupPath}/${slug}.zip`;
+        const destDir = targetPath.replace(/[/\\][^/\\]+$/, ''); // Parent directory
+        if (platform === 'win32') {
+            console.log(chalk.cyan(`  tar -xf "${zipPath}" -C "${destDir}"`));
+        } else {
+            console.log(chalk.cyan(`  unzip "${zipPath}" -d "${destDir}"`));
+        }
+    }
+
+    console.log(chalk.yellow('─'.repeat(48)));
+
+    if (backupPath) {
+        console.log();
+        console.log(chalk.gray(`Backup preserved at: ${backupPath}`));
+    }
+}

package/utils/progress.js

@@ -40,6 +40,7 @@ export class ProgressTracker {
         this.interval = null;
         this.lastRenderLength = 0;
         this.isFinished = false;
+        this.issues = [];  // Collected issues/warnings to display at end
     }
 
     /**
@@ -147,6 +148,36 @@ export class ProgressTracker {
         this.render();
     }
 
+    /**
+     * Add an issue/warning to be displayed at the end
+     * @param {string} type - 'error' | 'warning' | 'info'
+     * @param {string} message - The issue message
+     * @param {string} [hint] - Optional hint for resolution
+     */
+    addIssue(type, message, hint = null) {
+        this.issues.push({ type, message, hint });
+    }
+
+    /**
+     * Check if there are any issues collected
+     * @returns {boolean}
+     */
+    hasIssues() {
+        return this.issues.length > 0;
+    }
+
+    /**
+     * Get issues by type
+     * @param {string} type - 'error' | 'warning' | 'info'
+     * @returns {Array}
+     */
+    getIssues(type = null) {
+        if (type) {
+            return this.issues.filter(i => i.type === type);
+        }
+        return this.issues;
+    }
+
     /**
      * Update the message for the current step
      * @param {string} message - New message
@@ -289,8 +320,12 @@ export class ProgressTracker {
     /**
      * Finish the progress tracker
      * @param {string} message - Optional final message
+     * @param {object} options - Optional configuration
+     * @param {boolean} options.showIssues - Whether to show collected issues (default: false)
      */
-    finish(message = '') {
+    finish(message = '', options = {}) {
+        const { showIssues = false } = options;
+
         this.stopSpinner();
         this.isFinished = true;
 
@@ -318,6 +353,57 @@ export class ProgressTracker {
             console.log(chalk.green(`✓ All ${completed} step(s) completed successfully`));
         }
         console.log('');
+
+        // Only display collected issues if explicitly requested
+        if (showIssues && this.issues.length > 0) {
+            this.displayIssues();
+        }
+    }
+
+    /**
+     * Display collected issues
+     * Can be called manually after finish() if needed
+     */
+    displayIssues() {
+        if (this.issues.length === 0) return;
+
+        const errors = this.issues.filter(i => i.type === 'error');
+        const warnings = this.issues.filter(i => i.type === 'warning');
+        const infos = this.issues.filter(i => i.type === 'info');
+
+        console.log(chalk.bold('Issues Summary:'));
+
+        if (errors.length > 0) {
+            console.log(chalk.red(`  ✗ ${errors.length} error(s)`));
+            errors.forEach((issue, i) => {
+                console.log(chalk.red(`    ${i + 1}. ${issue.message}`));
+                if (issue.hint) {
+                    console.log(chalk.yellow(`       ${issue.hint}`));
+                }
+            });
+        }
+
+        if (warnings.length > 0) {
+            console.log(chalk.yellow(`  ⚠ ${warnings.length} warning(s)`));
+            warnings.forEach((issue, i) => {
+                console.log(chalk.yellow(`    ${i + 1}. ${issue.message}`));
+                if (issue.hint) {
+                    console.log(chalk.gray(`       ${issue.hint}`));
+                }
+            });
+        }
+
+        if (infos.length > 0) {
+            console.log(chalk.cyan(`  ℹ ${infos.length} info(s)`));
+            infos.forEach((issue, i) => {
+                console.log(chalk.cyan(`    ${i + 1}. ${issue.message}`));
+                if (issue.hint) {
+                    console.log(chalk.gray(`       ${issue.hint}`));
+                }
+            });
+        }
+
+        console.log('');
     }
 
     /**

package/utils/updateFileBase.js

@@ -65,9 +65,9 @@ export const updateBase = (filePath, record, actualPath = '', contentSnapshot =
     // Use snapshot if provided (to avoid race conditions), otherwise read from disk
     let fileContent, contentHash;
     if (isDirectory) {
-        // Folders don't have content
+        // Folders don't have content - use provided contentHash if any (e.g., for Iris apps)
         fileContent = '';
-        contentHash = '';
+        contentHash = record.contentHash || '';
     } else if (contentSnapshot && contentSnapshot.content) {
         // Use the snapshot of what was actually published
         fileContent = contentSnapshot.content;
@@ -91,6 +91,14 @@ export const updateBase = (filePath, record, actualPath = '', contentSnapshot =
         filePath,
         lastKnownActualPath: fileSystemLocation,
         lastKnownPath: path.resolve(filePath)
+    };
+
+    // Preserve custom fields from record (e.g., for Iris apps: folderName, appName, modifiedOn)
+    const customFields = ['folderName', 'appName', 'modifiedOn', 'uploadedOn', 'size'];
+    for (const field of customFields) {
+        if (record[field] !== undefined) {
+            saveData[field] = record[field];
+        }
     }
 
     if (saveData.type === 'File' || saveData.type === 'Folder') delete saveData.compressedContent;

package/vars/global.js

@@ -4,6 +4,7 @@ export const CWD = process.cwd();
 export const HASHED_CWD = sha256(CWD);
 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
 
 /**
      * Maps Magentrix Type fields to local folder names and extensions.