i18ntk 2.5.0 → 2.6.0

package/utils/config-manager.js

@@ -8,16 +8,20 @@ const { envManager } = require('./env-manager');
 
 // Determine package directory and user project root
 const packageDir = path.resolve(__dirname, '..');
-const userProjectRoot = path.resolve(process.cwd());
 
-// 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 = SecurityUtils.safeJoin(userProjectRoot, '.i18ntk-config');
-if (!PROJECT_CONFIG_PATH) {
-throw new Error('Invalid project config path - potential path traversal attempt');
+function getUserProjectRoot() {
+  return path.resolve(process.cwd());
 }
-const PROJECT_SETTINGS_DIR = path.dirname(PROJECT_CONFIG_PATH);
-const CONFIG_LOCK_PATH = `${PROJECT_CONFIG_PATH}.lock`;
+
+function getProjectConfigPath() {
+  const root = getUserProjectRoot();
+  const configPath = SecurityUtils.safeJoin(root, '.i18ntk-config');
+  if (!configPath) {
+    throw new Error('Invalid project config path - potential path traversal attempt');
+  }
+  return configPath;
+}
+
 const CONFIG_LOCK_TIMEOUT_MS = 5000;
 const CONFIG_LOCK_STALE_MS = 15000;
 const CONFIG_LOCK_RETRY_MS = 50;
@@ -72,7 +76,7 @@ function notifyConfigFallback(error) {
 }
 
 // Setup tracking file
-const SETUP_COMPLETED_FILE = path.join(PROJECT_SETTINGS_DIR, 'setup.json');
+const getSetupCompletedFile = () => path.join(path.dirname(getProjectConfigPath()), 'setup.json');
 
 // Legacy home directory config (for migration only)
 const LEGACY_CONFIG_DIR = path.join(os.homedir(), '.i18ntk');
@@ -82,12 +86,9 @@ const LEGACY_CONFIG_PATH = path.join(LEGACY_CONFIG_DIR, 'i18ntk-config.json');
 const PACKAGE_SETTINGS_DIR = path.join(packageDir, 'settings');
 const PACKAGE_CONFIG_PATH = path.join(PACKAGE_SETTINGS_DIR, 'i18ntk-config.json');
 
-// Keep projectRoot for path resolution functions
-const projectRoot = userProjectRoot;
-
 // Back-compat: expose CONFIG_DIR/CONFIG_PATH but point to project settings
-const CONFIG_DIR = PROJECT_SETTINGS_DIR;
-const CONFIG_PATH = PROJECT_CONFIG_PATH;
+const getConfigDir = () => path.dirname(getProjectConfigPath());
+const getConfigPath = getProjectConfigPath;
 
 // Default configuration values - comprehensive configuration
 const DEFAULT_CONFIG = {
@@ -314,12 +315,13 @@ function sleep(ms) {
 }
 
 async function acquireConfigLock(timeoutMs = CONFIG_LOCK_TIMEOUT_MS) {
+  const lockPath = `${getProjectConfigPath()}.lock`;
   const start = Date.now();
   let lockHandle = null;
 
   while (!lockHandle) {
     try {
-      lockHandle = await fs.promises.open(CONFIG_LOCK_PATH, 'wx');
+      lockHandle = await fs.promises.open(lockPath, 'wx');
       await lockHandle.writeFile(String(process.pid), 'utf8');
       break;
     } catch (error) {
@@ -329,9 +331,9 @@ async function acquireConfigLock(timeoutMs = CONFIG_LOCK_TIMEOUT_MS) {
 
       // Recover from stale lock files left by crashed processes.
       try {
-        const stats = await fs.promises.stat(CONFIG_LOCK_PATH);
+        const stats = await fs.promises.stat(lockPath);
         if (Date.now() - stats.mtimeMs > CONFIG_LOCK_STALE_MS) {
-          await fs.promises.unlink(CONFIG_LOCK_PATH);
+          await fs.promises.unlink(lockPath);
           continue;
         }
       } catch (_) {
@@ -355,7 +357,7 @@ async function acquireConfigLock(timeoutMs = CONFIG_LOCK_TIMEOUT_MS) {
       // Best-effort close only.
     }
     try {
-      await fs.promises.unlink(CONFIG_LOCK_PATH);
+      await fs.promises.unlink(lockPath);
     } catch (_) {
       // Best-effort cleanup only.
     }
@@ -382,9 +384,12 @@ function resetRecursionGuard() {
 }
 
 function ensureProjectSettingsDir() {
-  // Only create settings directory within the package, not in user projects
-  // Since PROJECT_SETTINGS_DIR is now set to package internals, no action needed
-  // if directory doesn't exist, we'll use package defaults
+  const settingsDir = path.dirname(getProjectConfigPath());
+  try {
+    fs.mkdirSync(settingsDir, { recursive: true });
+  } catch (_) {
+    // Directory may already exist or be unwritable
+  }
 }
 
 function normalizePathValue(keyPath, value) {
@@ -457,7 +462,8 @@ function tryReadJson(filePath) {
 
 async function migrateLegacyIfNeeded(baseCfg) {
   // If project config does not exist but legacy exists, migrate once
-  if (!SecurityUtils.safeExistsSync(PROJECT_CONFIG_PATH) && SecurityUtils.safeExistsSync(LEGACY_CONFIG_PATH)) {
+  const configPath = getProjectConfigPath();
+  if (!SecurityUtils.safeExistsSync(configPath) && SecurityUtils.safeExistsSync(LEGACY_CONFIG_PATH)) {
     const legacy = tryReadJson(LEGACY_CONFIG_PATH);
     if (legacy && typeof legacy === 'object') {
       const merged = deepMerge(clone(baseCfg), legacy);
@@ -465,9 +471,9 @@ async function migrateLegacyIfNeeded(baseCfg) {
       try { merged.migrationComplete = true; } catch (_) {}
       ensureProjectSettingsDir();
       try {
-        await fs.promises.writeFile(PROJECT_CONFIG_PATH, JSON.stringify(merged, null, 2), 'utf8');
+        await fs.promises.writeFile(configPath, JSON.stringify(merged, null, 2), 'utf8');
         // Best-effort removal of legacy file to prevent future use
-        try { fs.unlinkSync(LEGACY_CONFIG_PATH); } catch (_) {}
+        try { SecurityUtils.safeUnlinkSync(LEGACY_CONFIG_PATH, path.dirname(LEGACY_CONFIG_PATH)); } catch (_) {}
         // Deprecation notice
         logWarn('[i18ntk] Deprecated config location detected (~/.i18ntk). Configuration was migrated to project .i18ntk-config.');
         return merged;
@@ -503,8 +509,9 @@ function loadConfig() {
 
     try {
       let cfg = clone(DEFAULT_CONFIG);
+   const configPath = getProjectConfigPath();
    // 1) Project config (primary)
-   const projectCfg = tryReadJson(PROJECT_CONFIG_PATH);
+   const projectCfg = tryReadJson(configPath);
    if (projectCfg) {
      cfg = deepMerge(clone(DEFAULT_CONFIG), projectCfg);
    } else {
@@ -557,8 +564,10 @@ async function saveConfig(cfg = currentConfig) {
     let tempPath = null;
     let releaseLock = null;
     try {
+      const settingsDir = path.dirname(getProjectConfigPath());
+      const configFilePath = getProjectConfigPath();
       // Ensure settings directory exists before any lock/file operations.
-      await fs.promises.mkdir(PROJECT_SETTINGS_DIR, { recursive: true });
+      await fs.promises.mkdir(settingsDir, { recursive: true });
 
       releaseLock = await acquireConfigLock();
 
@@ -572,16 +581,16 @@ async function saveConfig(cfg = currentConfig) {
       // Use a simpler naming pattern to avoid triggering security warnings
       const nonce = `${process.pid}.${Date.now()}`;
       const tempFileName = `.i18ntk-config.temp-${nonce}`;
-      tempPath = path.join(PROJECT_SETTINGS_DIR, tempFileName);
+      tempPath = path.join(settingsDir, tempFileName);
       await fs.promises.writeFile(tempPath, serialized, 'utf8');
 
       try {
-        await fs.promises.rename(tempPath, PROJECT_CONFIG_PATH);
+        await fs.promises.rename(tempPath, configFilePath);
       } catch (renameError) {
         // If destination dir disappeared between checks, recreate and retry once.
         if (renameError && renameError.code === 'ENOENT') {
-          await fs.promises.mkdir(PROJECT_SETTINGS_DIR, { recursive: true });
-          await fs.promises.rename(tempPath, PROJECT_CONFIG_PATH);
+          await fs.promises.mkdir(settingsDir, { recursive: true });
+          await fs.promises.rename(tempPath, configFilePath);
         } else {
           throw renameError;
         }
@@ -598,9 +607,7 @@ async function saveConfig(cfg = currentConfig) {
       }
       if (tempPath) {
         try {
-          if (SecurityUtils.safeExistsSync(tempPath, path.dirname(tempPath))) {
-            fs.unlinkSync(tempPath);
-          }
+          SecurityUtils.safeUnlinkSync(tempPath, path.dirname(tempPath));
         } catch (_) {
           // Best-effort temp cleanup only.
         }
@@ -622,17 +629,19 @@ function getConfig() {
     }
 
    try {
+     const configPath = getProjectConfigPath();
+     const settingsDir = path.dirname(configPath);
      // Ensure settings directory exists
-     if (!SecurityUtils.safeExistsSync(PROJECT_SETTINGS_DIR)) {
-       fs.mkdirSync(PROJECT_SETTINGS_DIR, { recursive: true });
+     if (!SecurityUtils.safeExistsSync(settingsDir)) {
+       fs.mkdirSync(settingsDir, { 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');
+     if (SecurityUtils.safeExistsSync(configPath)) {
+       const rawConfig = SecurityUtils.safeReadFileSync(configPath, settingsDir, 'utf8');
        const config = SecurityUtils.safeParseJSON(rawConfig);
        if (config && typeof config === 'object') {
          currentConfig = config;
@@ -655,15 +664,15 @@ function getConfig() {
        });
        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
-       }
+        // Clean up legacy config
+        try {
+          SecurityUtils.safeUnlinkSync(LEGACY_CONFIG_PATH, path.dirname(LEGACY_CONFIG_PATH));
+          if (SecurityUtils.safeReaddirSync(LEGACY_CONFIG_DIR, path.dirname(LEGACY_CONFIG_DIR)).length === 0) {
+            SecurityUtils.safeRmdirSync(LEGACY_CONFIG_DIR, path.dirname(LEGACY_CONFIG_DIR));
+          }
+        } catch (cleanupError) {
+          // Ignore cleanup errors
+        }
 
        return resolvePaths(migratedConfig);
      }
@@ -706,7 +715,7 @@ function resolvePaths(cfg) {
     if (!cfg) {
       cfg = clone(DEFAULT_CONFIG);
     }
-   const root = path.resolve(projectRoot, cfg.projectRoot || '.');
+   const root = path.resolve(getUserProjectRoot(), cfg.projectRoot || '.');
    const resolved = clone(cfg);
    resolved.projectRoot = root;
    ['sourceDir', 'i18nDir', 'outputDir'].forEach(key => {
@@ -723,7 +732,7 @@ function resolvePaths(cfg) {
 
 function toRelative(absPath) {
    if (!absPath) return absPath;
-   const rel = path.relative(projectRoot, absPath);
+   const rel = path.relative(getUserProjectRoot(), absPath);
    const normalized = rel ? `./${rel.replace(/\\/g, '/')}` : '.';
    return normalized;
 }
@@ -731,7 +740,7 @@ function toRelative(absPath) {
 
 
 module.exports = {
-  CONFIG_PATH,
+  get CONFIG_PATH() { return getProjectConfigPath(); },
   DEFAULT_CONFIG,
   loadConfig,
   saveConfig,
@@ -742,6 +751,7 @@ module.exports = {
   resolvePaths,
   toRelative,
   normalizePathValue,
+  migrateLegacyIfNeeded,
 }
 
 

package/utils/config.js

@@ -85,16 +85,25 @@ function saveConfig(config, cwd = settingsManager.configDir) {
     const dir = path.dirname(configPath);
     
     // Ensure directory exists
-    if (!SecurityUtils.safeExistsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (!SecurityUtils.safeExistsSync(dir, settingsManager.configDir)) {
+      SecurityUtils.safeMkdirSync(dir, settingsManager.configDir, { recursive: true, mode: 0o700 });
     }
     
     // Write file with secure permissions (read/write for owner only)
-    SecurityUtils.safeWriteFileSync(
+    const written = SecurityUtils.safeWriteFileSync(
       configPath,
       JSON.stringify(config, null, 2),
-      { mode: 0o600, encoding: 'utf8' }
+      dir,
+      'utf8'
     );
+    if (!written) {
+      throw new Error('Failed to write configuration file');
+    }
+    try {
+      fs.chmodSync(configPath, 0o600);
+    } catch (_) {
+      // Best-effort: permissions are a hardening measure, not required
+    }
     
     return true;
   } catch (error) {

package/utils/env-manager.js

@@ -258,7 +258,9 @@ class EnvironmentManager {
 
   getBoolean(name) {
     const value = this.get(name);
-    return value === true || value === 'true' || value === '1';
+    if (typeof value === 'boolean') return value;
+    if (value === 'true' || value === '1' || value === 'yes') return true;
+    return false;
   }
 
   /**

package/utils/i18n-helper.js

@@ -11,26 +11,53 @@ function getSecurityUtils() {
     try {
       securityUtils = require('./security');
     } catch (error) {
-      // Fallback: use basic fs operations if SecurityUtils is not available
+      // Fallback: use basic fs operations with path containment
+      const path = require('path');
+      const fallbackBase = path.resolve(__dirname, '..');
       return {
-        safeExistsSync: (targetPath) => {
+        safeExistsSync: (targetPath, basePath) => {
           try {
-            require('fs').accessSync(targetPath);
+            const resolved = path.resolve(basePath || fallbackBase, targetPath);
+            if (!resolved.startsWith(path.resolve(basePath || fallbackBase))) {
+              return false;
+            }
+            require('fs').accessSync(resolved);
             return true;
           } catch {
             return false;
           }
         },
-        safeWriteFileSync: (targetPath, data, _basePath, encoding = 'utf8') => {
+        safeWriteFileSync: (targetPath, data, basePath, encoding = 'utf8') => {
+          try {
+            const resolved = path.resolve(basePath || fallbackBase, targetPath);
+            if (!resolved.startsWith(path.resolve(basePath || fallbackBase))) {
+              return null;
+            }
+            require('fs').mkdirSync(path.dirname(resolved), { recursive: true });
+            require('fs').writeFileSync(resolved, data, encoding);
+            return true;
+          } catch {
+            return null;
+          }
+        },
+        safeReadFileSync: (targetPath, basePath, encoding = 'utf8') => {
           try {
-            return require('fs').writeFileSync(targetPath, data, encoding);
+            const resolved = path.resolve(basePath || fallbackBase, targetPath);
+            if (!resolved.startsWith(path.resolve(basePath || fallbackBase))) {
+              return null;
+            }
+            return require('fs').readFileSync(resolved, encoding);
           } catch {
             return null;
           }
         },
-        safeReadFileSync: (targetPath, _basePath, encoding = 'utf8') => {
+        safeStatSync: (targetPath, basePath) => {
           try {
-            return require('fs').readFileSync(targetPath, encoding);
+            const resolved = path.resolve(basePath || fallbackBase, targetPath);
+            if (!resolved.startsWith(path.resolve(basePath || fallbackBase))) {
+              return null;
+            }
+            return require('fs').statSync(resolved);
           } catch {
             return null;
           }
@@ -68,7 +95,8 @@ function getValidationBase(targetPath) {
   let current = path.resolve(path.dirname(targetPath));
   while (true) {
     try {
-      if (fs.statSync(current).isDirectory()) {
+      const stat = getSecurityUtils().safeStatSync(current, current);
+      if (stat && stat.isDirectory()) {
         return current;
       }
     } catch {
@@ -175,8 +203,6 @@ function findLocaleFilesAllDirs(lang, preferredDir) {
       try {
         const stats = SecurityUtils.safeStatSync(candidate, getValidationBase(candidate));
         if (stats && stats.isFile() && stats.size > 0) {
-            // Validate file is readable and parseable
-            fs.accessSync(candidate, fs.constants.R_OK);
             // Quick JSON validation
             const content = safeReadFile(candidate, 'utf8');
             if (content) {
@@ -413,10 +439,12 @@ function getAvailableLanguages() {
     try {
       const SecurityUtils = getSecurityUtils();
       if (!SecurityUtils.safeExistsSync(d, getValidationBase(d))) continue;
-      for (const f of fs.readdirSync(d)) {
-        if (f.endsWith('.json')) langs.add(path.basename(f, '.json'));
+      const files = SecurityUtils.safeReaddirSync(d, getValidationBase(d), { withFileTypes: true });
+      if (!files) continue;
+      for (const f of files) {
+        if (f.isFile() && f.name.endsWith('.json')) langs.add(path.basename(f.name, '.json'));
       }
-      for (const f of fs.readdirSync(d, { withFileTypes: true })) {
+      for (const f of files) {
         const nestedPath = path.join(d, f.name, `${f.name}.json`);
         if (f.isDirectory() && SecurityUtils.safeExistsSync(nestedPath, getValidationBase(nestedPath))) {
           langs.add(f.name);

package/utils/init-helper.js

@@ -4,11 +4,11 @@ const configManager = require('./config-manager');
 const SecurityUtils = require('./security');
 const packageJson = require('../package.json');
 
-function ensureDirectory(dirPath) {
-  if (!dirPath || typeof dirPath !== 'string') return;
-  if (!SecurityUtils.safeExistsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
+function ensureDirectory(dirPath) {
+  if (!dirPath || typeof dirPath !== 'string') return;
+  if (!SecurityUtils.safeExistsSync(dirPath, process.cwd())) {
+    SecurityUtils.safeMkdirSync(dirPath, process.cwd(), { recursive: true });
+  }
 }
 
 function readJsonSafe(filePath) {
@@ -22,22 +22,24 @@ function readJsonSafe(filePath) {
   }
 }
 
-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);
+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, process.cwd())) {
+    try {
+      const stat = SecurityUtils.safeStatSync(modularLanguageDir, process.cwd());
+      if (stat && stat.isDirectory()) {
+        const items = SecurityUtils.safeReaddirSync(modularLanguageDir, process.cwd(), { withFileTypes: true });
+        return items ? items.some(item => item.isFile() && item.name.endsWith('.json')) : false;
+      }
+    } catch {
+      // Continue with single-file fallback.
+    }
+  }
+
+  return SecurityUtils.safeExistsSync(singleLanguageFile, process.cwd());
 }
 
 /**

package/utils/secure-errors.js

@@ -78,11 +78,14 @@ function secureErrorHandler(options = {}) {
   const config = { ...defaults, ...options };
   
   // Ensure log directory exists
-  if (config.logFilePath && !SecurityUtils.safeExistsSync(path.dirname(config.logFilePath))) {
-    try {
-      fs.mkdirSync(path.dirname(config.logFilePath), { recursive: true });
-    } catch (e) {
-      console.error('Failed to create log directory:', e);
+  if (config.logFilePath) {
+    const logDir = path.dirname(config.logFilePath);
+    if (!SecurityUtils.safeExistsSync(logDir, process.cwd())) {
+      try {
+        SecurityUtils.safeMkdirSync(logDir, process.cwd(), { recursive: true });
+      } catch (e) {
+        console.error('Failed to create log directory:', e);
+      }
     }
   }
 
@@ -128,7 +131,7 @@ function secureErrorHandler(options = {}) {
 
       // Log to console
       if (typeof config.logFunction === 'function') {
-        SecurityUtils.safeWriteFileSync(config.logFilePath, JSON.stringify(logEntry, null, 2));
+        config.logFunction(logEntry);
       }
 
       // Log to file if configured
@@ -136,6 +139,7 @@ function secureErrorHandler(options = {}) {
         SecurityUtils.safeWriteFileSync(
           config.logFilePath,
           JSON.stringify(logEntry) + '\n',
+          path.dirname(config.logFilePath),
           'utf8'
         );
       }

package/utils/security.js

@@ -299,7 +299,7 @@ static _logging = false;
 
       // Check for actual path traversal (going outside the base directory)
       const relativePath = path.relative(base, finalPath);
-      if (relativePath === '..' || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+      if (relativePath.startsWith('..')) {
         const message = useI18n
           ? i18n.t('security.pathTraversalAttempt')
           : 'Path traversal attempt';
@@ -474,6 +474,32 @@ static _logging = false;
     }
   }
 
+  static safeUnlinkSync(filePath, basePath) {
+    const validatedPath = this.validatePath(filePath, basePath);
+    if (!validatedPath) {
+      return false;
+    }
+    try {
+      fs.unlinkSync(validatedPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static safeRmdirSync(dirPath, basePath) {
+    const validatedPath = this.validatePath(dirPath, basePath);
+    if (!validatedPath) {
+      return false;
+    }
+    try {
+      fs.rmdirSync(validatedPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Safely parse JSON content.
    * Accepts both raw JSON strings and already-parsed objects.
@@ -486,8 +512,8 @@ static _logging = false;
       return fallback;
     }
 
-    if (typeof input === 'object') {
-      return input;
+    if (typeof input === 'object' && !Array.isArray(input)) {
+      return JSON.parse(JSON.stringify(input));
     }
 
     if (typeof input !== 'string') {
@@ -571,7 +597,7 @@ static _logging = false;
   const relativePath = path.relative(resolvedBase, resolvedPath);
   
   // Ensure the final path is within the base directory
-  if (relativePath === '..' || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+  if (relativePath.startsWith('..')) {
   SecurityUtils.logSecurityEvent('Path traversal attempt detected in safeJoin', 'error', {
   basePath,
   paths,

package/utils/setup-enforcer.js

@@ -271,84 +271,73 @@ static async handleInvalidConfig() {
 
         // Create new promise and store it
         SetupEnforcer._setupCheckInProgress = true;
-        SetupEnforcer._setupCheckPromise = new Promise(async (resolve, reject) => {
-             try {
-                 // Avoid circular dependency - use direct path resolution
-                 const path = require('path');
-                 const configPath = path.join(process.cwd(), '.i18ntk-config');
+        SetupEnforcer._setupCheckPromise = (async () => {
+            try {
+                // Avoid circular dependency - use direct path resolution
+                const pathModule = require('path');
+                const configPath = pathModule.join(process.cwd(), '.i18ntk-config');
                 const exists = SecurityUtils.safeExistsSync(configPath);
                 if (!exists) {
                     await SetupEnforcer.handleMissingSetup();
-                    // After setup is done, re-check the config
                     const existsAfter = SecurityUtils.safeExistsSync(configPath);
                     if (existsAfter) {
-                        resolve(true);
-                    } else {
-                        process.exit(0);
+                        return true;
                     }
-                    return;
+                    process.exit(0);
                 }
 
                 try {
-                    const configRaw = SecurityUtils.safeReadFileSync(configPath, path.dirname(configPath), 'utf8');
+                    const configRaw = SecurityUtils.safeReadFileSync(configPath, pathModule.dirname(configPath), 'utf8');
                     const config = SecurityUtils.safeParseJSON(configRaw);
                     if (!config || typeof config !== 'object') {
                         await SetupEnforcer.handleInvalidConfig();
                         process.exit(0);
                     }
-                    
-                    // Check if setup has been explicitly marked as completed
+
                     if (config.setup && config.setup.completed === true) {
-                        resolve(true);
-                        return;
+                        return true;
                     }
-                    
-                    // Fallback: check if config has required fields (for backward compatibility)
+
                     if (!config.version || !config.sourceDir || (!config.detectedFramework && !(config.framework && config.framework.detected !== false))) {
                         await SetupEnforcer.handleIncompleteSetup();
-                        // After setup is done, re-check the config
-                        const newConfigRaw = SecurityUtils.safeReadFileSync(configPath, path.dirname(configPath), 'utf8');
+                        const newConfigRaw = SecurityUtils.safeReadFileSync(configPath, pathModule.dirname(configPath), 'utf8');
                         const newConfig = SecurityUtils.safeParseJSON(newConfigRaw);
                         if (!newConfig || typeof newConfig !== 'object') {
                             process.exit(0);
                         }
                         if (newConfig.setup && newConfig.setup.completed === true) {
-                            resolve(true);
+                            return true;
                         } else if (newConfig.version && newConfig.sourceDir && (newConfig.detectedFramework || (newConfig.framework && newConfig.framework.detected !== false))) {
-                            resolve(true);
-                        } else {
-                            process.exit(0);
+                            return true;
                         }
-                        return;
+                        process.exit(0);
                     }
 
-                    resolve(true);
+                    return true;
                 } catch (error) {
                     await SetupEnforcer.handleInvalidConfig();
-                    // After setup is done, re-check the config
                     try {
-                        const newConfigRaw = SecurityUtils.safeReadFileSync(configPath, path.dirname(configPath), 'utf8');
+                        const newConfigRaw = SecurityUtils.safeReadFileSync(configPath, pathModule.dirname(configPath), 'utf8');
                         const newConfig = SecurityUtils.safeParseJSON(newConfigRaw);
                         if (!newConfig || typeof newConfig !== 'object') {
                             process.exit(0);
                         }
                         if (newConfig.setup && newConfig.setup.completed === true) {
-                            resolve(true);
+                            return true;
                         } else if (newConfig.version && newConfig.sourceDir && (newConfig.detectedFramework || (newConfig.framework && newConfig.framework.detected !== false))) {
-                            resolve(true);
-                        } else {
-                            process.exit(0);
+                            return true;
                         }
+                        process.exit(0);
                     } catch (e) {
                         process.exit(0);
                     }
                 }
             } catch (error) {
-                reject(error);
+                throw error;
             } finally {
                 SetupEnforcer._setupCheckInProgress = false;
             }
-        });
+        })();
 
         return SetupEnforcer._setupCheckPromise;
     }