i18ntk 1.10.2 → 2.0.3

package/main/manage/managers/DebugMenu.js

@@ -0,0 +1,140 @@
+/**
+ * Debug Menu Manager
+ * @module managers/DebugMenu
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { t } = require('../../../utils/i18n-helper');
+
+module.exports = class DebugMenu {
+  constructor(manager) {
+    this.manager = manager; // Reference to I18nManager for access to methods and properties
+    this.adminAuth = manager.adminAuth;
+  }
+
+  /**
+   * Display the debug tools menu
+   */
+  async showDebugMenu() {
+    // Check for PIN protection
+    const authRequired = await this.adminAuth.isAuthRequiredForScript('debugMenu');
+    if (authRequired) {
+      console.log(`\n${t('adminPin.protectedAccess')}`);
+      const cliHelper = require('../../../utils/cli-helper');
+      const pin = await cliHelper.promptPin(t('adminPin.enterPin') + ': ');
+      const isValid = await this.adminAuth.verifyPin(pin);
+
+      if (!isValid) {
+        console.log(t('adminPin.invalidPin'));
+        await this.manager.prompt(t('menu.pressEnterToContinue'));
+        await this.manager.showInteractiveMenu();
+        return;
+      }
+
+      console.log(t('adminPin.accessGranted'));
+    }
+
+    console.log(`\n${t('debug.title')}`);
+    console.log(t('debug.separator'));
+    console.log(t('debug.mainDebuggerSystemDiagnostics'));
+    console.log(t('debug.debugLogs'));
+    console.log(t('debug.backToMainMenu'));
+
+    const choice = await this.manager.prompt('\n' + t('debug.selectOption'));
+
+    switch (choice.trim()) {
+      case '1':
+        await this.runDebugTool('debugger.js', 'Main Debugger');
+        break;
+      case '2':
+        await this.viewDebugLogs();
+        break;
+      case '0':
+        await this.manager.showInteractiveMenu();
+        return;
+      default:
+        console.log(t('debug.invalidChoiceSelectRange'));
+        await this.showDebugMenu();
+    }
+  }
+
+  /**
+   * Run a specific debug tool
+   */
+  async runDebugTool(toolName, displayName) {
+    console.log(t('debug.runningDebugTool', { displayName }));
+    try {
+      const toolPath = path.join(__dirname, '..', '..', 'scripts', 'debug', toolName);
+      if (fs.existsSync(toolPath)) {
+        console.log(`Debug tool available: ${toolName}`);
+        console.log(`To run this tool manually: node "${toolPath}"`);
+        console.log(`Working directory: ${path.join(__dirname, '..', '..')}`);
+      } else {
+        console.log(t('debug.debugToolNotFound', { toolName }));
+      }
+    } catch (error) {
+      console.error(t('debug.errorRunningDebugTool', { displayName, error: error.message }));
+    }
+
+    await this.manager.prompt('\n' + t('menu.pressEnterToContinue'));
+    await this.showDebugMenu();
+  }
+
+  /**
+   * View debug logs
+   */
+  async viewDebugLogs() {
+    console.log(`\n${t('debug.recentDebugLogs')}`);
+    console.log('============================================================');
+
+    try {
+      const logsDir = path.join(__dirname, '..', '..', 'scripts', 'debug', 'logs');
+      if (fs.existsSync(logsDir)) {
+        const files = fs.readdirSync(logsDir)
+          .filter(file => file.endsWith('.log') || file.endsWith('.txt'))
+          .sort((a, b) => {
+            const statA = fs.statSync(path.join(logsDir, a));
+            const statB = fs.statSync(path.join(logsDir, b));
+            return statB.mtime - statA.mtime;
+          })
+          .slice(0, 5);
+
+        if (files.length > 0) {
+          files.forEach((file, index) => {
+            const filePath = path.join(logsDir, file);
+            const stats = fs.statSync(filePath);
+            console.log(`${index + 1}. ${file} (${stats.mtime.toLocaleString()})`);
+          });
+
+          const choice = await this.manager.prompt('\n' + t('debug.selectLogPrompt', { count: files.length }));
+          const fileIndex = parseInt(choice) - 1;
+
+          if (fileIndex >= 0 && fileIndex < files.length) {
+            const logContent = fs.readFileSync(path.join(logsDir, files[fileIndex]), 'utf8');
+            console.log(`\n${t('debug.contentOf', { filename: files[fileIndex] })}:`);
+            console.log('============================================================');
+            console.log(logContent.slice(-2000)); // Show last 2000 characters
+            console.log('============================================================');
+          }
+        } else {
+          console.log(t('debug.noDebugLogsFound'));
+        }
+      } else {
+        console.log(t('debug.debugLogsDirectoryNotFound'));
+      }
+    } catch (error) {
+      console.error(t('errors.errorReadingDebugLogs', { error: error.message }));
+    }
+
+    await this.manager.prompt('\n' + t('menu.pressEnterToContinue'));
+    await this.manager.showInteractiveMenu();
+  }
+
+  /**
+   * Alias for showDebugMenu for backward compatibility
+   */
+  async show() {
+    return this.showDebugMenu();
+  }
+};

package/main/manage/managers/InteractiveMenu.js

@@ -0,0 +1,177 @@
+/**
+ * Interactive Menu Manager
+ * @module managers/InteractiveMenu
+ */
+
+const { t } = require('../../../utils/i18n-helper');
+
+module.exports = class InteractiveMenu {
+  constructor(manager) {
+    this.manager = manager; // Reference to I18nManager for access to methods and properties
+    this.adminAuth = manager.adminAuth;
+    this.ui = manager.ui;
+  }
+
+  /**
+   * Display the main interactive menu with 13 options
+   */
+  async showInteractiveMenu() {
+    // Check if we're in non-interactive mode (like echo 0 | node script)
+    if (this.manager.isNonInteractiveMode()) {
+      console.log(`\n${t('menu.title')}`);
+      console.log(t('menu.separator'));
+      console.log(`1. ${t('menu.options.init')}`);
+      console.log(`2. ${t('menu.options.analyze')}`);
+      console.log(`3. ${t('menu.options.validate')}`);
+      console.log(`4. ${t('menu.options.usage')}`);
+      console.log(`5. ${t('menu.options.complete')}`);
+      console.log(`6. ${t('menu.options.sizing')}`);
+      console.log(`7. ${t('menu.options.fix')}`);
+      console.log(`8. ${t('menu.options.status')}`);
+      console.log(`9. ${t('menu.options.delete')}`);
+      console.log(`10. ${t('menu.options.settings')}`);
+      console.log(`11. ${t('menu.options.help')}`);
+      console.log(`12. ${t('menu.options.language')}`);
+      console.log(`13. ${t('menu.options.scanner')}`);
+      console.log(`0. ${t('menu.options.exit')}`);
+
+      console.log('\n' + t('menu.nonInteractiveModeWarning'));
+      console.log(t('menu.useDirectExecution'));
+      console.log(t('menu.useHelpForCommands'));
+      this.manager.safeClose();
+      process.exit(0);
+      return;
+    }
+
+    console.log(`\n${t('menu.title')}`);
+    console.log(t('menu.separator'));
+    console.log(`1. ${t('menu.options.init')}`);
+    console.log(`2. ${t('menu.options.analyze')}`);
+    console.log(`3. ${t('menu.options.validate')}`);
+    console.log(`4. ${t('menu.options.usage')}`);
+    console.log(`5. ${t('menu.options.complete')}`);
+    console.log(`6. ${t('menu.options.sizing')}`);
+    console.log(`7. ${t('menu.options.fix')}`);
+    console.log(`8. ${t('menu.options.status')}`);
+    console.log(`9. ${t('menu.options.delete')}`);
+    console.log(`10. ${t('menu.options.settings')}`);
+    console.log(`11. ${t('menu.options.help')}`);
+    console.log(`12. ${t('menu.options.language')}`);
+    console.log(`13. ${t('menu.options.scanner')}`);
+    console.log(`0. ${t('menu.options.exit')}`);
+
+    const choice = await this.manager.prompt('\n' + t('menu.selectOptionPrompt'));
+
+    switch (choice.trim()) {
+      case '1':
+        await this.manager.executeCommand('init', {fromMenu: true});
+        break;
+      case '2':
+        await this.manager.executeCommand('analyze', {fromMenu: true});
+        break;
+      case '3':
+        await this.manager.executeCommand('validate', {fromMenu: true});
+        break;
+      case '4':
+        await this.manager.executeCommand('usage', {fromMenu: true});
+        break;
+      case '5':
+        await this.manager.executeCommand('complete', {fromMenu: true});
+        break;
+      case '6':
+        await this.manager.executeCommand('sizing', {fromMenu: true});
+        break;
+      case '7':
+        await this.manager.executeCommand('fix', {fromMenu: true});
+        break;
+      case '8':
+        // Check for PIN protection
+        const authRequired = await this.adminAuth.isAuthRequiredForScript('summaryReports');
+        if (authRequired) {
+          console.log(`\n${t('adminCli.protectedAccess')}`);
+          const cliHelper = require('../../../utils/cli-helper');
+          const pin = await cliHelper.promptPin(t('adminCli.enterPin') + ': ');
+          const isValid = await this.adminAuth.verifyPin(pin);
+
+          if (!isValid) {
+            console.log(t('adminCli.invalidPin'));
+            await this.manager.prompt(t('menu.pressEnterToContinue'));
+            await this.showInteractiveMenu();
+            return;
+          }
+
+          console.log(t('adminCli.accessGranted'));
+        }
+
+        console.log(t('summary.status.generating'));
+        try {
+          const summaryTool = require('../../i18ntk-summary');
+          const summary = new summaryTool();
+          await summary.run({ fromMenu: true });
+          console.log(t('summary.status.completed'));
+
+          // Check if we're in interactive mode before prompting
+          if (!this.manager.isNonInteractiveMode()) {
+            try {
+              await this.manager.prompt('\n' + t('debug.pressEnterToContinue'));
+              await this.showInteractiveMenu();
+            } catch (error) {
+              console.log(t('menu.returning'));
+              process.exit(0);
+            }
+          } else {
+            console.log(t('status.exitingCompleted'));
+            process.exit(0);
+          }
+        } catch (error) {
+          console.error(t('common.errorGeneratingStatusSummary', { error: error.message }));
+
+          // Check if we're in interactive mode before prompting
+          if (!this.manager.isNonInteractiveMode()) {
+            try {
+              await this.manager.prompt('\n' + t('debug.pressEnterToContinue'));
+              await this.showInteractiveMenu();
+            } catch (error) {
+              console.log(t('menu.returning'));
+              process.exit(0);
+            }
+          } else {
+            console.log(t('common.errorExiting'));
+            process.exit(1);
+          }
+        }
+        break;
+      case '9':
+        await this.manager.deleteReports();
+        break;
+      case '10':
+        await this.manager.showSettingsMenu();
+        break;
+      case '11':
+        this.manager.showHelp();
+        await this.manager.prompt(t('menu.returnToMainMenu'));
+        await this.showInteractiveMenu();
+        break;
+      case '12':
+        await this.manager.showLanguageMenu();
+        break;
+      case '13':
+        await this.manager.executeCommand('scanner', {fromMenu: true});
+        break;
+      case '0':
+        console.log(t('menu.goodbye'));
+        this.manager.safeClose();
+        process.exit(0);
+      default:
+        console.log(t('menu.invalidChoice'));
+        await this.showInteractiveMenu();
+    }
+  }
+
+  /**
+   * Alias for showInteractiveMenu for backward compatibility
+   */
+  async show() {
+    return this.showInteractiveMenu();
+  }
+};

package/main/manage/managers/LanguageMenu.js

@@ -0,0 +1,62 @@
+/**
+ * Language Menu Manager
+ * @module managers/LanguageMenu
+ */
+
+const { t } = require('../../../utils/i18n-helper');
+
+module.exports = class LanguageMenu {
+  constructor(manager) {
+    this.manager = manager; // Reference to I18nManager for access to methods and properties
+    this.ui = manager.ui;
+  }
+
+  /**
+   * Display the language selection menu
+   */
+  async showLanguageMenu() {
+    console.log(`\n${t('language.title')}`);
+    console.log(t('language.separator'));
+    console.log(t('language.current', { language: this.ui.getLanguageDisplayName(this.ui.getCurrentLanguage()) }));
+    console.log('\n' + t('language.available'));
+
+    this.ui.availableLanguages.forEach((lang, index) => {
+      const displayName = this.ui.getLanguageDisplayName(lang);
+      const current = lang === this.ui.getCurrentLanguage() ? ' ✓' : '';
+      console.log(t('language.languageOption', { index: index + 1, displayName, current }));
+    });
+
+    console.log(`0. ${t('language.backToMainMenu')}`);
+
+    const choice = await this.manager.prompt('\n' + t('language.prompt'));
+    const choiceNum = parseInt(choice);
+
+    if (choiceNum === 0) {
+      await this.manager.showInteractiveMenu();
+      return;
+    } else if (choiceNum >= 1 && choiceNum <= this.ui.availableLanguages.length) {
+      const selectedLang = this.ui.availableLanguages[choiceNum - 1];
+      await this.ui.changeLanguage(selectedLang);
+      console.log(t('language.changed', { language: this.ui.getLanguageDisplayName(selectedLang) }));
+
+      // Force reload translations for the entire system
+      const { loadTranslations } = require('../../../utils/i18n-helper');
+      loadTranslations(selectedLang);
+
+      // Return to main menu with new language
+      await this.manager.prompt('\n' + t('language.pressEnterToContinue'));
+      await this.manager.showInteractiveMenu();
+    } else {
+      console.log(t('language.invalid'));
+      await this.manager.prompt('\n' + t('language.pressEnterToContinue'));
+      await this.showLanguageMenu();
+    }
+  }
+
+  /**
+   * Alias for showLanguageMenu for backward compatibility
+   */
+  async show() {
+    return this.showLanguageMenu();
+  }
+};

package/main/manage/managers/SettingsMenu.js

@@ -0,0 +1,53 @@
+/**
+ * Settings Menu Manager
+ * @module managers/SettingsMenu
+ */
+
+const { t } = require('../../../utils/i18n-helper');
+
+module.exports = class SettingsMenu {
+  constructor(manager) {
+    this.manager = manager; // Reference to I18nManager for access to methods and properties
+    this.adminAuth = manager.adminAuth;
+  }
+
+  /**
+   * Display the settings management menu
+   */
+  async showSettingsMenu() {
+    try {
+      // Check for PIN protection
+      const authRequired = await this.adminAuth.isAuthRequiredForScript('settingsMenu');
+      if (authRequired) {
+        console.log(`\n${t('adminPin.protectedAccess')}`);
+        const cliHelper = require('../../../utils/cli-helper');
+        const pin = await cliHelper.promptPin(t('adminPin.enterPin') + ': ');
+        const isValid = await this.adminAuth.verifyPin(pin);
+
+        if (!isValid) {
+          console.log(t('adminPin.invalidPin'));
+          await this.manager.prompt(t('menu.pressEnterToContinue'));
+          await this.manager.showInteractiveMenu();
+          return;
+        }
+
+        console.log(t('adminPin.accessGranted'));
+      }
+
+      const SettingsCLI = require('../../../settings/settings-cli');
+      const settingsCLI = new SettingsCLI();
+      await settingsCLI.run();
+    } catch (error) {
+      console.error('❌ Error opening settings:', error.message);
+      await this.manager.prompt(t('menu.pressEnterToContinue'));
+    }
+    await this.manager.showInteractiveMenu();
+  }
+
+  /**
+   * Alias for showSettingsMenu for backward compatibility
+   */
+  async show() {
+    return this.showSettingsMenu();
+  }
+};

package/main/manage/services/AuthenticationService.js

@@ -0,0 +1,263 @@
+/**
+ * Authentication Service
+ * Handles PIN protection, admin authentication, and security checks
+ * @module services/AuthenticationService
+ */
+
+const AdminAuth = require('../../../utils/admin-auth');
+
+module.exports = class AuthenticationService {
+  constructor(config = {}) {
+    this.config = config;
+    this.settings = null;
+    this.configManager = null;
+    this.adminAuth = new AdminAuth();
+  }
+
+  /**
+   * Initialize the service with required dependencies
+   * @param {Object} configManager - Configuration manager instance
+   */
+  initialize(configManager) {
+    this.configManager = configManager;
+    this.settings = configManager.loadSettings ? configManager.loadSettings() : (configManager.getConfig ? configManager.getConfig() : {});
+  }
+
+  /**
+   * Check if authentication is required for the system
+   * @returns {Promise<boolean>} True if authentication is required
+   */
+  async isAuthRequired() {
+    return await this.adminAuth.isAuthRequired();
+  }
+
+  /**
+   * Check if authentication is required for a specific script
+   * @param {string} scriptName - Name of the script to check
+   * @returns {Promise<boolean>} True if authentication is required
+   */
+  async isAuthRequiredForScript(scriptName) {
+    return await this.adminAuth.isAuthRequiredForScript(scriptName);
+  }
+
+  /**
+   * Verify PIN for authentication
+   * @param {string} pin - PIN to verify
+   * @returns {Promise<boolean>} True if PIN is valid
+   */
+  async verifyPin(pin) {
+    return await this.adminAuth.verifyPin(pin);
+  }
+
+  /**
+   * Check admin authentication for protected operations
+   * @param {Object} ui - UI instance for translations (optional)
+   * @returns {Promise<boolean>} True if authentication passed
+   */
+  async checkAdminAuth(ui = null) {
+    const isRequired = await this.isAuthRequired();
+    if (!isRequired) {
+      return true;
+    }
+
+    // Check if admin PIN was provided via command line
+    const args = this.parseArgs();
+    if (args.adminPin) {
+      const isValid = await this.verifyPin(args.adminPin);
+      if (isValid) {
+        console.log(ui ? ui.t('adminCli.authSuccess') : 'Authentication successful');
+        return true;
+      } else {
+        console.log(ui ? ui.t('adminCli.invalidPin') : 'Invalid PIN');
+        return false;
+      }
+    }
+
+    console.log(ui ? ui.t('adminCli.authRequired') : 'Admin authentication required');
+    const cliHelper = require('../../../utils/cli-helper');
+    const pin = await cliHelper.promptPin(ui ? ui.t('adminCli.enterPin') : 'Enter PIN: ');
+    const isValid = await this.verifyPin(pin);
+
+    if (!isValid) {
+      console.log(ui ? ui.t('adminCli.invalidPin') : 'Invalid PIN');
+      return false;
+    }
+
+    console.log(ui ? ui.t('adminCli.authSuccess') : 'Authentication successful');
+    return true;
+  }
+
+  /**
+   * Parse command line arguments for authentication-related flags
+   * @returns {Object} Parsed arguments
+   */
+  parseArgs() {
+    const args = process.argv.slice(2);
+    const parsed = {};
+
+    args.forEach(arg => {
+      if (arg.startsWith('--')) {
+        const [key, value] = arg.substring(2).split('=');
+        const sanitizedKey = key?.trim();
+        const sanitizedValue = value !== undefined ? value.trim() : true;
+
+        switch (sanitizedKey) {
+          case 'admin-pin':
+            parsed.adminPin = sanitizedValue || '';
+            break;
+          case 'no-prompt':
+            parsed.noPrompt = true;
+            break;
+          default:
+            break;
+        }
+      }
+    });
+
+    return parsed;
+  }
+
+  /**
+   * Check if we're in non-interactive mode
+   * @returns {boolean} True if in non-interactive mode
+   */
+  isNonInteractiveMode() {
+    return !process.stdin.isTTY || process.stdin.destroyed;
+  }
+
+  /**
+   * Prompt user for input with fallback for non-interactive mode
+   * @param {string} question - Question to ask
+   * @returns {Promise<string>} User input or empty string
+   */
+  async prompt(question) {
+    const cliHelper = require('../../../utils/cli-helper');
+    // If interactive not available, return empty string to avoid hangs
+    if (!process.stdin.isTTY || process.stdin.destroyed) {
+      console.log('\n⚠️ Interactive input not available, using default response.');
+      return Promise.resolve('');
+    }
+    return cliHelper.prompt(`${question} `);
+  }
+
+  /**
+   * Safe method to close readline interface
+   */
+  safeClose() {
+    // This would be implemented if we had a readline interface to close
+    // For now, it's a placeholder for compatibility
+  }
+
+  /**
+   * Get execution context based on options and environment
+   * @param {Object} options - Execution options
+   * @returns {Object} Execution context information
+   */
+  getExecutionContext(options = {}) {
+    // Check if called from interactive menu
+    if (options.fromMenu === true) {
+      return { type: 'manager', source: 'interactive_menu' };
+    }
+
+    // Check if called from workflow/autorun
+    if (options.fromWorkflow === true) {
+      return { type: 'workflow', source: 'autorun_script' };
+    }
+
+    // Check if this is a direct command line execution
+    if (process.argv.some(arg => arg.startsWith('--command='))) {
+      return { type: 'direct', source: 'command_line' };
+    }
+
+    // Default to direct execution
+    return { type: 'direct', source: 'unknown' };
+  }
+
+  /**
+   * Execute command with authentication checks
+   * @param {string} command - Command to execute
+   * @param {Object} options - Execution options
+   * @param {Object} ui - UI instance for translations (optional)
+   * @returns {Promise<boolean>} True if command should proceed
+   */
+  async executeCommandWithAuth(command, options = {}, ui = null) {
+    console.log(ui ? ui.t('menu.executingCommand', { command }) : `Executing command: ${command}`);
+
+    // Enhanced context detection
+    const executionContext = this.getExecutionContext(options);
+    const isDirectCommand = executionContext.type === 'direct';
+    const isWorkflowExecution = executionContext.type === 'workflow';
+    const isManagerExecution = executionContext.type === 'manager';
+
+    // Check admin authentication for all commands when PIN protection is enabled
+    const authRequiredCommands = ['init', 'analyze', 'validate', 'usage', 'scanner', 'complete', 'fix', 'sizing', 'workflow', 'status', 'delete', 'settings', 'debug'];
+    if (authRequiredCommands.includes(command)) {
+      const authPassed = await this.checkAdminAuth(ui);
+      if (!authPassed) {
+        if (!this.isNonInteractiveMode() && !isDirectCommand) {
+          await this.prompt(ui ? ui.t('menu.pressEnterToContinue') : 'Press Enter to continue...');
+        }
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Handle command completion based on execution context
+   * @param {Object} executionContext - Execution context information
+   * @param {Object} ui - UI instance for translations (optional)
+   * @returns {Promise<void>}
+   */
+  async handleCommandCompletion(executionContext, ui = null) {
+    const isDirectCommand = executionContext.type === 'direct';
+    const isWorkflowExecution = executionContext.type === 'workflow';
+    const isManagerExecution = executionContext.type === 'manager';
+
+    console.log(ui ? ui.t('operations.completed') : 'Operation completed');
+
+    if (isManagerExecution && !this.isNonInteractiveMode()) {
+      // Interactive menu execution - return to menu
+      await this.prompt(ui ? ui.t('menu.returnToMainMenu') : 'Press Enter to return to main menu...');
+    } else {
+      // Direct commands, non-interactive mode, or workflow execution - exit immediately
+      console.log(ui ? ui.t('workflow.exitingCompleted') : 'Exiting...');
+      this.safeClose();
+      process.exit(0);
+    }
+  }
+
+  /**
+   * Handle command error based on execution context
+   * @param {Error} error - Error that occurred
+   * @param {Object} executionContext - Execution context information
+   * @param {Object} ui - UI instance for translations (optional)
+   * @returns {Promise<void>}
+   */
+  async handleCommandError(error, executionContext, ui = null) {
+    const isDirectCommand = executionContext.type === 'direct';
+    const isWorkflowExecution = executionContext.type === 'workflow';
+    const isManagerExecution = executionContext.type === 'manager';
+
+    if (ui && ui.t) {
+      console.error(ui.t('common.errorExecutingCommand', { error: error.message }));
+    } else {
+      console.error(`Error executing command: ${error.message}`);
+    }
+
+    if (isManagerExecution && !this.isNonInteractiveMode()) {
+      // Interactive menu execution - show error and return to menu
+      await this.prompt(ui ? ui.t('menu.pressEnterToContinue') : 'Press Enter to continue...');
+    } else if (isDirectCommand && !this.isNonInteractiveMode()) {
+      // Direct command execution - show "enter to continue" and exit with error
+      await this.prompt(ui ? ui.t('menu.pressEnterToContinue') : 'Press Enter to continue...');
+      this.safeClose();
+      process.exit(1);
+    } else {
+      // Non-interactive mode or workflow execution - exit immediately with error
+      this.safeClose();
+      process.exit(1);
+    }
+  }
+};