i18ntk 1.10.2 → 2.0.2

package/utils/i18n-helper.js

@@ -2,11 +2,47 @@
 const path = require('path');
 const fs = require('fs');
 
+// Lazy load SecurityUtils to prevent circular dependencies
+let securityUtils;
+function getSecurityUtils() {
+  if (!securityUtils) {
+    try {
+      securityUtils = require('./security');
+    } catch (error) {
+      // Fallback: use basic fs operations if SecurityUtils is not available
+      return {
+        safeExistsSync: (path) => {
+          try {
+            return require('fs').existsSync(path);
+          } catch {
+            return false;
+          }
+        },
+        safeWriteFileSync: (path, data, encoding) => {
+          try {
+            return require('fs').writeFileSync(path, data, encoding);
+          } catch {
+            return null;
+          }
+        },
+        safeReadFileSync: (path, encoding) => {
+          try {
+            return require('fs').readFileSync(path, encoding);
+          } catch {
+            return null;
+          }
+        }
+      };
+    }
+  }
+  return securityUtils;
+}
+
 // Helper functions for OS-agnostic path handling
 function toPosix(p) { return String(p).replace(/\\/g, '/'); }
-function isBundledPath(p) { 
-  const s = toPosix(p); 
-  return s.includes('/node_modules/i18ntk/') || s.includes('/i18ntk/ui-locales/'); 
+function isBundledPath(p) {
+  const s = toPosix(p);
+  return s.includes('/node_modules/i18ntk/') || s.includes('/i18ntk/ui-locales/');
 }
 
 function safeRequireConfig() {
@@ -21,7 +57,8 @@ function stripBOMAndComments(s) {
 }
 
 function readJsonSafe(file) {
-  const raw = fs.readFileSync(file, 'utf8');
+  const SecurityUtils = getSecurityUtils();
+  const raw = SecurityUtils.safeReadFileSync(file, path.dirname(file), 'utf8');
   return JSON.parse(stripBOMAndComments(raw));
 }
 
@@ -43,7 +80,8 @@ function resolveLocalesDirs() {
       try {
         const normalized = path.normalize(path.resolve(dir.trim()));
 
-        if (fs.existsSync(normalized) && fs.statSync(normalized).isDirectory()) {
+        const SecurityUtils = getSecurityUtils();
+        if (SecurityUtils.safeExistsSync(normalized) && fs.statSync(normalized).isDirectory()) {
           dirs.push(normalized);
         }
       } catch {
@@ -54,7 +92,7 @@ function resolveLocalesDirs() {
 
   const pkgA = pkgUiLocalesDirViaThisFile();
   addDir(pkgA);
-  
+
   const pkgB = pkgUiLocalesDirViaResolve();
   if (pkgB && pkgB !== pkgA) {
     addDir(pkgB);
@@ -78,28 +116,33 @@ function candidatesForLang(dir, lang) {
 
 function findLocaleFilesAllDirs(lang) {
   const dirs = resolveLocalesDirs();
-  
+
   if (process.env.I18NTK_DEBUG_LOCALES === '1') {
     console.log('🔎 i18ntk locale search dirs:', dirs);
   }
-  
+
   const files = [];
   const errors = [];
-  
+
   for (const dir of dirs) {
     for (const candidate of candidatesForLang(dir, lang)) {
       try {
-        if (fs.existsSync(candidate)) {
+        const SecurityUtils = getSecurityUtils();
+        if (SecurityUtils.safeExistsSync(candidate)) {
           const stats = fs.statSync(candidate);
           if (stats.isFile() && stats.size > 0) {
             // Validate file is readable and parseable
             fs.accessSync(candidate, fs.constants.R_OK);
             // Quick JSON validation
-            const content = fs.readFileSync(candidate, 'utf8');
-            if (content.trim().startsWith('{') || content.trim().startsWith('[')) {
-              files.push(candidate);
+            const content = SecurityUtils.safeReadFileSync(candidate, path.dirname(candidate), 'utf8');
+            if (content) {
+              if (content.trim().startsWith('{') || content.trim().startsWith('[')) {
+                files.push(candidate);
+              } else {
+                errors.push({ file: candidate, error: 'Invalid JSON format' });
+              }
             } else {
-              errors.push({ file: candidate, error: 'Invalid JSON format' });
+              errors.push({ file: candidate, error: 'Empty or unreadable file' });
             }
           }
         }
@@ -108,11 +151,11 @@ function findLocaleFilesAllDirs(lang) {
       }
     }
   }
-  
+
   if (process.env.I18NTK_DEBUG_LOCALES === '1' && errors.length > 0) {
     console.warn(`⚠️ Locale resolution errors for ${lang}:`, errors);
   }
-  
+
   return files;
 }
 
@@ -121,34 +164,34 @@ let currentLanguage = 'en';
 let isInitialized = false;
 const missingWarned = new Set();
 
-function loadTranslations(language) {
-  const cfg = safeRequireConfig();
-  const settings = cfg?.getConfig?.() || {};
-  const configuredLanguage = settings.uiLanguage || settings.language || 'en';
-
-  // Prioritize settings file language over environment variable
-  const requested = (configuredLanguage || language || 'en').toString();
+function loadTranslations(language) {
+  const cfg = safeRequireConfig();
+  const settings = cfg?.getConfig?.() || {};
+  const configuredLanguage = settings.uiLanguage || settings.language;
+
+  // Prioritize CLI argument, then UI language, then language fallback
+  const requested = (language || configuredLanguage || 'en').toString();
   const short = requested.split('-')[0].toLowerCase();
   const tryOrder = [requested, short, 'en'];
 
   const loadErrors = [];
-  
+
   for (const lang of tryOrder) {
     const files = findLocaleFilesAllDirs(lang);
-    
+
     // Prioritize bundled locales over project ones
       const prioritizedFiles = files.sort((a, b) => Number(isBundledPath(b)) - Number(isBundledPath(a)));
-    
+
     for (const file of prioritizedFiles) {
       try {
         translations = readJsonSafe(file);
         currentLanguage = lang;
         isInitialized = true;
-        
+
         if (process.env.I18NTK_DEBUG_LOCALES === '1') {
           console.log(`🗂 Loaded UI locale → ${file} (${lang})`);
         }
-        
+
         // Validate translations object
         if (typeof translations === 'object' && translations !== null) {
           return translations;
@@ -199,11 +242,11 @@ function loadTranslations(language) {
   };
   currentLanguage = 'en';
   isInitialized = true;
-  
+
   if (loadErrors.length > 0) {
     console.warn(`⚠️ No valid UI locale files found. Using built-in English strings.`);
   }
-  
+
   return translations;
 }
 
@@ -219,7 +262,7 @@ function t(key, params = {}) {
     loadTranslations();
     isInitialized = true;
   }
-  
+
   // Split the key into parts (e.g., 'module.subkey' -> ['module', 'subkey'])
   const keyParts = key.split('.');
   let value = translations;
@@ -258,12 +301,12 @@ function t(key, params = {}) {
     }
     return key;
   }
-  
+
   // If we found a string, interpolate parameters
   if (typeof value === 'string') {
     return interpolateParams(value, params);
   }
-  
+
   // Return the key if the final value is not a string
   console.warn(`Translation key does not resolve to a string: ${key}`);
   return key;
@@ -309,12 +352,13 @@ function getAvailableLanguages() {
   const langs = new Set();
   for (const d of dirs) {
     try {
-      if (!fs.existsSync(d)) continue;
+      const SecurityUtils = getSecurityUtils();
+      if (!SecurityUtils.safeExistsSync(d)) continue;
       for (const f of fs.readdirSync(d)) {
         if (f.endsWith('.json')) langs.add(path.basename(f, '.json'));
       }
       for (const f of fs.readdirSync(d, { withFileTypes: true })) {
-        if (f.isDirectory() && fs.existsSync(path.join(d, f.name, `${f.name}.json`))) {
+        if (f.isDirectory() && SecurityUtils.safeExistsSync(path.join(d, f.name, `${f.name}.json`))) {
           langs.add(f.name);
         }
       }
@@ -347,11 +391,11 @@ function deepMerge(target, source) {
  * Refresh language from settings manager
  * This ensures translations stay in sync with settings changes
  */
-function refreshLanguageFromSettings() {
-  const cfg = safeRequireConfig();
-  const settings = cfg?.getConfig?.() || {};
-  const configuredLanguage = settings.language || settings.uiLanguage || 'en';
-  
+function refreshLanguageFromSettings() {
+  const cfg = safeRequireConfig();
+  const settings = cfg?.getConfig?.() || {};
+  const configuredLanguage = settings.uiLanguage || settings.language || 'en';
+
   if (configuredLanguage !== currentLanguage) {
     isInitialized = false;
     loadTranslations(configuredLanguage);
@@ -373,4 +417,4 @@ module.exports = {
   deepMerge,
   refreshTranslations,
   refreshLanguageFromSettings
-};
+};

package/utils/init-helper.js

@@ -1,81 +1,121 @@
-const fs = require('fs');
-const path = require('path');
-const configManager = require('./config-helper');
-const { ensureDirectory } = require('./config-helper');
+const fs = require('fs');
+const path = require('path');
+const configManager = require('./config-manager');
+const SecurityUtils = require('./security');
+
+function ensureDirectory(dirPath) {
+  if (!dirPath || typeof dirPath !== 'string') return;
+  if (!SecurityUtils.safeExistsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function readJsonSafe(filePath) {
+  try {
+    if (!SecurityUtils.safeExistsSync(filePath)) return null;
+    const raw = SecurityUtils.safeReadFileSync(filePath, path.dirname(filePath), 'utf8');
+    if (!raw) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function hasSourceLanguageFiles(sourceDir, sourceLanguage) {
+  const baseSourceDir = path.resolve(sourceDir);
+  const modularLanguageDir = path.join(baseSourceDir, sourceLanguage);
+  const singleLanguageFile = path.join(baseSourceDir, `${sourceLanguage}.json`);
+
+  if (SecurityUtils.safeExistsSync(modularLanguageDir)) {
+    try {
+      if (fs.statSync(modularLanguageDir).isDirectory()) {
+        return fs.readdirSync(modularLanguageDir).some(file => file.endsWith('.json'));
+      }
+    } catch {
+      // Continue with single-file fallback.
+    }
+  }
+
+  return SecurityUtils.safeExistsSync(singleLanguageFile);
+}
 
 /**
  * Check if the project is properly initialized
  * @param {Object} options - Options for initialization check
  * @returns {Promise<Object>} Object containing initialization status and config
  */
-async function checkInitialized(options = {}) {
-  const settings = configManager.loadSettings ? configManager.loadSettings() : (configManager.getConfig ? configManager.getConfig() : {});
-  const currentVersion = require('../package.json').version;
-  const configDir = settings.configDir || './settings';
-  
-  // Ensure config directory exists
-  ensureDirectory(configDir);
-  
+async function checkInitialized(options = {}) {
+  const settings = configManager.getConfig ? configManager.getConfig() : {};
+  const currentVersion = require('../package.json').version;
+  const projectConfigPath = configManager.CONFIG_PATH || path.join(process.cwd(), '.i18ntk-config');
+  const configDir = path.dirname(projectConfigPath);
+  
+  // Ensure config directory exists
+  ensureDirectory(configDir);
+  
   const defaultConfig = {
     sourceDir: settings.sourceDir || './locales',
     sourceLanguage: settings.sourceLanguage || 'en',
     projectRoot: path.resolve('.'),
     framework: settings.framework || { detected: false, prompt: 'always' },
-    configDir: configDir
-  };
-
-  // Check initialization status file with consistent path resolution
-  const initFilePath = path.resolve(configDir, 'initialization.json');
-  
-  // If initialization file exists and is valid, return early
-  if (fs.existsSync(initFilePath)) {
-    try {
-      const initStatus = JSON.parse(fs.readFileSync(initFilePath, 'utf8'));
-      const isInitialized = initStatus.initialized && 
-                          initStatus.version && 
-                          initStatus.version.split('.')[0] === currentVersion.split('.')[0];
-      
-      if (isInitialized) {
-        // Merge with default config but don't override existing settings
-        return {
-          initialized: true,
-          config: { 
-            ...defaultConfig, 
-            ...initStatus,
-            // Don't override framework settings if they exist
-            framework: initStatus.framework || defaultConfig.framework
-          }
-        };
-      }
-    } catch (e) {
-      console.warn('Warning: Invalid initialization file, will reinitialize...', e.message);
-    }
-  }
-
-  // Check if source language files exist
-  const langDir = path.resolve(defaultConfig.sourceDir, defaultConfig.sourceLanguage);
-  const hasLanguageFiles = fs.existsSync(langDir) &&
-    fs.readdirSync(langDir).some(f => f.endsWith('.json'));
-
-  // If language files exist but no init file, create one
-  if (hasLanguageFiles) {
-    const initData = {
-      initialized: true,
-      version: currentVersion,
-      timestamp: new Date().toISOString(),
-      sourceDir: defaultConfig.sourceDir,
-      sourceLanguage: defaultConfig.sourceLanguage,
-      detectedLanguage: defaultConfig.detectedLanguage,
-      detectedFramework: defaultConfig.detectedFramework,
-      lastUpdated: new Date().toISOString()
-    };
-    
-    ensureDirectory(path.dirname(initFilePath));
-    fs.writeFileSync(initFilePath, JSON.stringify(initData, null, 2));
-    
-    return {
-      initialized: true,
-      config: { ...defaultConfig, ...initData }
+    configDir: configDir
+  };
+
+  // Primary source of truth in v2: project-level .i18ntk-config
+  const projectConfig = readJsonSafe(projectConfigPath);
+  if (projectConfig?.setup?.completed === true) {
+    return {
+      initialized: true,
+      config: {
+        ...defaultConfig,
+        ...projectConfig,
+        framework: projectConfig.framework || defaultConfig.framework
+      }
+    };
+  }
+
+  // Backward compatibility: legacy initialization marker file.
+  const initFilePath = path.join(configDir, 'initialization.json');
+  const initStatus = readJsonSafe(initFilePath);
+  const isLegacyInitialized = Boolean(initStatus?.initialized) && (
+    !initStatus.version ||
+    initStatus.version.split('.')[0] === currentVersion.split('.')[0]
+  );
+  if (isLegacyInitialized) {
+    return {
+      initialized: true,
+      config: {
+        ...defaultConfig,
+        ...initStatus,
+        framework: initStatus.framework || defaultConfig.framework
+      }
+    };
+  }
+
+  // Final fallback: detect existing source language files and mark initialized.
+  const sourceDir = options.sourceDir || defaultConfig.sourceDir;
+  const sourceLanguage = options.sourceLanguage || defaultConfig.sourceLanguage;
+  const hasLanguageFiles = hasSourceLanguageFiles(sourceDir, sourceLanguage);
+
+  // If language files exist but no init file, create one
+  if (hasLanguageFiles) {
+    const initData = {
+      initialized: true,
+      version: currentVersion,
+      timestamp: new Date().toISOString(),
+      sourceDir,
+      sourceLanguage,
+      detectedLanguage: defaultConfig.detectedLanguage,
+      detectedFramework: defaultConfig.detectedFramework,
+      lastUpdated: new Date().toISOString()
+    };
+    
+    ensureDirectory(path.dirname(initFilePath));
+    SecurityUtils.safeWriteFileSync(initFilePath, JSON.stringify(initData, null, 2), path.dirname(initFilePath), 'utf8');
+    
+    return {
+      initialized: true,
+      config: { ...defaultConfig, ...initData }
     };
   }
 
@@ -90,33 +130,51 @@ async function checkInitialized(options = {}) {
  * @param {Object} config - Configuration to save
  * @returns {Promise<void>}
  */
-async function markAsInitialized(config) {
-  const settings = configManager.loadSettings ? configManager.loadSettings() : (configManager.getConfig ? configManager.getConfig() : {});
-  const configDir = settings.configDir || './settings';
-  const initFilePath = path.resolve(configDir, 'initialization.json');
-  const currentVersion = require('../package.json').version;
-  
-  const initData = {
-    initialized: true,
-    version: currentVersion,
-    timestamp: new Date().toISOString(),
-    sourceDir: config.sourceDir,
-    sourceLanguage: config.sourceLanguage,
-    detectedLanguage: config.detectedLanguage,
-    detectedFramework: config.detectedFramework,
-    lastUpdated: new Date().toISOString()
-  };
-  
-  ensureDirectory(path.dirname(initFilePath));
-  fs.writeFileSync(initFilePath, JSON.stringify(initData, null, 2));
-  
-  // Update the settings object if it has a save method
-  if (configManager.saveSettings) {
-    await configManager.saveSettings({ ...settings, ...initData });
-  } else if (configManager.saveConfig) {
-    await configManager.saveConfig({ ...settings, ...initData });
-  }
-}
+async function markAsInitialized(config) {
+  const settings = configManager.getConfig ? configManager.getConfig() : {};
+  const projectConfigPath = configManager.CONFIG_PATH || path.join(process.cwd(), '.i18ntk-config');
+  const configDir = path.dirname(projectConfigPath);
+  const initFilePath = path.join(configDir, 'initialization.json');
+  const currentVersion = require('../package.json').version;
+  const now = new Date().toISOString();
+  const sourceDir = config?.sourceDir || settings.sourceDir || './locales';
+  const sourceLanguage = config?.sourceLanguage || settings.sourceLanguage || 'en';
+  
+  const initData = {
+    initialized: true,
+    version: currentVersion,
+    timestamp: now,
+    sourceDir,
+    sourceLanguage,
+    detectedLanguage: config?.detectedLanguage || settings.detectedLanguage,
+    detectedFramework: config?.detectedFramework || settings.detectedFramework,
+    lastUpdated: now
+  };
+  
+  ensureDirectory(path.dirname(initFilePath));
+  SecurityUtils.safeWriteFileSync(initFilePath, JSON.stringify(initData, null, 2), path.dirname(initFilePath), 'utf8');
+
+  const mergedConfig = {
+    ...settings,
+    ...(config || {}),
+    sourceDir,
+    sourceLanguage,
+    version: currentVersion,
+    setup: {
+      ...(settings.setup || {}),
+      completed: true,
+      completedAt: now,
+      version: currentVersion,
+      setupId: settings.setup?.setupId || `setup_${Date.now()}`
+    }
+  };
+  
+  if (configManager.saveConfig) {
+    await configManager.saveConfig(mergedConfig);
+  } else {
+    SecurityUtils.safeWriteFileSync(projectConfigPath, JSON.stringify(mergedConfig, null, 2), path.dirname(projectConfigPath), 'utf8');
+  }
+}
 
 module.exports = {
   checkInitialized,