@magentrix-corp/magentrix-cli 1.2.0 → 1.3.0

package/actions/iris/buildStage.js

@@ -0,0 +1,330 @@
+import chalk from 'chalk';
+import { select, input, confirm } from '@inquirer/prompts';
+import { existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import Config from '../../utils/config.js';
+import { runPublish } from '../publish.js';
+import { isAutopublishRunning } from '../../utils/autopublishLock.js';
+import {
+    buildVueProject,
+    stageToCliProject,
+    findDistDirectory,
+    formatBuildError,
+    formatValidationError
+} from '../../utils/iris/builder.js';
+import { validateIrisBuild } from '../../utils/iris/validator.js';
+import {
+    readVueConfig,
+    formatMissingConfigError,
+    formatConfigErrors
+} from '../../utils/iris/config-reader.js';
+import {
+    getLinkedProjectsWithStatus,
+    linkVueProject,
+    findLinkedProjectByPath,
+    buildProjectChoices
+} from '../../utils/iris/linker.js';
+import { EXPORT_ROOT, IRIS_APPS_DIR, HASHED_CWD } from '../../vars/global.js';
+
+const config = new Config();
+
+/**
+ * Check if the current directory appears to be a Magentrix workspace.
+ * @returns {boolean} - True if in a Magentrix workspace
+ */
+function isMagentrixWorkspace() {
+    const magentrixFolder = join(process.cwd(), '.magentrix');
+    const srcFolder = join(process.cwd(), 'src');
+
+    // Check for .magentrix folder
+    if (!existsSync(magentrixFolder)) return false;
+
+    // Check for src folder (typical workspace structure)
+    if (!existsSync(srcFolder)) return false;
+
+    // Check if credentials are configured (instanceUrl or apiKey in global config)
+    const instanceUrl = config.read('instanceUrl', { global: true, pathHash: HASHED_CWD });
+    const apiKey = config.read('apiKey', { global: true, pathHash: HASHED_CWD });
+
+    return !!(instanceUrl || apiKey);
+}
+
+/**
+ * vue-build-stage command - Build a Vue project and stage to CLI workspace.
+ *
+ * Options:
+ *   --path <dir>      Specify Vue project path directly
+ *   --skip-build      Use existing dist/ without rebuilding
+ */
+export const vueBuildStage = async (options = {}) => {
+    process.stdout.write('\x1Bc'); // Clear console
+
+    const { path: pathOption, skipBuild } = options;
+
+    // Warn if not in a Magentrix workspace
+    if (!isMagentrixWorkspace()) {
+        console.log(chalk.yellow('⚠ Warning: Magentrix Workspace Not Detected'));
+        console.log(chalk.gray('─'.repeat(48)));
+        console.log(chalk.white('\nThis command should be run from your Magentrix CLI workspace directory.'));
+        console.log(chalk.white('It stages Vue.js build files to ') + chalk.cyan('src/iris-apps/<slug>/'));
+        console.log();
+        console.log(chalk.white('Expected workspace indicators:'));
+        console.log(chalk.gray('  • .magentrix/ folder (config and cache)'));
+        console.log(chalk.gray('  • src/ folder (code files and assets)'));
+        console.log(chalk.gray('  • Magentrix credentials configured'));
+        console.log();
+        console.log(chalk.white('Current directory: ') + chalk.gray(process.cwd()));
+        console.log();
+
+        const shouldContinue = await confirm({
+            message: 'Do you want to continue anyway?',
+            default: false
+        });
+
+        if (!shouldContinue) {
+            console.log(chalk.gray('\nCancelled. Run this command from your Magentrix workspace.'));
+            return;
+        }
+
+        console.log();
+    }
+
+    // Determine which project to build
+    let projectPath = pathOption;
+    let vueConfig = null;
+
+    if (projectPath) {
+        // Path provided via option
+        projectPath = resolve(projectPath);
+
+        if (!existsSync(projectPath)) {
+            console.log(chalk.red(`Error: Path does not exist: ${projectPath}`));
+            return;
+        }
+
+        vueConfig = readVueConfig(projectPath);
+    } else {
+        // Prompt user to select a project
+        const result = await selectProject();
+        if (!result) return; // User cancelled
+
+        projectPath = result.path;
+        vueConfig = result.config;
+    }
+
+    // Validate Vue config
+    if (!vueConfig.found) {
+        console.log(chalk.red(formatMissingConfigError(projectPath)));
+        return;
+    }
+
+    if (vueConfig.errors.length > 0) {
+        console.log(chalk.red(formatConfigErrors(vueConfig)));
+        return;
+    }
+
+    const { slug, appName } = vueConfig;
+
+    console.log(chalk.blue('\nVue Build & Stage'));
+    console.log(chalk.gray('─'.repeat(48)));
+    console.log(chalk.white(`  Project: ${chalk.cyan(appName)} (${slug})`));
+    console.log(chalk.white(`  Path: ${chalk.gray(projectPath)}`));
+    console.log();
+
+    // Ensure project is linked
+    const linked = findLinkedProjectByPath(projectPath);
+    if (!linked) {
+        const shouldLink = await confirm({
+            message: 'This project is not linked. Link it now?',
+            default: true
+        });
+
+        if (shouldLink) {
+            const linkResult = linkVueProject(projectPath);
+            if (!linkResult.success) {
+                console.log(chalk.red(`Failed to link project: ${linkResult.error}`));
+                return;
+            }
+            console.log(chalk.green(`\u2713 Project linked`));
+        }
+    }
+
+    let distPath;
+
+    if (skipBuild) {
+        // Use existing dist
+        distPath = findDistDirectory(projectPath);
+
+        if (!distPath) {
+            console.log(chalk.red('No existing dist/ directory found.'));
+            console.log(chalk.gray('Run without --skip-build to build the project.'));
+            return;
+        }
+
+        console.log(chalk.yellow(`Using existing dist: ${distPath}`));
+
+        // Validate the existing build
+        const validation = validateIrisBuild(distPath);
+        if (!validation.valid) {
+            console.log(chalk.red(formatValidationError(distPath, validation.errors)));
+            return;
+        }
+
+        console.log(chalk.green('\u2713 Existing build is valid'));
+    } else {
+        // Build the project
+        console.log(chalk.blue('Building project...'));
+        console.log();
+
+        const buildResult = await buildVueProject(projectPath, { silent: false });
+
+        if (!buildResult.success) {
+            console.log();
+            console.log(chalk.red(formatBuildError(projectPath, buildResult.error)));
+            return;
+        }
+
+        distPath = buildResult.distPath;
+        console.log();
+        console.log(chalk.green(`\u2713 Build completed successfully`));
+        console.log(chalk.gray(`  Output: ${distPath}`));
+
+        // Validate build output
+        const validation = validateIrisBuild(distPath);
+        if (!validation.valid) {
+            console.log();
+            console.log(chalk.red(formatValidationError(distPath, validation.errors)));
+            return;
+        }
+
+        console.log(chalk.green('\u2713 Build output validated'));
+    }
+
+    // Stage to CLI project
+    console.log();
+    console.log(chalk.blue('Staging to CLI workspace...'));
+
+    const stageResult = stageToCliProject(distPath, slug);
+
+    if (!stageResult.success) {
+        console.log(chalk.red(`Failed to stage: ${stageResult.error}`));
+        return;
+    }
+
+    console.log(chalk.green(`\u2713 Staged ${stageResult.fileCount} files to ${stageResult.stagedPath}`));
+
+    // Summary
+    console.log();
+    console.log(chalk.green('─'.repeat(48)));
+    console.log(chalk.green.bold('\u2713 Build & Stage Complete!'));
+    console.log();
+    console.log(chalk.gray(`Staged to: ${EXPORT_ROOT}/${IRIS_APPS_DIR}/${slug}/`));
+    console.log();
+
+    // Check if autopublish is running
+    if (isAutopublishRunning()) {
+        console.log(chalk.cyan('✓ Autopublish is running - changes will be deployed automatically'));
+    } else {
+        // Prompt to run publish now
+        const shouldPublish = await confirm({
+            message: 'Do you want to publish to Magentrix now?',
+            default: true
+        });
+
+        if (shouldPublish) {
+            console.log();
+            console.log(chalk.blue('Running publish...'));
+            console.log();
+
+            try {
+                await runPublish();
+            } catch (error) {
+                console.log(chalk.red(`\nPublish failed: ${error.message}`));
+                console.log(chalk.gray('You can run it manually later with:'), chalk.yellow('magentrix publish'));
+            }
+        } else {
+            console.log();
+            console.log(chalk.cyan('Next steps:'));
+            console.log(chalk.white(`  • Run ${chalk.yellow('magentrix publish')} to deploy to Magentrix`));
+            console.log(chalk.white(`  • Or use ${chalk.yellow('magentrix autopublish')} for automatic deployment`));
+        }
+    }
+};
+
+/**
+ * Prompt user to select a project.
+ *
+ * @returns {Promise<{path: string, config: object} | null>}
+ */
+async function selectProject() {
+    const projectsWithStatus = getLinkedProjectsWithStatus();
+
+    // Check if CWD is a Vue project (and not already linked)
+    const cwdConfig = readVueConfig(process.cwd());
+    const inVueProject = cwdConfig.found && cwdConfig.errors.length === 0;
+    const cwdAlreadyLinked = projectsWithStatus.some(p =>
+        resolve(p.path) === resolve(process.cwd())
+    );
+
+    // Build choices using the helper
+    const choices = buildProjectChoices({
+        includeManual: true,
+        includeCancel: true,
+        showInvalid: true
+    });
+
+    // If CWD is a valid Vue project and not linked, add it at the top
+    if (inVueProject && !cwdAlreadyLinked) {
+        choices.unshift({
+            name: `${cwdConfig.appName} (${cwdConfig.slug}) - Current directory (not linked)`,
+            value: { type: 'cwd', path: process.cwd() }
+        });
+    }
+
+    // Check if we have any projects to show
+    const hasProjects = choices.some(c => c.value?.type === 'linked' || c.value?.type === 'cwd');
+
+    if (!hasProjects) {
+        console.log(chalk.yellow('No linked Vue projects found.'));
+        console.log();
+        console.log(chalk.gray('To get started:'));
+        console.log(chalk.white(`  1. Link a Vue project: ${chalk.cyan('magentrix iris-link')}`));
+        console.log(chalk.white(`  2. Or specify path: ${chalk.cyan('magentrix vue-build-stage --path /path/to/vue-project')}`));
+        console.log();
+    }
+
+    const choice = await select({
+        message: 'Which project do you want to build?',
+        choices
+    });
+
+    if (choice.type === 'cancel') {
+        console.log(chalk.gray('Cancelled.'));
+        return null;
+    }
+
+    if (choice.type === 'manual') {
+        const manualPath = await input({
+            message: 'Enter the path to your Vue project:',
+            validate: (value) => {
+                if (!value.trim()) {
+                    return 'Path is required';
+                }
+                const resolved = resolve(value);
+                if (!existsSync(resolved)) {
+                    return `Path does not exist: ${resolved}`;
+                }
+                return true;
+            }
+        });
+
+        const config = readVueConfig(resolve(manualPath));
+        return { path: resolve(manualPath), config };
+    }
+
+    // Linked project or CWD
+    const config = readVueConfig(choice.path);
+    return { path: choice.path, config };
+}
+
+export default vueBuildStage;

package/actions/iris/delete.js

@@ -0,0 +1,211 @@
+import chalk from 'chalk';
+import { select, input, confirm } from '@inquirer/prompts';
+import path from 'path';
+import Config from '../../utils/config.js';
+import { ensureValidCredentials } from '../../utils/cli/helpers/ensureCredentials.js';
+import { backupIrisApp } from '../../utils/iris/backup.js';
+import { getLinkedProjects, unlinkVueProject } from '../../utils/iris/linker.js';
+import { deleteIrisAppFromServer, deleteLocalIrisAppFiles } from '../../utils/iris/deleteHelper.js';
+import { showPermissionError } from '../../utils/permissionError.js';
+import { EXPORT_ROOT, IRIS_APPS_DIR } from '../../vars/global.js';
+
+const config = new Config();
+
+/**
+ * iris-delete command - Delete a published Iris app with backup and recovery.
+ */
+export const irisDelete = async () => {
+    process.stdout.write('\x1Bc'); // Clear console
+
+    console.log(chalk.red.bold('\n⚠ Delete Iris App'));
+    console.log(chalk.gray('─'.repeat(48)));
+    console.log();
+
+    // Get list of published apps from base.json
+    const cachedResults = config.read(null, { filename: "base.json" });
+    const cachedIrisApps = Object.values(cachedResults || {})
+        .filter(entry => entry.type === 'IrisApp' || entry.Type === 'IrisApp')
+        .map(entry => {
+            const slug = entry.folderName || (entry.recordId && entry.recordId.startsWith('iris-app:')
+                ? entry.recordId.replace('iris-app:', '')
+                : null);
+            return {
+                slug,
+                appName: entry.appName || slug,
+                folderName: entry.folderName || slug
+            };
+        })
+        .filter(app => app.slug);
+
+    if (cachedIrisApps.length === 0) {
+        console.log(chalk.yellow('No published Iris apps found.'));
+        console.log();
+        console.log(chalk.gray('Published apps appear here after running:'));
+        console.log(chalk.white(`  1. ${chalk.cyan('magentrix vue-build-stage')}`));
+        console.log(chalk.white(`  2. ${chalk.cyan('magentrix publish')}`));
+        console.log();
+        return;
+    }
+
+    // Build choices
+    const choices = cachedIrisApps.map(app => ({
+        name: `${app.appName} (${app.slug})`,
+        value: app
+    }));
+
+    choices.push({
+        name: 'Cancel',
+        value: null
+    });
+
+    // Select app to delete
+    const selectedApp = await select({
+        message: 'Which Iris app do you want to delete?',
+        choices
+    });
+
+    if (!selectedApp) {
+        console.log(chalk.gray('Cancelled.'));
+        return;
+    }
+
+    const { slug, appName } = selectedApp;
+
+    // Show destructive warning
+    console.log();
+    console.log(chalk.bgRed.bold.white('  ⚠ DESTRUCTIVE OPERATION  '));
+    console.log(chalk.red('─'.repeat(48)));
+    console.log(chalk.white('This will permanently delete:'));
+    console.log(chalk.red(`  • App from server: ${chalk.cyan(appName)} (${slug})`));
+    console.log(chalk.red(`  • Local files: ${chalk.gray(`src/iris-apps/${slug}/`)}`));
+    console.log(chalk.red(`  • Navigation menu entry on Magentrix`));
+    console.log();
+    console.log(chalk.yellow('A recovery backup will be created before deletion.'));
+    console.log(chalk.gray('You can restore using: ') + chalk.cyan('magentrix iris-recover'));
+    console.log(chalk.red('─'.repeat(48)));
+    console.log();
+
+    // Confirm deletion by typing app name
+    const confirmation = await input({
+        message: `Type the app slug "${slug}" to confirm deletion:`,
+        validate: (value) => {
+            if (value === slug) return true;
+            return `Please type exactly: ${slug}`;
+        }
+    });
+
+    if (confirmation !== slug) {
+        console.log(chalk.gray('Cancelled.'));
+        return;
+    }
+
+    // Check if app is linked
+    const linkedProjects = getLinkedProjects();
+    const linkedProject = linkedProjects.find(p => p.slug === slug);
+
+    let shouldUnlink = false;
+    if (linkedProject) {
+        console.log();
+        shouldUnlink = await confirm({
+            message: `This app is linked to a Vue project at ${linkedProject.path}. Unlink it?`,
+            default: false
+        });
+    }
+
+    // Create backup
+    console.log();
+    console.log(chalk.blue('Creating recovery backup...'));
+
+    const appPath = path.join(EXPORT_ROOT, IRIS_APPS_DIR, slug);
+    const backupResult = await backupIrisApp(appPath, {
+        slug,
+        appName,
+        linkedProject: linkedProject || null
+    });
+
+    if (!backupResult.success) {
+        console.log(chalk.red(`Failed to create backup: ${backupResult.error}`));
+        console.log(chalk.yellow('Deletion cancelled for safety.'));
+        return;
+    }
+
+    console.log(chalk.green(`✓ Backup created: ${backupResult.backupPath}`));
+
+    // Delete from server
+    console.log();
+    console.log(chalk.blue('Deleting from Magentrix server...'));
+
+    const { instanceUrl, token } = await ensureValidCredentials();
+    const deleteResult = await deleteIrisAppFromServer(instanceUrl, token.value, slug, {
+        updateCache: true  // Automatically updates base.json
+    });
+
+    if (!deleteResult.success && deleteResult.error !== 'App not found on server (already deleted)') {
+        console.log(chalk.red(`Failed to delete from server: ${deleteResult.error}`));
+        console.log(chalk.yellow('Backup preserved. Use ') + chalk.cyan('magentrix iris-recover') + chalk.yellow(' to restore.'));
+        return;
+    }
+
+    if (deleteResult.error === 'App not found on server (already deleted)') {
+        console.log(chalk.yellow('⚠ App not found on server (already deleted)'));
+    } else {
+        console.log(chalk.green('✓ Deleted from server'));
+    }
+
+    if (deleteResult.cleanedFromCache) {
+        console.log(chalk.green('✓ Cache updated'));
+    }
+
+    // Delete local files
+    console.log(chalk.blue('Deleting local files...'));
+
+    const localDeleteResult = deleteLocalIrisAppFiles(appPath);
+
+    if (localDeleteResult.success) {
+        if (localDeleteResult.existed) {
+            console.log(chalk.green('✓ Local files deleted'));
+        } else {
+            console.log(chalk.gray('  (No local files found)'));
+        }
+    } else if (localDeleteResult.isPermissionError) {
+        showPermissionError({
+            operation: 'delete',
+            targetPath: appPath
+        });
+        console.log();
+        console.log(chalk.gray('Note: The app was deleted from the server and cache.'));
+        console.log(chalk.gray('Only local file cleanup failed.'));
+        console.log();
+    } else {
+        console.log(chalk.yellow(`⚠ Failed to delete local files: ${localDeleteResult.error}`));
+        console.log(chalk.gray(`Path: ${appPath}`));
+        console.log(chalk.white('You may need to delete manually.'));
+    }
+
+    // Unlink Vue project if requested
+    if (shouldUnlink && linkedProject) {
+        console.log(chalk.blue('Unlinking Vue project...'));
+        unlinkVueProject(linkedProject.path);
+        console.log(chalk.green('✓ Vue project unlinked'));
+    }
+
+    // Summary
+    console.log();
+    console.log(chalk.green('─'.repeat(48)));
+    if (localDeleteResult.success) {
+        console.log(chalk.green.bold('✓ Iris App Deleted Successfully!'));
+    } else {
+        console.log(chalk.yellow.bold('⚠ Iris App Partially Deleted'));
+        console.log();
+        console.log(chalk.green('✓ Deleted from server'));
+        console.log(chalk.green('✓ Cache updated'));
+        console.log(chalk.yellow('⚠ Local files require manual deletion'));
+    }
+    console.log();
+    console.log(chalk.cyan('Recovery:'));
+    console.log(chalk.white(`  Backup saved to: ${chalk.gray(backupResult.backupPath)}`));
+    console.log(chalk.white(`  To restore, run: ${chalk.cyan('magentrix iris-recover')}`));
+    console.log();
+};
+
+export default irisDelete;