@magentrix-corp/magentrix-cli 1.2.0 → 1.3.0

package/actions/iris/link.js

@@ -0,0 +1,377 @@
+import chalk from 'chalk';
+import { select, input, confirm } from '@inquirer/prompts';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import {
+    linkVueProject,
+    unlinkVueProject,
+    getLinkedProjectsWithStatus,
+    formatLinkedProjects,
+    cleanupInvalidProjects
+} from '../../utils/iris/linker.js';
+import { formatMissingConfigError, formatConfigErrors, readVueConfig } from '../../utils/iris/config-reader.js';
+
+/**
+ * iris-link command - Link a Vue project to the CLI.
+ *
+ * Options:
+ *   --path <dir>    Specify Vue project path directly
+ *   --unlink        Remove a linked project
+ *   --list          Show all linked projects
+ *   --cleanup       Remove invalid (non-existent) linked projects
+ */
+export const irisLink = async (options = {}) => {
+    process.stdout.write('\x1Bc'); // Clear console
+
+    const { path: pathOption, unlink, list, cleanup } = options;
+
+    // Handle --list option
+    if (list) {
+        const projects = getLinkedProjectsWithStatus();
+        console.log(formatLinkedProjects(projects));
+        return;
+    }
+
+    // Handle --cleanup option
+    if (cleanup) {
+        await handleCleanup();
+        return;
+    }
+
+    // Handle --unlink option
+    if (unlink) {
+        await handleUnlink(pathOption);
+        return;
+    }
+
+    // If path provided directly, link it
+    if (pathOption) {
+        await linkProjectDirect(pathOption);
+        return;
+    }
+
+    // Interactive mode - show main menu
+    await showMainMenu();
+};
+
+/**
+ * Show the main menu for managing linked projects.
+ */
+async function showMainMenu() {
+    const projects = getLinkedProjectsWithStatus();
+    const validCount = projects.filter(p => p.validation.valid).length;
+    const invalidCount = projects.filter(p => !p.validation.valid).length;
+
+    console.log(chalk.blue.bold('Iris Vue Project Manager'));
+    console.log(chalk.gray('─'.repeat(48)));
+
+    if (projects.length > 0) {
+        console.log(chalk.white(`Linked projects: ${validCount} valid`));
+        if (invalidCount > 0) {
+            console.log(chalk.yellow(`                 ${invalidCount} with issues`));
+        }
+    } else {
+        console.log(chalk.gray('No Vue projects linked yet.'));
+    }
+    console.log();
+
+    const choices = [
+        {
+            name: 'Link a new Vue project',
+            value: 'link',
+            description: 'Add a Vue project to the CLI'
+        }
+    ];
+
+    if (projects.length > 0) {
+        choices.push({
+            name: 'View linked projects',
+            value: 'list',
+            description: 'Show all linked Vue projects with status'
+        });
+        choices.push({
+            name: 'Unlink a project',
+            value: 'unlink',
+            description: 'Remove a Vue project from the CLI'
+        });
+    }
+
+    if (invalidCount > 0) {
+        choices.push({
+            name: `Clean up invalid projects (${invalidCount})`,
+            value: 'cleanup',
+            description: 'Remove projects with missing paths'
+        });
+    }
+
+    choices.push({
+        name: 'Exit',
+        value: 'exit'
+    });
+
+    const action = await select({
+        message: 'What would you like to do?',
+        choices
+    });
+
+    switch (action) {
+        case 'link':
+            await handleLink();
+            break;
+        case 'list':
+            console.log();
+            console.log(formatLinkedProjects(projects));
+            break;
+        case 'unlink':
+            await handleUnlink();
+            break;
+        case 'cleanup':
+            await handleCleanup();
+            break;
+        case 'exit':
+            console.log(chalk.gray('Goodbye!'));
+            break;
+    }
+}
+
+/**
+ * Handle linking a new Vue project.
+ */
+async function handleLink(pathOption) {
+    let projectPath = pathOption;
+
+    // If no path provided, prompt for one
+    if (!projectPath) {
+        // Check if we're in a Vue project directory
+        const cwdConfig = readVueConfig(process.cwd());
+        const cwdPath = process.cwd();
+
+        const choices = [];
+
+        // Always show current directory option, but disable if not a valid Vue project
+        if (cwdConfig.found && cwdConfig.errors.length === 0) {
+            // Valid Vue project
+            choices.push({
+                name: `Current directory - ${cwdConfig.appName} (${cwdConfig.slug})`,
+                value: cwdPath,
+                description: cwdPath
+            });
+        } else if (cwdConfig.found && cwdConfig.errors.length > 0) {
+            // Has config.ts but with errors
+            const errorMsg = cwdConfig.errors[0] || 'Invalid config';
+            choices.push({
+                name: `Current directory`,
+                value: '__disabled__',
+                disabled: `Config error: ${errorMsg}`,
+                description: cwdPath
+            });
+        } else {
+            // No config.ts found
+            choices.push({
+                name: `Current directory`,
+                value: '__disabled__',
+                disabled: 'No config.ts found',
+                description: cwdPath
+            });
+        }
+
+        choices.push({
+            name: 'Enter path manually',
+            value: '__manual__',
+            description: 'Specify the full path to a Vue project'
+        });
+
+        choices.push({
+            name: 'Cancel',
+            value: '__cancel__'
+        });
+
+        const choice = await select({
+            message: 'Which Vue project do you want to link?',
+            choices
+        });
+
+        if (choice === '__cancel__') {
+            console.log(chalk.gray('Cancelled.'));
+            return;
+        }
+
+        if (choice === '__manual__') {
+            projectPath = 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;
+                }
+            });
+        } else {
+            projectPath = choice;
+        }
+    }
+
+    await linkProjectDirect(projectPath);
+}
+
+/**
+ * Link a project directly by path.
+ */
+async function linkProjectDirect(projectPath) {
+    // Resolve the path
+    projectPath = resolve(projectPath);
+
+    // Validate path exists
+    if (!existsSync(projectPath)) {
+        console.log(chalk.red(`Error: Path does not exist: ${projectPath}`));
+        return;
+    }
+
+    // Check Vue config
+    const vueConfig = readVueConfig(projectPath);
+    if (!vueConfig.found) {
+        console.log(chalk.red(formatMissingConfigError(projectPath)));
+        return;
+    }
+
+    if (vueConfig.errors.length > 0) {
+        console.log(chalk.red(formatConfigErrors(vueConfig)));
+        return;
+    }
+
+    // Link the project
+    console.log(chalk.blue(`\nLinking Vue project...`));
+    console.log(chalk.gray(`  Path: ${projectPath}`));
+    console.log(chalk.gray(`  Slug: ${vueConfig.slug}`));
+    console.log(chalk.gray(`  Name: ${vueConfig.appName}`));
+    if (vueConfig.siteUrl) {
+        console.log(chalk.gray(`  Site: ${vueConfig.siteUrl}`));
+    }
+    console.log();
+
+    const result = linkVueProject(projectPath);
+
+    if (!result.success) {
+        console.log(chalk.red(`Failed to link project: ${result.error}`));
+        return;
+    }
+
+    if (result.updated) {
+        console.log(chalk.green(`\u2713 Project updated successfully!`));
+        console.log(chalk.gray(`  The linked project configuration has been updated.`));
+    } else {
+        console.log(chalk.green(`\u2713 Project linked successfully!`));
+        console.log();
+        console.log(chalk.cyan('Next steps:'));
+        console.log(chalk.white(`  1. Build and stage: ${chalk.yellow('magentrix vue-build-stage')}`));
+        console.log(chalk.white(`  2. Publish to server: ${chalk.yellow('magentrix publish')}`));
+        console.log(chalk.white(`     Or use ${chalk.yellow('magentrix autopublish')} for automatic publishing`));
+    }
+
+    console.log();
+    console.log(chalk.gray('Note: Linked projects are stored globally and available across all Magentrix workspaces.'));
+}
+
+/**
+ * Handle unlinking a Vue project.
+ */
+async function handleUnlink(pathOption) {
+    const linkedProjects = getLinkedProjectsWithStatus();
+
+    if (linkedProjects.length === 0) {
+        console.log(chalk.yellow('No Vue projects are currently linked.'));
+        return;
+    }
+
+    let projectToUnlink = pathOption;
+
+    // If no path provided, prompt user to select
+    if (!projectToUnlink) {
+        const choices = linkedProjects.map(p => {
+            const validation = p.validation;
+            let prefix = '';
+            if (!validation.valid) {
+                prefix = validation.exists ? '⚠ ' : '✗ ';
+            }
+            const displayName = validation.currentAppName || p.appName;
+            const displaySlug = validation.currentSlug || p.slug;
+
+            return {
+                name: `${prefix}${displayName} (${displaySlug})`,
+                value: p.slug,
+                description: p.path
+            };
+        });
+
+        choices.push({
+            name: 'Cancel',
+            value: '__cancel__'
+        });
+
+        projectToUnlink = await select({
+            message: 'Which project do you want to unlink?',
+            choices
+        });
+
+        if (projectToUnlink === '__cancel__') {
+            console.log(chalk.gray('Cancelled.'));
+            return;
+        }
+    }
+
+    // Unlink the project
+    const result = unlinkVueProject(projectToUnlink);
+
+    if (!result.success) {
+        console.log(chalk.red(`Failed to unlink: ${result.error}`));
+        return;
+    }
+
+    console.log(chalk.green(`\u2713 Project '${result.project.appName}' (${result.project.slug}) has been unlinked.`));
+    console.log(chalk.gray(`  Path: ${result.project.path}`));
+    console.log();
+    console.log(chalk.gray('Note: This only removes the link from CLI tracking.'));
+    console.log(chalk.gray('The Vue project and any deployed Iris app are unchanged.'));
+}
+
+/**
+ * Handle cleanup of invalid projects.
+ */
+async function handleCleanup() {
+    const projectsWithStatus = getLinkedProjectsWithStatus();
+    const invalidProjects = projectsWithStatus.filter(p => !p.validation.exists);
+
+    if (invalidProjects.length === 0) {
+        console.log(chalk.green('All linked projects are valid. No cleanup needed.'));
+        return;
+    }
+
+    console.log(chalk.yellow(`Found ${invalidProjects.length} project(s) with invalid paths:\n`));
+
+    for (const project of invalidProjects) {
+        console.log(chalk.red(`  ✗ ${project.appName} (${project.slug})`));
+        console.log(chalk.gray(`    Path: ${project.path}`));
+        console.log(chalk.gray(`    Error: ${project.validation.errors.join(', ')}`));
+        console.log();
+    }
+
+    const shouldCleanup = await confirm({
+        message: `Remove these ${invalidProjects.length} invalid project(s)?`,
+        default: true
+    });
+
+    if (!shouldCleanup) {
+        console.log(chalk.gray('Cleanup cancelled.'));
+        return;
+    }
+
+    const result = cleanupInvalidProjects();
+
+    console.log(chalk.green(`\u2713 Removed ${result.removed} invalid project(s).`));
+}
+
+export default irisLink;

package/actions/iris/recover.js

@@ -0,0 +1,228 @@
+import chalk from 'chalk';
+import { select, confirm } from '@inquirer/prompts';
+import { existsSync } from 'node:fs';
+import path from 'path';
+import { listBackups, restoreIrisApp, deleteBackup } from '../../utils/iris/backup.js';
+import { linkVueProject } from '../../utils/iris/linker.js';
+import { showPermissionError } from '../../utils/permissionError.js';
+import { EXPORT_ROOT, IRIS_APPS_DIR } from '../../vars/global.js';
+
+/**
+ * iris-recover command - Restore a deleted Iris app from backup.
+ *
+ * Options:
+ *   --list      List all available backups
+ */
+export const irisRecover = async (options = {}) => {
+    process.stdout.write('\x1Bc'); // Clear console
+
+    const { list } = options;
+
+    console.log(chalk.blue.bold('\n♻ Recover Iris App'));
+    console.log(chalk.gray('─'.repeat(48)));
+    console.log();
+
+    // Get available backups
+    const backups = listBackups();
+
+    if (backups.length === 0) {
+        console.log(chalk.yellow('No recovery backups found.'));
+        console.log();
+        console.log(chalk.gray('Backups are created automatically when you delete an Iris app.'));
+        console.log(chalk.white(`Use: ${chalk.cyan('magentrix iris-delete')}`));
+        console.log();
+        return;
+    }
+
+    // If --list flag, just show and exit
+    if (list) {
+        console.log(chalk.white('Available Recovery Backups:'));
+        console.log();
+
+        backups.forEach((backup, i) => {
+            const date = new Date(backup.deletedAt);
+            console.log(chalk.white(`${i + 1}. ${chalk.cyan(backup.appName)} (${backup.slug})`));
+            console.log(chalk.gray(`   Deleted: ${date.toLocaleString()}`));
+            if (backup.linkedProject) {
+                console.log(chalk.gray(`   Linked: ${backup.linkedProject.path}`));
+            }
+            console.log(chalk.gray(`   Backup: ${backup.backupPath}`));
+            console.log();
+        });
+
+        console.log(chalk.white(`To recover, run: ${chalk.cyan('magentrix iris-recover')}`));
+        console.log();
+        return;
+    }
+
+    // Build choices for selection
+    const choices = backups.map((backup) => {
+        const date = new Date(backup.deletedAt);
+        const timeAgo = getTimeAgo(date);
+        return {
+            name: `${backup.appName} (${backup.slug}) - Deleted ${timeAgo}`,
+            value: backup
+        };
+    });
+
+    choices.push({
+        name: 'Cancel',
+        value: null
+    });
+
+    // Select backup to restore
+    const selectedBackup = await select({
+        message: 'Which backup do you want to restore?',
+        choices
+    });
+
+    if (!selectedBackup) {
+        console.log(chalk.gray('Cancelled.'));
+        return;
+    }
+
+    const { slug, appName, linkedProject, backupPath } = selectedBackup;
+
+    // Show recovery info
+    console.log();
+    console.log(chalk.white('Recovery Details:'));
+    console.log(chalk.gray('─'.repeat(48)));
+    console.log(chalk.white(`  App: ${chalk.cyan(appName)} (${slug})`));
+    console.log(chalk.white(`  Backup: ${chalk.gray(backupPath)}`));
+
+    if (linkedProject) {
+        const pathExists = existsSync(linkedProject.path);
+        if (pathExists) {
+            console.log(chalk.green(`  ✓ Linked project: ${linkedProject.path}`));
+        } else {
+            console.log(chalk.yellow(`  ⚠ Linked project path no longer exists:`));
+            console.log(chalk.gray(`    ${linkedProject.path}`));
+        }
+    } else {
+        console.log(chalk.gray('  (No linked Vue project)'));
+    }
+
+    console.log();
+
+    // Check for warnings
+    const warnings = [];
+    if (linkedProject && !existsSync(linkedProject.path)) {
+        warnings.push('The linked Vue project path no longer exists. Only local files will be restored.');
+    }
+
+    // Check if app already exists locally
+    const appPath = path.join(EXPORT_ROOT, IRIS_APPS_DIR, slug);
+    if (existsSync(appPath)) {
+        console.log(chalk.yellow(`⚠ Warning: App folder already exists at ${appPath}`));
+        console.log(chalk.yellow('  Recovery will overwrite existing files.'));
+        console.log();
+    }
+
+    if (warnings.length > 0) {
+        console.log(chalk.yellow('⚠ Warnings:'));
+        warnings.forEach(w => console.log(chalk.yellow(`  • ${w}`)));
+        console.log();
+    }
+
+    // Confirm recovery
+    const shouldRecover = await confirm({
+        message: 'Do you want to restore this app?',
+        default: true
+    });
+
+    if (!shouldRecover) {
+        console.log(chalk.gray('Cancelled.'));
+        return;
+    }
+
+    // Restore files
+    console.log();
+    console.log(chalk.blue('Restoring files...'));
+
+    const restoreResult = await restoreIrisApp(backupPath, {
+        restoreLocal: true,
+        restoreLink: true
+    });
+
+    if (!restoreResult.success) {
+        if (restoreResult.isPermissionError) {
+            const targetDir = path.join(process.cwd(), EXPORT_ROOT, IRIS_APPS_DIR);
+            showPermissionError({
+                operation: 'restore',
+                targetPath: targetDir,
+                backupPath,
+                slug
+            });
+        } else {
+            console.log(chalk.red(`Failed to restore: ${restoreResult.error}`));
+        }
+        return;
+    }
+
+    console.log(chalk.green(`✓ Restored files to ${EXPORT_ROOT}/${IRIS_APPS_DIR}/${slug}/`));
+
+    // Re-link Vue project if needed
+    if (linkedProject && restoreResult.linkedProjectPathExists) {
+        console.log(chalk.blue('Re-linking Vue project...'));
+
+        const linkResult = linkVueProject(linkedProject.path);
+        if (linkResult.success) {
+            console.log(chalk.green('✓ Vue project re-linked'));
+        } else {
+            console.log(chalk.yellow(`⚠ Could not re-link Vue project: ${linkResult.error}`));
+        }
+    }
+
+    // Show warnings
+    if (restoreResult.warnings.length > 0) {
+        console.log();
+        console.log(chalk.yellow('Warnings:'));
+        restoreResult.warnings.forEach(w => console.log(chalk.yellow(`  • ${w}`)));
+    }
+
+    // Summary
+    console.log();
+    console.log(chalk.green('─'.repeat(48)));
+    console.log(chalk.green.bold('✓ Recovery Complete!'));
+    console.log();
+    console.log(chalk.cyan('Next steps:'));
+    console.log(chalk.white(`  • Run ${chalk.yellow('magentrix publish')} to sync the app back to the server`));
+    console.log();
+
+    // Ask if they want to delete the backup
+    const deleteBackupConfirm = await confirm({
+        message: 'Delete the recovery backup now?',
+        default: false
+    });
+
+    if (deleteBackupConfirm) {
+        deleteBackup(backupPath);
+        console.log(chalk.green('✓ Recovery backup deleted'));
+    } else {
+        console.log(chalk.gray(`Backup preserved at: ${backupPath}`));
+    }
+
+    console.log();
+};
+
+/**
+ * Get human-readable time ago string.
+ * @param {Date} date - Date to compare
+ * @returns {string} - Time ago string
+ */
+function getTimeAgo(date) {
+    const now = new Date();
+    const diffMs = now - date;
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMins < 1) return 'just now';
+    if (diffMins < 60) return `${diffMins} minute${diffMins > 1 ? 's' : ''} ago`;
+    if (diffHours < 24) return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+    if (diffDays < 7) return `${diffDays} day${diffDays > 1 ? 's' : ''} ago`;
+
+    return date.toLocaleDateString();
+}
+
+export default irisRecover;