i18ntk 2.3.8 → 2.4.0

package/README.md

@@ -1,4 +1,4 @@
-# i18ntk v2.3.8
+# i18ntk v2.4.0
 
 Zero-dependency internationalization toolkit for setup, scanning, analysis, validation, usage tracking, and translation completion.
 
@@ -9,12 +9,12 @@ Zero-dependency internationalization toolkit for setup, scanning, analysis, vali
 [![node](https://img.shields.io/badge/node-%3E%3D16-339933)](https://nodejs.org)
 [![dependencies](https://img.shields.io/badge/dependencies-0-success)](https://www.npmjs.com/package/i18ntk)
 [![license](https://img.shields.io/badge/license-MIT-yellow.svg)](LICENSE)
-[![socket](https://socket.dev/api/badge/npm/package/i18ntk/2.3.8)](https://socket.dev/npm/package/i18ntk/overview/2.3.8)
+[![socket](https://socket.dev/api/badge/npm/package/i18ntk/2.4.0)](https://socket.dev/npm/package/i18ntk/overview/2.4.0)
 
 ## Upgrade Notice
 
-Versions earlier than `2.3.8` may contain known stability and security issues.
-They are considered unsupported for production use. Upgrade to `2.3.8` or newer.
+Versions earlier than `2.4.0` may contain known stability and security issues.
+They are considered unsupported for production use. Upgrade to `2.4.0` or newer.
 
 ## What i18ntk Does
 
@@ -104,6 +104,9 @@ i18ntk-fixer
 i18ntk-backup
 ```
 
+Note: `i18ntk --command=backup` in the manager flow is disabled in current builds.
+Use the standalone `i18ntk-backup` executable when backup operations are required.
+
 ## Common Flags
 
 - `--source-dir <path>`
@@ -151,7 +154,7 @@ Example `.i18ntk-config`:
 
 ```json
 {
-  "version": "2.3.8",
+  "version": "2.4.0",
   "sourceDir": "./locales",
   "i18nDir": "./locales",
   "outputDir": "./i18ntk-reports",
@@ -174,7 +177,7 @@ See [docs/api/CONFIGURATION.md](docs/api/CONFIGURATION.md) for the full configur
 - [Runtime API Guide](docs/runtime.md)
 - [Scanner Guide](docs/scanner-guide.md)
 - [Environment Variables](docs/environment-variables.md)
-- [Migration Guide v2.3.8](docs/migration-guide-v2.3.8.md)
+- [Migration Guide v2.4.0](docs/migration-guide-v2.4.0.md)
 - [Optimization Prompt](docs/development/package-optimization-prompt.md)
 
 ## Code of Conduct

package/main/i18ntk-backup-class.js

@@ -1,430 +1,42 @@
-#!/usr/bin/env node
-
-'use strict';
-
-const fs = require('fs');
-const fsp = fs.promises;
-const path = require('path');
-const configManager = require('../utils/config-manager');
+#!/usr/bin/env node
+
+'use strict';
+
 const { logger } = require('../utils/logger');
-const { colors } = require('../utils/logger');
-const SecurityUtils = require('../utils/security');
-
-/**
- * I18NTK BACKUP CLASS
- *
- * Class-based implementation of backup functionality for use with CommandRouter
- */
+
+/**
+ * I18NTK BACKUP CLASS
+ *
+ * Backup operations are intentionally disabled in the manager command path
+ * to reduce filesystem scanner surface.
+ */
 class I18nBackup {
-    constructor(config = {}) {
-        this.config = config;
-        this.backupDir = path.join(process.cwd(), 'i18ntk-backups');
-        this.maxBackups = Math.min(Math.max(parseInt(config.backup?.maxBackups, 10) || 1, 1), 3);
-    }
+  constructor(config = {}) {
+    this.config = config;
+  }
 
-    validateInProject(targetPath, label = 'path') {
-        const validated = SecurityUtils.validatePath(targetPath, process.cwd());
-        if (!validated) {
-            throw new Error(`Invalid ${label}: ${targetPath}`);
-        }
-        return validated;
-    }
-
-    /**
-     * Main run method for the backup command
-     */
-    async run(options = {}) {
-        const command = options.command || options._ && options._[0];
-
-        // Show help if no command provided
-        if (!command) {
-            this.showHelp();
-            return { success: true, command: 'help' };
-        }
-
-        try {
-            switch (command) {
-                case 'create':
-                    return await this.handleCreate(options);
-                case 'restore':
-                    return await this.handleRestore(options);
-                case 'list':
-                    return await this.handleList();
-                case 'verify':
-                    return await this.handleVerify(options);
-                case 'cleanup':
-                    return await this.handleCleanup(options);
-                default:
-                    logger.error(`Unknown command: ${command}`);
-                    this.showHelp();
-                    return { success: false, error: `Unknown command: ${command}` };
-            }
-        } catch (error) {
-            this.handleError(error);
-            return { success: false, error: error.message };
-        }
-    }
-
-    showHelp() {
-        console.log(`
-i18ntk-backup - Secure backup and restore for i18n translation files
-
-Usage:
-  i18ntk-backup <command> [options]
-
-Commands:
-  create <dir>     Create a backup of translation files
-  restore <file>   Restore from a backup
-  list             List available backups
-  verify <file>    Verify the integrity of a backup file
-  cleanup          Remove old backups
-
-Options:
-  --output <path>   Output directory for backup/restore
-  --force           Overwrite existing files without prompting
-  --keep <number>   Number of backups to keep (default: 10)
-`);
-    }
-
-    // Command handlers
-    async handleCreate(options = {}) {
-        // Use absolute path for the locales directory
-        const requestedDir = (options._ && options._[1]) || options.dir || path.join(process.cwd(), 'locales');
-        const requestedOutputDir = options.output || this.backupDir;
-        const dir = this.validateInProject(path.resolve(process.cwd(), requestedDir), 'source directory');
-        const outputDir = this.validateInProject(path.resolve(process.cwd(), requestedOutputDir), 'backup directory');
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const backupName = `backup-${timestamp}.json`;
-        const backupPath = this.validateInProject(path.join(outputDir, backupName), 'backup file');
-
-        // Log the paths for debugging
-        logger.debug(`Source directory: ${dir}`);
-        logger.debug(`Backup will be saved to: ${backupPath}`);
-
-        // Create backup directory if it doesn't exist
-        try {
-            await fsp.mkdir(outputDir, { recursive: true });
-            logger.debug(`Created backup directory: ${outputDir}`);
-        } catch (err) {
-            if (err.code !== 'EEXIST') {
-                logger.error(`Failed to create backup directory: ${err.message}`);
-                throw err;
-            }
-            logger.debug(`Using existing backup directory: ${outputDir}`);
-        }
-
-        // Validate directory
-        const sourceDir = dir;
-        try {
-            const stats = await fsp.stat(sourceDir);
-            if (!stats.isDirectory()) {
-                throw new Error(`Path exists but is not a directory: ${sourceDir}`);
-            }
-            logger.debug(`Source directory exists: ${sourceDir}`);
-        } catch (err) {
-            if (err.code === 'ENOENT') {
-                throw new Error(`Directory not found: ${sourceDir}. Please specify a valid directory.`);
-            }
-            throw new Error(`Error accessing directory ${sourceDir}: ${err.message}`);
-        }
-
-        logger.info('\nCreating backup...');
-
-        // Read all files in the directory
-        const files = (await fsp.readdir(sourceDir, { withFileTypes: true }))
-            .filter(dirent => dirent.isFile() && dirent.name.endsWith('.json'))
-            .map(dirent => dirent.name);
-
-        if (files.length === 0) {
-            logger.warn('No JSON files found in the specified directory');
-            return { success: true, message: 'No files to backup' };
-        }
-
-        // Read all translation files
-        const translations = {};
-        for (const file of files) {
-            const filePath = path.join(sourceDir, file);
-            try {
-                const content = JSON.parse(await fsp.readFile(filePath, 'utf8'));
-                translations[file] = content;
-            } catch (error) {
-                logger.error(`Could not read file ${file}: ${error.message}`);
-            }
-        }
-
-        // Create the backup
-        await fsp.writeFile(backupPath, JSON.stringify(translations, null, 2));
-        const stats = await fsp.stat(backupPath);
-
-        logger.success('Backup created successfully');
-        logger.info(`  Location: ${backupPath}`);
-        logger.info(`  Size: ${(stats.size / 1024).toFixed(2)} KB`);
-        logger.info(`  Timestamp: ${new Date().toLocaleString()}`);
-
-        // Clean up old backups
-        await this.cleanupOldBackups(outputDir);
-
-        return {
-            success: true,
-            command: 'create',
-            backupPath,
-            size: stats.size,
-            fileCount: files.length
-        };
-    }
-
-    async handleRestore(options = {}) {
-        const backupFile = options._ && options._[1];
-        if (!backupFile) {
-            throw new Error('Backup file path is required');
-        }
+  showHelp() {
+    logger.warn('Backup command is disabled in this build.');
+    logger.info('Use project-level source control or external backup tooling instead.');
+  }
 
-        const backupPath = this.validateInProject(path.resolve(process.cwd(), backupFile), 'backup file');
-        const outputDir = this.validateInProject(
-            options.output ? path.resolve(process.cwd(), options.output) : path.join(process.cwd(), 'restored'),
-            'restore output directory'
-        );
-
-        // Validate backup file
-        if (!SecurityUtils.safeExistsSync(backupPath, process.cwd())) {
-            throw new Error(`Backup file not found: ${backupPath}`);
-        }
-
-        logger.info('\nRestoring backup...');
-
-        try {
-            // Read the backup file
-            const backupData = await fsp.readFile(backupPath, 'utf8');
-            const translations = JSON.parse(backupData);
-
-            // Create output directory if it doesn't exist
-            try {
-                await fsp.mkdir(outputDir, { recursive: true });
-            } catch (err) {
-                if (err.code !== 'EEXIST') throw err;
-            }
-
-            // Write the restored files
-            for (const [file, content] of Object.entries(translations)) {
-                const filePath = this.validateInProject(path.join(outputDir, file), 'restore file');
-                await fsp.writeFile(filePath, JSON.stringify(content, null, 2), 'utf8');
-            }
-
-            logger.success('Backup restored successfully');
-            logger.info(`  Restored ${Object.keys(translations).length} files to: ${outputDir}`);
-
-            return {
-                success: true,
-                command: 'restore',
-                outputDir,
-                fileCount: Object.keys(translations).length
-            };
-        } catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-
-    async handleList() {
-        const backupDir = this.validateInProject(this.backupDir, 'backup directory');
-        try {
-            // Ensure backup directory exists
-            try {
-                await fsp.access(backupDir);
-            } catch (err) {
-                if (err.code === 'ENOENT') {
-                    logger.warn('No backups found. The backup directory does not exist yet.');
-                } else {
-                    logger.error(`Error accessing backup directory: ${err.message}`);
-                }
-                return { success: true, backups: [] };
-            }
-
-            const files = await fsp.readdir(backupDir);
-            const backups = [];
-
-            for (const file of files) {
-                if (file.startsWith('backup-') && file.endsWith('.json')) {
-                    try {
-                        const filePath = this.validateInProject(path.join(backupDir, file), 'backup file');
-                        const stats = await fsp.stat(filePath);
-                        backups.push({
-                            name: file,
-                            path: filePath,
-                            size: stats.size,
-                            createdAt: stats.mtime
-                        });
-                    } catch (err) {
-                        logger.warn(`Skipping invalid backup file ${file}: ${err.message}`);
-                    }
-                }
-            }
-
-            if (backups.length === 0) {
-                logger.warn('No valid backup files found in the backup directory.');
-                return { success: true, backups: [] };
-            }
-
-            // Sort by creation time (newest first)
-            backups.sort((a, b) => b.createdAt - a.createdAt);
-
-            logger.info('\n📋 Available Backups');
-            logger.info('='.repeat(50));
-
-            backups.forEach((backup, index) => {
-                const sizeKB = (backup.size / 1024).toFixed(2);
-                const formattedDate = backup.createdAt.toLocaleString();
-
-                logger.info(`🔹 ${index + 1}. ${backup.name}`);
-                logger.info(`   📏 Size: ${sizeKB} KB`);
-                logger.info(`   📅 Created: ${formattedDate}`);
-                logger.info(`   📂 Path: ${backup.path}\n`);
-            });
-
-            logger.info(`Total backups: ${backups.length}`);
-
-            return { success: true, backups, count: backups.length };
-        } catch (err) {
-            if (err.code === 'ENOENT') {
-                logger.warn('No backups found.');
-                return { success: true, backups: [] };
-            } else {
-                throw err;
-            }
-        }
-    }
-
-    async handleVerify(options = {}) {
-        const backupFile = options._ && options._[1];
-        if (!backupFile) {
-            throw new Error('Backup file path is required');
-        }
-
-        const backupPath = this.validateInProject(path.resolve(process.cwd(), backupFile), 'backup file');
-
-        // Validate backup file
-        if (!SecurityUtils.safeExistsSync(backupPath, process.cwd())) {
-            throw new Error(`Backup file not found: ${backupPath}`);
-        }
-
-        logger.info('\nVerifying backup...');
-
-        try {
-            const data = await fsp.readFile(backupPath, 'utf8');
-            const content = JSON.parse(data);
-
-            if (typeof content === 'object' && content !== null) {
-                const fileCount = Object.keys(content).length;
-                logger.success('Backup is valid');
-                logger.info(`  Contains ${fileCount} translation files`);
-                logger.info(`  Last modified: ${(await fsp.stat(backupPath)).mtime.toLocaleString()}`);
-
-                return {
-                    success: true,
-                    command: 'verify',
-                    valid: true,
-                    fileCount
-                };
-            } else {
-                throw new Error('Invalid backup format');
-            }
-        } catch (error) {
-            logger.error('Backup verification failed!');
-            logger.error(`  Error: ${error.message}`);
-            return {
-                success: false,
-                command: 'verify',
-                valid: false,
-                error: error.message
-            };
-        }
-    }
-
-    async handleCleanup(options = {}) {
-        const keep = options.keep ? parseInt(options.keep, 10) : this.maxBackups;
-        const backupDir = this.validateInProject(this.backupDir, 'backup directory');
-
-        logger.info('\nCleaning up old backups...');
-
-        try {
-            const files = await fsp.readdir(backupDir);
-            const backupFiles = files
-                .filter(file => file.startsWith('backup-') && file.endsWith('.json'))
-                .map(file => ({
-                    name: file,
-                    path: this.validateInProject(path.join(backupDir, file), 'backup file'),
-                    time: (SecurityUtils.safeStatSync(path.join(backupDir, file), process.cwd()) || { mtime: new Date(0) }).mtime.getTime()
-                }))
-                .sort((a, b) => b.time - a.time);
-
-            // Keep only the most recent 'keep' files
-            const toDelete = backupFiles.slice(keep);
-
-            if (toDelete.length === 0) {
-                logger.info('No old backups to delete.');
-                return { success: true, deleted: 0 };
-            }
-
-            // Delete old backups
-            for (const file of toDelete) {
-                try {
-                    await fsp.unlink(file.path);
-                    logger.info(`  - Deleted: ${file.name}`);
-                } catch (err) {
-                    logger.error(`  - Failed to delete ${file.name}: ${err.message}`);
-                }
-            }
-
-            logger.info(`\nRemoved ${toDelete.length} old backups`);
-            logger.info(`Total backups kept: ${keep}`);
-
-            return {
-                success: true,
-                command: 'cleanup',
-                deleted: toDelete.length,
-                kept: keep
-            };
-        } catch (error) {
-            logger.error('Error cleaning up backups:');
-            logger.error(`  ${error.message}`);
-            logger.debug(error.stack || error.message);
-            throw error;
-        }
-    }
-
-    async cleanupOldBackups(outputDir) {
-        try {
-            const safeOutputDir = this.validateInProject(outputDir, 'backup output directory');
-            const files = await fsp.readdir(safeOutputDir);
-            const backupFiles = files
-                .filter(file => file.startsWith('backup-') && file.endsWith('.json'))
-                .map(file => ({
-                    name: file,
-                    path: this.validateInProject(path.join(safeOutputDir, file), 'backup file'),
-                    time: (SecurityUtils.safeStatSync(path.join(safeOutputDir, file), process.cwd()) || { mtime: new Date(0) }).mtime.getTime()
-                }))
-                .sort((a, b) => b.time - a.time);
-
-            // Keep only the most recent files
-            const toDelete = backupFiles.slice(this.maxBackups);
-
-            for (const file of toDelete) {
-                try {
-                    await fsp.unlink(file.path);
-                } catch (err) {
-                    // Ignore cleanup errors
-                }
-            }
-        } catch (error) {
-            // Ignore cleanup errors
-        }
-    }
-
-    handleError(error) {
-        logger.error('Backup operation failed:');
-        logger.error(`  ${error.message}`);
-        logger.debug(error.stack || error.message);
+  async run(options = {}) {
+    const command = options.command || (options._ && options._[0]);
+    if (!command || command === 'help') {
+      this.showHelp();
+      return { success: false, command: 'backup', disabled: true };
     }
+
+    logger.warn(`Backup command '${command}' is disabled in this build.`);
+    logger.info('Use project-level source control or external backup tooling instead.');
+
+    return {
+      success: false,
+      command,
+      disabled: true,
+      error: 'Backup command is disabled'
+    };
+  }
 }
-
+
 module.exports = I18nBackup;

package/main/manage/commands/BackupCommand.js

@@ -1,62 +1,62 @@
-#!/usr/bin/env node
-
-/**
- * I18NTK BACKUP COMMAND
- *
- * Handles backup operations for translation files and settings.
- */
-
-const I18nBackup = require('../../i18ntk-backup-class');
-
-class BackupCommand {
-    constructor(config = {}, ui = null) {
-        this.config = config;
-        this.ui = ui;
-        this.prompt = null;
-        this.isNonInteractiveMode = false;
-        this.safeClose = null;
-    }
-
-    /**
-     * Set runtime dependencies for interactive operations
-     */
-    setRuntimeDependencies(prompt, isNonInteractiveMode, safeClose) {
-        this.prompt = prompt;
-        this.isNonInteractiveMode = isNonInteractiveMode;
-        this.safeClose = safeClose;
-    }
-
-    /**
-     * Execute the backup command
-     */
-    async execute(options = {}) {
-        try {
-            const backup = new I18nBackup();
-            await backup.run(options);
-            return { success: true, command: 'backup' };
-        } catch (error) {
-            console.error(`Backup command failed: ${error.message}`);
-            throw error;
-        }
-    }
-
-    /**
-     * Get command metadata
-     */
-    getMetadata() {
-        return {
-            name: 'backup',
-            description: 'Create backups of translation files and settings',
-            category: 'maintenance',
-            aliases: [],
-            usage: 'backup [options]',
-            examples: [
-                'backup',
-                'backup --output-dir=./backups',
-                'backup --include-settings'
-            ]
-        };
-    }
-}
-
-module.exports = BackupCommand;
+#!/usr/bin/env node
+
+/**
+ * I18NTK BACKUP COMMAND
+ *
+ * Handles backup operations for translation files and settings.
+ */
+
+const I18nBackup = require('../../i18ntk-backup-class');
+
+class BackupCommand {
+    constructor(config = {}, ui = null) {
+        this.config = config;
+        this.ui = ui;
+        this.prompt = null;
+        this.isNonInteractiveMode = false;
+        this.safeClose = null;
+    }
+
+    /**
+     * Set runtime dependencies for interactive operations
+     */
+    setRuntimeDependencies(prompt, isNonInteractiveMode, safeClose) {
+        this.prompt = prompt;
+        this.isNonInteractiveMode = isNonInteractiveMode;
+        this.safeClose = safeClose;
+    }
+
+    /**
+     * Execute the backup command
+     */
+    async execute(options = {}) {
+        try {
+            const backup = new I18nBackup();
+            const result = await backup.run(options);
+            return result || { success: false, command: 'backup', error: 'Backup command failed' };
+        } catch (error) {
+            console.error(`Backup command failed: ${error.message}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Get command metadata
+     */
+    getMetadata() {
+        return {
+            name: 'backup',
+            description: 'Create backups of translation files and settings',
+            category: 'maintenance',
+            aliases: [],
+            usage: 'backup [options]',
+            examples: [
+                'backup',
+                'backup --output-dir=./backups',
+                'backup --include-settings'
+            ]
+        };
+    }
+}
+
+module.exports = BackupCommand;