i18ntk 1.10.2 → 2.0.2

package/utils/config-manager.js

@@ -1,16 +1,16 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { envManager } = require('./env-manager');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const SecurityUtils = require('./security');
 
 // Determine package directory and user project root
 const packageDir = path.resolve(__dirname, '..');
 const userProjectRoot = process.cwd();
 
-// Always use package's internal settings directory to avoid polluting user projects
-// The settings directory should be within the package, not in user space
-const PROJECT_SETTINGS_DIR = path.join(packageDir, 'settings');
-const PROJECT_CONFIG_PATH = path.join(PROJECT_SETTINGS_DIR, 'i18ntk-config.json');
+// Always use current working directory for settings to support test environments
+// This ensures config works correctly when tests change the working directory
+const PROJECT_CONFIG_PATH = path.join(process.cwd(), '.i18ntk-config');
+const PROJECT_SETTINGS_DIR = path.dirname(PROJECT_CONFIG_PATH);
 
 // Setup tracking file
 const SETUP_COMPLETED_FILE = path.join(PROJECT_SETTINGS_DIR, 'setup.json');
@@ -241,24 +241,26 @@ const DEFAULT_CONFIG = {
   "timezone": "auto"
 };
 
-// Mapping of supported environment variables to config keys
-const ENV_VAR_MAP = {
-  I18NTK_PROJECT_ROOT: 'projectRoot',
-  I18NTK_SOURCE_DIR: 'sourceDir',
-  I18NTK_I18N_DIR: 'i18nDir',
-  I18NTK_OUTPUT_DIR: 'outputDir',
-  I18NTK_FRAMEWORK_PREFERENCE: 'framework.preference',
-  I18NTK_FRAMEWORK_FALLBACK: 'framework.fallback',
-  I18NTK_FRAMEWORK_DETECT: 'framework.detect',
-  I18NTK_LOG_LEVEL: 'advanced.logLevel',
-  I18NTK_LANG: 'uiLanguage',
-  I18NTK_SILENT: 'processing.minimalLogging',
-};
+// Environment variable support has been removed in favor of exclusive .i18ntk-config configuration
 
 let currentConfig = null;
+let configLoadInProgress = false;
+let recursionDepth = 0;
+const MAX_RECURSION_DEPTH = 15; // Increased to handle legitimate sequential calls
 
 function clone(obj) {
-  return JSON.parse(JSON.stringify(obj));
+   return JSON.parse(JSON.stringify(obj));
+}
+
+function checkRecursionGuard() {
+    // Disabled recursion detection to prevent false positives on legitimate sequential calls
+    // TODO: Implement more sophisticated recursion detection in future versions
+    return null;
+}
+
+function resetRecursionGuard() {
+    recursionDepth = 0;
+    configLoadInProgress = false;
 }
 
 function ensureProjectSettingsDir() {
@@ -297,56 +299,38 @@ function deepMerge(target, source, basePath = '') {
 }
 
 function applyEnvOverrides(cfg) {
-  for (const [envVar, keyPath] of Object.entries(ENV_VAR_MAP)) {
-    const value = envManager.get(envVar);
-    if (value === null || value === undefined) continue;
-    
-    const keys = keyPath.split('.');
-    let current = cfg;
-    for (let i = 0; i < keys.length - 1; i++) {
-      const k = keys[i];
-      if (!current[k] || typeof current[k] !== 'object') current[k] = {};
-      current = current[k];
-    }
-    const leaf = keys[keys.length - 1];
-    
-    if (keyPath === 'framework.detect' || envVar === 'I18NTK_FRAMEWORK_DETECT') {
-      current[leaf] = String(value).toLowerCase() !== 'false' && value !== '0';
-    } else if (envVar === 'I18NTK_SILENT') {
-      current[leaf] = String(value).toLowerCase() === 'true' || value === '1';
-    } else {
-      current[leaf] = normalizePathValue(keyPath, value);
-    }
-  }
+  // Environment variable support has been removed in favor of exclusive .i18ntk-config configuration
+  // This function is kept for backward compatibility but does nothing
   return cfg;
 }
 
 function tryReadJson(filePath) {
   try {
-    if (!fs.existsSync(filePath)) {
+    if (!SecurityUtils.safeExistsSync(filePath)) {
       return null;
     }
-    
-    const data = fs.readFileSync(filePath, 'utf8');
+
+    const data = SecurityUtils.safeReadFileSync(filePath, path.dirname(filePath), 'utf8');
     if (!data || data.trim() === '') {
       console.warn(`[i18ntk] Warning: Empty or invalid JSON file at ${filePath}`);
       return null;
     }
-    
-    try {
-      return JSON.parse(data);
-    } catch (parseError) {
-      console.error(`[i18ntk] Error parsing JSON from ${filePath}: ${parseError.message}`);
-      // Create a backup of the corrupted file
-      const backupPath = `${filePath}.corrupted-${Date.now()}.bak`;
-      try {
-        fs.writeFileSync(backupPath, data, 'utf8');
-        console.warn(`[i18ntk] Created backup of corrupted config at ${backupPath}`);
-      } catch (backupError) {
-        console.error(`[i18ntk] Failed to create backup of corrupted config: ${backupError.message}`);
-      }
-      return null;
-    }
+
+    const parsed = SecurityUtils.safeParseJSON(data);
+    if (parsed && typeof parsed === 'object') {
+      return parsed;
+    }
+
+    console.error(`[i18ntk] Error parsing JSON from ${filePath}: Invalid JSON content`);
+    // Create a backup of the corrupted file
+    const backupPath = `${filePath}.corrupted-${Date.now()}.bak`;
+    try {
+      SecurityUtils.safeWriteFileSync(backupPath, data, path.dirname(backupPath), 'utf8');
+      console.warn(`[i18ntk] Created backup of corrupted config at ${backupPath}`);
+    } catch (backupError) {
+      console.error(`[i18ntk] Failed to create backup of corrupted config: ${backupError.message}`);
+    }
+    return null;
   } catch (error) {
     console.error(`[i18ntk] Error reading config file at ${filePath}: ${error.message}`);
     return null;
@@ -355,7 +339,7 @@ function tryReadJson(filePath) {
 
 async function migrateLegacyIfNeeded(baseCfg) {
   // If project config does not exist but legacy exists, migrate once
-  if (!fs.existsSync(PROJECT_CONFIG_PATH) && fs.existsSync(LEGACY_CONFIG_PATH)) {
+  if (!SecurityUtils.safeExistsSync(PROJECT_CONFIG_PATH) && SecurityUtils.safeExistsSync(LEGACY_CONFIG_PATH)) {
     const legacy = tryReadJson(LEGACY_CONFIG_PATH);
     if (legacy && typeof legacy === 'object') {
       const merged = deepMerge(clone(baseCfg), legacy);
@@ -367,61 +351,95 @@ async function migrateLegacyIfNeeded(baseCfg) {
         // Best-effort removal of legacy file to prevent future use
         try { fs.unlinkSync(LEGACY_CONFIG_PATH); } catch (_) {}
         // Deprecation notice
-        console.warn('[i18ntk] Deprecated config location detected (~/.i18ntk). Your config has been migrated to settings/i18ntk-config.json. Please commit the settings/ directory to your project.');
-        return merged;
-      } catch (_) {
-        // If write fails, fall back to in-memory config without deleting legacy
-        console.warn('[i18ntk] Deprecated config location detected (~/.i18ntk). Using migrated settings in memory; failed to persist to settings/. Ensure the project has write permissions.');
-        return merged;
-      }
+        console.warn('[i18ntk] Deprecated config location detected (~/.i18ntk). Configuration was migrated to project .i18ntk-config.');
+        return merged;
+      } catch (_) {
+        // If write fails, fall back to in-memory config without deleting legacy
+        console.warn('[i18ntk] Deprecated config location detected (~/.i18ntk). Using migrated settings in memory; failed to persist to .i18ntk-config.');
+        return merged;
+      }
     }
   }
   return null;
 }
 
 function loadConfig() {
-  if (currentConfig) return currentConfig;
-  let cfg = clone(DEFAULT_CONFIG);
-  // 1) Project config (primary)
-  const projectCfg = tryReadJson(PROJECT_CONFIG_PATH);
-  if (projectCfg) {
-    cfg = deepMerge(clone(DEFAULT_CONFIG), projectCfg);
-  } else {
-    // 2) Package default (read-only)
-    const pkgCfg = tryReadJson(PACKAGE_CONFIG_PATH);
-    if (pkgCfg) {
-      cfg = deepMerge(clone(DEFAULT_CONFIG), pkgCfg);
+    // Check for recursion
+    const recursionFallback = checkRecursionGuard();
+    if (recursionFallback) return recursionFallback;
+
+    // Return cached config if available
+    if (currentConfig) {
+      resetRecursionGuard();
+      return currentConfig;
     }
-    // 3) Legacy migration (read-only source)
-    if (!projectCfg) {
-      const fromLegacy = tryReadJson(LEGACY_CONFIG_PATH);
-      if (fromLegacy) {
-        cfg = deepMerge(clone(DEFAULT_CONFIG), fromLegacy);
-        // Attempt to migrate to project settings
-        // Ignore migration errors; we still return merged cfg in memory
-        // eslint-disable-next-line no-unused-vars
-        console.warn('[i18ntk] Detected legacy config at ~/.i18ntk. Migrating to project settings directory...');
-        const _ = (async () => { await migrateLegacyIfNeeded(DEFAULT_CONFIG); })();
-      }
+
+    // Prevent concurrent loading
+    if (configLoadInProgress) {
+      console.warn('[i18ntk] Configuration loading already in progress, returning defaults');
+      resetRecursionGuard();
+      return clone(DEFAULT_CONFIG);
     }
-  }
-  applyEnvOverrides(cfg);
-  currentConfig = cfg;
-  return currentConfig;
+
+    configLoadInProgress = true;
+
+    try {
+      let cfg = clone(DEFAULT_CONFIG);
+   // 1) Project config (primary)
+   const projectCfg = tryReadJson(PROJECT_CONFIG_PATH);
+   if (projectCfg) {
+     cfg = deepMerge(clone(DEFAULT_CONFIG), projectCfg);
+   } else {
+     // 2) Package default (read-only)
+     const pkgCfg = tryReadJson(PACKAGE_CONFIG_PATH);
+     if (pkgCfg) {
+       cfg = deepMerge(clone(DEFAULT_CONFIG), pkgCfg);
+     }
+     // 3) Legacy migration (read-only source)
+     if (!projectCfg) {
+       const fromLegacy = tryReadJson(LEGACY_CONFIG_PATH);
+       if (fromLegacy) {
+         cfg = deepMerge(clone(DEFAULT_CONFIG), fromLegacy);
+         // Attempt to migrate to project settings
+         // Ignore migration errors; we still return merged cfg in memory
+         // eslint-disable-next-line no-unused-vars
+         console.warn('[i18ntk] Detected legacy config at ~/.i18ntk. Migrating to project settings directory...');
+         const _ = (async () => { await migrateLegacyIfNeeded(DEFAULT_CONFIG); })();
+       }
+     }
+   }
+     applyEnvOverrides(cfg);
+     currentConfig = cfg;
+     return currentConfig;
+   } catch (error) {
+     console.error('[i18ntk] Error in loadConfig:', error.message);
+     currentConfig = clone(DEFAULT_CONFIG);
+     return currentConfig;
+   } finally {
+     configLoadInProgress = false;
+     recursionDepth = Math.max(0, recursionDepth - 1);
+   }
 }
 
-async function saveConfig(cfg = currentConfig) {
-  if (!cfg) return;
-  
+async function saveConfig(cfg = currentConfig) {
+  if (!cfg || typeof cfg !== 'object') return;
+
   try {
     // Ensure settings directory exists
-    if (!fs.existsSync(PROJECT_SETTINGS_DIR)) {
+    if (!SecurityUtils.safeExistsSync(PROJECT_SETTINGS_DIR)) {
       fs.mkdirSync(PROJECT_SETTINGS_DIR, { recursive: true });
     }
-    
-    // Save configuration to the project settings directory
-    await fs.promises.writeFile(PROJECT_CONFIG_PATH, JSON.stringify(cfg, null, 2), 'utf8');
-    currentConfig = cfg;
+
+    const serialized = JSON.stringify(cfg, null, 2);
+    if (typeof serialized !== 'string' || serialized.length === 0) {
+      throw new Error('Cannot save empty configuration payload');
+    }
+
+    // Atomic write prevents partially-written/empty config files.
+    const tempPath = `${PROJECT_CONFIG_PATH}.tmp`;
+    await fs.promises.writeFile(tempPath, serialized, 'utf8');
+    await fs.promises.rename(tempPath, PROJECT_CONFIG_PATH);
+    currentConfig = cfg;
   } catch (error) {
     console.error('[i18ntk] Error saving configuration:', error.message);
     throw error;
@@ -429,58 +447,71 @@ async function saveConfig(cfg = currentConfig) {
 }
 
 function getConfig() {
-  if (currentConfig) {
-    return resolvePaths(currentConfig);
-  }
-  
-  try {
-    // Ensure settings directory exists
-    if (!fs.existsSync(PROJECT_SETTINGS_DIR)) {
-      fs.mkdirSync(PROJECT_SETTINGS_DIR, { recursive: true });
-    }
-
-    // Setup is now handled automatically by the unified config system
-    // No need to check here - handled by getUnifiedConfig
+    // Check for recursion
+    const recursionFallback = checkRecursionGuard();
+    if (recursionFallback) return resolvePaths(recursionFallback);
 
-    // Check if config file exists
-    if (fs.existsSync(PROJECT_CONFIG_PATH)) {
-      const config = JSON.parse(fs.readFileSync(PROJECT_CONFIG_PATH, 'utf8'));
-      currentConfig = config;
-      return resolvePaths(config);
+    if (currentConfig) {
+      resetRecursionGuard();
+      return resolvePaths(currentConfig);
     }
 
-    // Check for legacy config for migration
-    if (fs.existsSync(LEGACY_CONFIG_PATH)) {
-      console.log('📦 Migrating legacy configuration...');
-      const legacyConfig = JSON.parse(fs.readFileSync(LEGACY_CONFIG_PATH, 'utf8'));
-      const migratedConfig = { ...DEFAULT_CONFIG, ...legacyConfig };
-      saveConfig(migratedConfig);
-      currentConfig = migratedConfig;
-      
-      // Clean up legacy config
-      try {
-        fs.unlinkSync(LEGACY_CONFIG_PATH);
-        if (fs.readdirSync(LEGACY_CONFIG_DIR).length === 0) {
-          fs.rmdirSync(LEGACY_CONFIG_DIR);
-        }
-      } catch (cleanupError) {
-        // Ignore cleanup errors
-      }
-      
-      return resolvePaths(migratedConfig);
-    }
-
-    // Use package defaults for new installation
-    console.log('📦 Initializing with default configuration...');
-    saveConfig(DEFAULT_CONFIG);
-    currentConfig = DEFAULT_CONFIG;
-    return resolvePaths(DEFAULT_CONFIG);
-
-  } catch (error) {
-    console.warn('⚠️  Error loading configuration, using defaults:', error.message);
-    currentConfig = DEFAULT_CONFIG;
-    return resolvePaths(DEFAULT_CONFIG);
-  }
+   try {
+     // Ensure settings directory exists
+     if (!SecurityUtils.safeExistsSync(PROJECT_SETTINGS_DIR)) {
+       fs.mkdirSync(PROJECT_SETTINGS_DIR, { recursive: true });
+     }
+
+     // Setup is now handled automatically by the unified config system
+     // No need to check here - handled by getUnifiedConfig
+
+     // Check if config file exists
+     if (SecurityUtils.safeExistsSync(PROJECT_CONFIG_PATH)) {
+       const rawConfig = SecurityUtils.safeReadFileSync(PROJECT_CONFIG_PATH, path.dirname(PROJECT_CONFIG_PATH), 'utf8');
+       const config = SecurityUtils.safeParseJSON(rawConfig);
+       if (config && typeof config === 'object') {
+         currentConfig = config;
+         return resolvePaths(config);
+       }
+       throw new Error('Invalid project configuration JSON');
+     }
+
+     // Check for legacy config for migration
+     if (SecurityUtils.safeExistsSync(LEGACY_CONFIG_PATH)) {
+       console.log('📦 Migrating legacy configuration...');
+       const legacyRaw = SecurityUtils.safeReadFileSync(LEGACY_CONFIG_PATH, path.dirname(LEGACY_CONFIG_PATH), 'utf8');
+       const legacyConfig = SecurityUtils.safeParseJSON(legacyRaw);
+       if (!legacyConfig || typeof legacyConfig !== 'object') {
+         throw new Error('Invalid legacy configuration JSON');
+       }
+       const migratedConfig = { ...DEFAULT_CONFIG, ...legacyConfig };
+       saveConfig(migratedConfig);
+       currentConfig = migratedConfig;
+
+       // Clean up legacy config
+       try {
+         fs.unlinkSync(LEGACY_CONFIG_PATH);
+         if (fs.readdirSync(LEGACY_CONFIG_DIR).length === 0) {
+           fs.rmdirSync(LEGACY_CONFIG_DIR);
+         }
+       } catch (cleanupError) {
+         // Ignore cleanup errors
+       }
+
+       return resolvePaths(migratedConfig);
+     }
+
+     // Use package defaults for new installation
+     console.log('📦 Initializing with default configuration...');
+     saveConfig(DEFAULT_CONFIG);
+     currentConfig = DEFAULT_CONFIG;
+     return resolvePaths(DEFAULT_CONFIG);
+
+   } catch (error) {
+     console.warn('⚠️  Error loading configuration, using defaults:', error.message);
+     currentConfig = DEFAULT_CONFIG;
+     return resolvePaths(DEFAULT_CONFIG);
+   }
 }
 
 async function setConfig(cfg) {
@@ -502,27 +533,30 @@ async function resetToDefaults() {
   return currentConfig;
 }
 
-function resolvePaths(cfg = getConfig()) {
-  const root = path.resolve(projectRoot, cfg.projectRoot || '.');
-  const resolved = clone(cfg);
-  resolved.projectRoot = root;
-  ['sourceDir', 'i18nDir', 'outputDir'].forEach(key => {
-    if (resolved[key]) resolved[key] = path.resolve(root, resolved[key]);
-  });
-  if (resolved.scriptDirectories) {
-    resolved.scriptDirectories = { ...resolved.scriptDirectories };
-    for (const [k, v] of Object.entries(resolved.scriptDirectories)) {
-      if (v) resolved.scriptDirectories[k] = path.resolve(root, v);
+function resolvePaths(cfg) {
+    if (!cfg) {
+      cfg = clone(DEFAULT_CONFIG);
     }
-  }
-  return resolved;
+   const root = path.resolve(projectRoot, cfg.projectRoot || '.');
+   const resolved = clone(cfg);
+   resolved.projectRoot = root;
+   ['sourceDir', 'i18nDir', 'outputDir'].forEach(key => {
+     if (resolved[key]) resolved[key] = path.resolve(root, resolved[key]);
+   });
+   if (resolved.scriptDirectories) {
+     resolved.scriptDirectories = { ...resolved.scriptDirectories };
+     for (const [k, v] of Object.entries(resolved.scriptDirectories)) {
+       if (v) resolved.scriptDirectories[k] = path.resolve(root, v);
+     }
+   }
+   return resolved;
 }
 
 function toRelative(absPath) {
-  if (!absPath) return absPath;
-  const rel = path.relative(projectRoot, absPath);
-  const normalized = rel ? `./${rel.replace(/\\/g, '/')}` : '.';
-  return normalized;
+   if (!absPath) return absPath;
+   const rel = path.relative(projectRoot, absPath);
+   const normalized = rel ? `./${rel.replace(/\\/g, '/')}` : '.';
+   return normalized;
 }
 
 
@@ -539,5 +573,4 @@ module.exports = {
   resolvePaths,
   toRelative,
   normalizePathValue,
-}
-
+}

package/utils/config.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const SecurityUtils = require('./security');
 
 const settingsManager = require('../settings/settings-manager');
 const CONFIG_FILE = 'i18ntk-config.json';
@@ -46,12 +47,12 @@ function loadConfig(cwd = settingsManager.configDir) {
     const configPath = getConfigPath(cwd);
     
     // Check if file exists and is accessible
-    if (!fs.existsSync(configPath)) {
+    if (!SecurityUtils.safeExistsSync(configPath)) {
       return null;
     }
     
     // Read file with explicit encoding
-    const raw = fs.readFileSync(configPath, { encoding: 'utf8', flag: 'r' });
+    const raw = SecurityUtils.safeReadFileSync(configPath, settingsManager.configDir, 'utf8');
     
     // Basic validation of file content
     if (!raw || typeof raw !== 'string') {
@@ -83,12 +84,12 @@ function saveConfig(config, cwd = settingsManager.configDir) {
     const dir = path.dirname(configPath);
     
     // Ensure directory exists
-    if (!fs.existsSync(dir)) {
+    if (!SecurityUtils.safeExistsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
     
     // Write file with secure permissions (read/write for owner only)
-    fs.writeFileSync(
+    SecurityUtils.safeWriteFileSync(
       configPath,
       JSON.stringify(config, null, 2),
       { mode: 0o600, encoding: 'utf8' }