Merge development into main, keeping development changes for conflicts

Author: 1minds3t

src/omnipkg/__main__.py

@@ -1,24 +1,28 @@
 from __future__ import annotations
-
 from omnipkg.common_utils import safe_print
-
 try:
     from .common_utils import safe_print
 except ImportError:
     pass
 
 import sys
+import os
 
 from .cli import main
-from .core import ConfigManager  # ← Import from core, not config_manager
-from .i18n import _  # ← Import the translator instance, not setup_i18n
+from .core import ConfigManager
+from .i18n import _
 
 # Initialize the config manager
 config_manager = ConfigManager()
 
-# Set the language from config
-# The _ translator has a set_language method
-_.set_language(config_manager.config.get("language", "en"))
+# Language priority: OMNIPKG_LANG env var > config file > default (en)
+language = os.environ.get("OMNIPKG_LANG") or config_manager.config.get("language", "en")
+
+# Set the language in the translator
+_.set_language(language)
+
+# ⚠️ CRITICAL: Set in os.environ so subprocesses inherit it!
+os.environ["OMNIPKG_LANG"] = language  # ← ADD THIS LINE IF MISSING!
 
 # This runs the main function and ensures the script exits with the correct status code.
 if __name__ == "__main__":

src/omnipkg/apis/local_bridge.py

@@ -551,13 +551,13 @@ def telemetry():
 def run_bridge_server():
     """The entry point for the background process."""
     if not HAS_WEB_DEPS:
-        print(_('❌ Flask missing. Cannot start server.'))
+        safe_print(_('❌ Flask missing. Cannot start server.'))
         sys.exit(1)
 
     try:
         port = find_free_port(5000)
     except RuntimeError as e:
-        print(_('❌ {}').format(e))
+        safe_print(_('❌ {}').format(e))
         sys.exit(1)
 
     print(_('Local Port: {}').format(port), flush=True)
@@ -580,16 +580,16 @@ def __init__(self):
     def start(self):
         """Start the web bridge in background."""
         if not HAS_WEB_DEPS:
-            print(_('❌ Dependencies missing. Please run: pip install flask flask-cors'))
+            safe_print(_('❌ Dependencies missing. Please run: pip install flask flask-cors'))
             return 1
 
         if self.is_running():
             port = self._get_port()
-            print(_('✅ Web bridge already running on port {}').format(port))
-            print(_('🌍 Dashboard: {}#{}').format(PRIMARY_DASHBOARD, port))
+            safe_print(_('✅ Web bridge already running on port {}').format(port))
+            safe_print(_('🌍 Dashboard: {}#{}').format(PRIMARY_DASHBOARD, port))
             return 0
 
-        print(_('🚀 Starting web bridge...'))
+        safe_print(_('🚀 Starting web bridge...'))
         cmd = [sys.executable, "-m", "omnipkg.apis.local_bridge"]
 
         # Cross-platform detachment logic
@@ -616,29 +616,29 @@ def start(self):
                 port = self._get_port()
                 url = f"{PRIMARY_DASHBOARD}#{port}"
                 print("="*60)
-                print(_('✅ Web bridge started successfully'))
-                print(_('🔗 Local Port: {}').format(port))
-                print(_('📊 PID: {}').format(process.pid))
-                print(_('🌍 Dashboard: {}').format(url))
+                safe_print(_('✅ Web bridge started successfully'))
+                safe_print(_('🔗 Local Port: {}').format(port))
+                safe_print(_('📊 PID: {}').format(process.pid))
+                safe_print(_('🌍 Dashboard: {}').format(url))
                 print("="*60)
                 webbrowser.open(url)
                 return 0
             else:
-                print(_('❌ Failed to start. Check logs.'))
+                safe_print(_('❌ Failed to start. Check logs.'))
                 return 1
         except Exception as e:
-            print(_('❌ Launch error: {}').format(e))
+            safe_print(_('❌ Launch error: {}').format(e))
             return 1
 
     def stop(self):
         """Stop the web bridge safely across platforms."""
         if not self.is_running():
-            print(_('⚠️  Web bridge is not running'))
+            safe_print(_('⚠️  Web bridge is not running'))
             return 0
 
         try:
             pid = int(self.pid_file.read_text())
-            print(_('🛑 Stopping web bridge (PID: {})...').format(pid))
+            safe_print(_('🛑 Stopping web bridge (PID: {})...').format(pid))
 
             if os.name == 'nt':
                 subprocess.run(["taskkill", "/PID", str(pid), "/T", "/F"], 
@@ -651,33 +651,33 @@ def stop(self):
 
             if self.pid_file.exists(): 
                 self.pid_file.unlink()
-            print(_('✅ Web bridge stopped'))
+            safe_print(_('✅ Web bridge stopped'))
             return 0
         except Exception as e:
-            print(_('❌ Error stopping: {}').format(e))
+            safe_print(_('❌ Error stopping: {}').format(e))
             if self.pid_file.exists(): 
                 self.pid_file.unlink()
             return 1
 
     def restart(self):
         """Restart the web bridge."""
-        print(_('🔄 Restarting web bridge...'))
+        safe_print(_('🔄 Restarting web bridge...'))
         self.stop()
         time.sleep(1)
         return self.start()
 
     def status(self):
         """Check web bridge status."""
         if not self.is_running():
-            print(_('❌ Web bridge is not running'))
-            print(_('\n💡 Start with: 8pkg web start'))
+            safe_print(_('❌ Web bridge is not running'))
+            safe_print(_('\n💡 Start with: 8pkg web start'))
             return 1
 
         if not HAS_SYS_DEPS:
-            print(_("⚠️  'psutil' not installed. Limited status info available."))
+            safe_print(_("⚠️  'psutil' not installed. Limited status info available."))
             pid = int(self.pid_file.read_text())
             port = self._get_port()
-            print(_('✅ Running (PID: {}, Port: {})').format(pid, port))
+            safe_print(_('✅ Running (PID: {}, Port: {})').format(pid, port))
             return 0
 
         pid = int(self.pid_file.read_text())
@@ -689,28 +689,28 @@ def status(self):
             uptime = time.time() - process.create_time()
 
             print("="*60)
-            print(_('✅ Web Bridge Status: RUNNING'))
+            safe_print(_('✅ Web Bridge Status: RUNNING'))
             print("="*60)
-            print(_('🔗 Port:        {}').format(port))
-            print(_('📊 PID:         {}').format(pid))
-            print(f"💾 Memory:      {mem_info.rss / 1024 / 1024:.1f} MB")
-            print(_('⏱️  Uptime:      {}').format(self._format_uptime(uptime)))
-            print(_('🌍 Dashboard:   {}#{}').format(PRIMARY_DASHBOARD, port))
+            safe_print(_('🔗 Port:        {}').format(port))
+            safe_print(_('📊 PID:         {}').format(pid))
+            safe_print(f"💾 Memory:      {mem_info.rss / 1024 / 1024:.1f} MB")
+            safe_print(_('⏱️  Uptime:      {}').format(self._format_uptime(uptime)))
+            safe_print(_('🌍 Dashboard:   {}#{}').format(PRIMARY_DASHBOARD, port))
             print("="*60)
             return 0
         except psutil.NoSuchProcess:
-            print(_('⚠️  PID file exists but process is dead. Cleaning up...'))
+            safe_print(_('⚠️  PID file exists but process is dead. Cleaning up...'))
             self.pid_file.unlink()
             return 1
 
     def show_logs(self, follow=False, lines=50):
         """Display web bridge logs."""
         if not self.log_file.exists():
-            print(_('❌ Log file not found: {}').format(self.log_file))
+            safe_print(_('❌ Log file not found: {}').format(self.log_file))
             return 1
 
         if follow:
-            print(_('📝 Following logs (Ctrl+C to stop)...\n'))
+            safe_print(_('📝 Following logs (Ctrl+C to stop)...\n'))
             try:
                 subprocess.run(["tail", "-f", str(self.log_file)], check=True)
             except (FileNotFoundError, subprocess.CalledProcessError):
@@ -727,7 +727,7 @@ def show_logs(self, follow=False, lines=50):
                     pass
             except KeyboardInterrupt:
                 pass
-            print(_('\n✅ Stopped following logs'))
+            safe_print(_('\n✅ Stopped following logs'))
             return 0
         else:
             try:

src/omnipkg/cli.py

@@ -2,6 +2,7 @@
 
 from omnipkg.common_utils import safe_print
 
+from omnipkg.i18n import _, SUPPORTED_LANGUAGES
 """omnipkg CLI - Enhanced with runtime interpreter switching and language support"""
 try:
     from .common_utils import safe_print
@@ -33,7 +34,6 @@
 from .common_utils import print_header
 from .core import ConfigManager
 from .core import omnipkg as OmnipkgCore
-from omnipkg.i18n import _, SUPPORTED_LANGUAGES
 
 project_root = Path(__file__).resolve().parent.parent
 TESTS_DIR = Path(__file__).parent.parent / "tests"
@@ -884,7 +884,7 @@ def main():
                 sys.argv.insert(2, forced_version)
 
                 if os.environ.get("OMNIPKG_DEBUG") == "1":
-                    print(f"[DEBUG-CLI] Detected: {prog_name} -> forcing --python {forced_version}", file=sys.stderr)
+                    print(_('[DEBUG-CLI] Detected: {} -> forcing --python {}').format(prog_name, forced_version), file=sys.stderr)
 
         # 🎪 NORMALIZE FLAGS AND COMMANDS (but not package names)
         normalized_argv = [sys.argv[0]]
@@ -917,11 +917,27 @@ def main():
             # Always show "omnipkg" - 8pkg is just an alias
             safe_print(_("omnipkg {}").format(get_version()))
             return 0
+        # BEFORE creating ConfigManager
+        os.environ["OMNIPKG_LANG"] = os.environ.get("OMNIPKG_LANG", "")
+
+        cm = ConfigManager()
+        user_lang = global_args.lang or cm.config.get("language") or os.environ.get("OMNIPKG_LANG")
 
         cm = ConfigManager()
         user_lang = global_args.lang or cm.config.get("language")
+
+        # NEW: Check environment variable first (highest priority)
+        if not user_lang:
+            user_lang = os.environ.get("OMNIPKG_LANG")
+
         if user_lang:
+            # Force re-import to pick up env var
+            import importlib
+            from omnipkg import i18n
+            importlib.reload(i18n)
+            
             _.set_language(user_lang)
+            os.environ["OMNIPKG_LANG"] = user_lang
 
         # --- DECIDE MINIMAL VS FULL INITIALIZATION ---
         use_minimal = False
@@ -1238,23 +1254,23 @@ def main():
 
                         try:
                             if os.environ.get("OMNIPKG_DEBUG") == "1":
-                                safe_print(f"[DEBUG] Spawning shell: {shell}")
-                                safe_print(f"[DEBUG] Target Python: {python_path}")
-                                safe_print(f"[DEBUG] OMNIPKG_PYTHON: {version}")
-                                safe_print(f"[DEBUG] OMNIPKG_VENV_ROOT: {original_venv}")
-                                safe_print(f"[DEBUG] Shims directory: {shims_dir}")
-                                safe_print(f"[DEBUG] PATH prefix: {deduped[0]}")
-                                safe_print(f"[DEBUG] Cleanup script: {cleanup_file}")
-                                safe_print(f"[DEBUG] CONDA_PREFIX: {new_env.get('CONDA_PREFIX', 'NOT SET')}")
-                                safe_print(f"[DEBUG] CONDA_DEFAULT_ENV: {new_env.get('CONDA_DEFAULT_ENV', 'NOT SET')}")
+                                safe_print(_('[DEBUG] Spawning shell: {}').format(shell))
+                                safe_print(_('[DEBUG] Target Python: {}').format(python_path))
+                                safe_print(_('[DEBUG] OMNIPKG_PYTHON: {}').format(version))
+                                safe_print(_('[DEBUG] OMNIPKG_VENV_ROOT: {}').format(original_venv))
+                                safe_print(_('[DEBUG] Shims directory: {}').format(shims_dir))
+                                safe_print(_('[DEBUG] PATH prefix: {}').format(deduped[0]))
+                                safe_print(_('[DEBUG] Cleanup script: {}').format(cleanup_file))
+                                safe_print(_('[DEBUG] CONDA_PREFIX: {}').format(new_env.get('CONDA_PREFIX', 'NOT SET')))
+                                safe_print(_('[DEBUG] CONDA_DEFAULT_ENV: {}').format(new_env.get('CONDA_DEFAULT_ENV', 'NOT SET')))
 
                             safe_print(_("🐚 Spawning new shell... (Type 'exit' to return)"))
                             safe_print(f"   🐍 Python {version} context active (via shims)")
-                            safe_print(f"   💡 Note: Type 'exit' to clean up and return")
+                            safe_print(_("   💡 Note: Type 'exit' to clean up and return"))
 
                             conda_env = os.environ.get("CONDA_DEFAULT_ENV", "")
                             if conda_env:
-                                safe_print(f"   📦 Conda env '{conda_env}' preserved")
+                                safe_print(_("   📦 Conda env '{}' preserved").format(conda_env))
 
                             # Launch interactive shell
                             os.execle(

src/omnipkg/commands/run.py

@@ -2624,6 +2624,11 @@ def execute_run_command(
     # ADD THIS LINE - Propagate verbose flag to subprocesses
     if verbose:
         os.environ["OMNIPKG_VERBOSE"] = "1"
+    
+    # NEW: Ensure language persists to subprocess
+    current_lang = config_manager.config.get("language")
+    if current_lang:
+        os.environ["OMNIPKG_LANG"] = current_lang
 
     if not cmd_args:
         safe_print(_("❌ Error: No script or command specified to run."))