Add conversation persistence and enhanced machine-bound key encryption

Author: BlackTechX011

hacxgpt/config.py

@@ -2,7 +2,8 @@
 import os
 import sys
 import json
-from dotenv import load_dotenv
+from dotenv import load_dotenv, set_key
+from .utils.security import Security
 
 class Config:
     """System Configuration & Constants"""
@@ -20,8 +21,7 @@ class Config:
     DEFAULT_PROVIDER = "hacxgpt"
 
     # System Paths
-    ENV_FILE = ".hacx"
-    API_KEY_NAME = "HacxGPT-API" # Legacy/Default
+    ENV_FILE = os.path.join(os.path.expanduser("~"), ".hacx")
     CODE_OUTPUT_DIR = "hacxgpt_code_output"
 
     # Visual Theme
@@ -81,6 +81,20 @@ def get_model(cls):
     def get_provider_config(cls, provider=None):
         p = provider or cls.get_provider()
         return cls.PROVIDERS.get(p, cls.PROVIDERS.get(cls.DEFAULT_PROVIDER, {}))
+        
+    @classmethod
+    def get_api_key(cls, provider: str = None) -> str:
+        """Retrieves and decrypts the API key for the specified provider."""
+        p_cfg = cls.get_provider_config(provider)
+        key_var = p_cfg.get("key_var")
+        if not key_var: return ""
+        
+        # Reload env to get latest values
+        load_dotenv(cls.ENV_FILE, override=True)
+        encrypted_key = os.getenv(key_var, "")
+        if not encrypted_key: return ""
+        
+        return Security.decrypt(encrypted_key)
 
     @staticmethod
     def is_hacxgpt_model(model_name: str) -> bool:
@@ -105,14 +119,14 @@ def initialize():
         """Initialize environment (load .env, load configuration, etc)"""
         Config.load_providers()
 
-        # Look for .hacx in current directory or user home
-        env_path = Config.ENV_FILE
-        if not os.path.exists(env_path):
-            user_env = os.path.join(os.path.expanduser("~"), Config.ENV_FILE)
-            if os.path.exists(user_env):
-                env_path = user_env
+        # Support migration: if .hacx exists locally but NOT in home, copy it to home
+        local_env = ".hacx"
+        if os.path.exists(local_env) and not os.path.exists(Config.ENV_FILE):
+             import shutil
+             shutil.copy(local_env, Config.ENV_FILE)
+             # print(f"Migration: Copied {local_env} to {Config.ENV_FILE}")
 
-        load_dotenv(dotenv_path=env_path, override=True)
+        load_dotenv(dotenv_path=Config.ENV_FILE, override=True)
 
         # Load last used provider/model if saved in env
         saved_provider = os.getenv("HACX_ACTIVE_PROVIDER")

hacxgpt/core/brain.py

@@ -1,5 +1,8 @@
 import sys
-from typing import Generator
+import os
+import json
+import time
+from typing import Generator, List
 from ..config import Config
 from ..ui.interface import UI 
 from .api import Client
@@ -12,6 +15,10 @@ def __init__(self, api_key: str):
         self.api_key = api_key
         self.model = Config.get_model()
         self.system_prompt = Config.load_system_prompt()
+        self.session_dir = os.path.join(os.path.expanduser("~"), ".hacxgpt_sessions")
+        if not os.path.exists(self.session_dir):
+            os.makedirs(self.session_dir)
+            
         self._init_client()
 
         # HacxGPT models don't need the system prompt history
@@ -62,6 +69,42 @@ def reset(self):
             self.history = []
         else:
             self.history = [{"role": "system", "content": self.system_prompt}]
+            
+    def save_session(self, name: str) -> str:
+        """Save current history to a file"""
+        session_data = {
+            "model": self.model,
+            "provider": Config.ACTIVE_PROVIDER,
+            "history": self.history,
+            "timestamp": time.time()
+        }
+        filename = f"{name}.json"
+        filepath = os.path.join(self.session_dir, filename)
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(session_data, f, indent=4)
+        return filepath
+
+    def load_session(self, name: str) -> bool:
+        """Load history from a file"""
+        filename = f"{name}.json"
+        filepath = os.path.join(self.session_dir, filename)
+        if not os.path.exists(filepath):
+            return False
+        
+        with open(filepath, 'r', encoding='utf-8') as f:
+            session_data = json.load(f)
+            
+        self.history = session_data.get("history", [])
+        self.model = session_data.get("model", self.model)
+        Config.ACTIVE_PROVIDER = session_data.get("provider", Config.ACTIVE_PROVIDER)
+        Config.ACTIVE_MODEL = self.model
+        self._init_client()
+        return True
+
+    def list_sessions(self) -> List[str]:
+        """List all saved session names"""
+        sessions = [f.replace(".json", "") for f in os.listdir(self.session_dir) if f.endswith(".json")]
+        return sorted(sessions)
 
     def chat(self, user_input: str) -> Generator[str, None, None]:
         self.history.append({"role": "user", "content": user_input})

hacxgpt/main.py

@@ -10,6 +10,7 @@
 from .core.brain import HacxBrain
 from .utils.system import check_dependencies
 from .utils.updater import Updater
+from .utils.security import Security
 
 # Initialize Colorama
 colorama.init(autoreset=True)
@@ -30,9 +31,7 @@ def setup(self) -> bool:
         except:
             pass # Silent fail if offline
 
-        p_cfg = Config.get_provider_config()
-        key_var = p_cfg.get("key_var")
-        key = os.getenv(key_var)
+        key = Config.get_api_key()
 
         if not key:
             self.ui.banner()
@@ -96,7 +95,9 @@ def configure_key(self, provider: str = None) -> bool:
         if not os.path.exists(Config.ENV_FILE):
              with open(Config.ENV_FILE, 'w') as f: f.write("")
 
-        set_key(Config.ENV_FILE, key_var, key.strip())
+        # Encrypt the key before saving
+        encrypted_key = Security.encrypt(key.strip())
+        set_key(Config.ENV_FILE, key_var, encrypted_key)
         set_key(Config.ENV_FILE, "HACX_ACTIVE_PROVIDER", provider)
         set_key(Config.ENV_FILE, "HACX_ACTIVE_MODEL", selected_model)
 
@@ -139,12 +140,45 @@ def run_chat(self):
                         "/model <name> - Switch Model\n"
                         "/setup - Configure API Keys\n"
                         "/status - Show current config\n"
+                        "/save <name> - Save current session\n"
+                        "/load <name> - Load a saved session\n"
+                        "/sessions - List saved sessions\n"
                         "/new - Wipe Memory\n"
                         "/exit - Disconnect"
                     )
                     self.ui.show_msg("Help", help_text, "magenta")
                     continue
 
+                if prompt.lower().startswith('/save'):
+                    parts = prompt.split()
+                    if len(parts) < 2:
+                        self.ui.show_msg("Error", "Usage: /save <name>", "red")
+                        continue
+                    name = parts[1]
+                    path = self.brain.save_session(name)
+                    self.ui.show_msg("Session Saved", f"Neural state backed up to: {name}\n[dim]{path}[/]", "green")
+                    continue
+
+                if prompt.lower().startswith('/load'):
+                    parts = prompt.split()
+                    if len(parts) < 2:
+                        self.ui.show_msg("Error", "Usage: /load <name>", "red")
+                        continue
+                    name = parts[1]
+                    if self.brain.load_session(name):
+                        self.ui.show_msg("Session Restored", f"Neural state '{name}' re-established.", "green")
+                    else:
+                        self.ui.show_msg("Error", f"Session '{name}' not found.", "red")
+                    continue
+                
+                if prompt.lower() == '/sessions':
+                    sessions = self.brain.list_sessions()
+                    if not sessions:
+                        self.ui.show_msg("Sessions", "No saved neural states found.", "yellow")
+                    else:
+                        self.ui.show_msg("Saved Sessions", "\n".join([f"- {s}" for s in sessions]), "cyan")
+                    continue
+
                 if prompt.lower() == '/update':
                     self.ui.show_msg("System Update", "Initiating update process...", "cyan")
                     success, msg = Updater.update()

hacxgpt/utils/security.py

@@ -0,0 +1,77 @@
+import os
+import sys
+import base64
+import hashlib
+import subprocess
+from cryptography.fernet import Fernet
+
+class Security:
+    """Handles machine-specific key encryption and decryption."""
+    
+    _cached_key = None
+
+    @classmethod
+    def get_machine_id(cls) -> str:
+        """Generates a reasonably unique hardware-linked ID for this device."""
+        try:
+            if sys.platform == "win32":
+                # Get Windows UUID from registry/command
+                cmd = 'wmic csproduct get uuid'
+                uuid = subprocess.check_output(cmd, shell=True).decode().split('
+')[1].strip()
+                if uuid: return uuid
+            elif sys.platform == "darwin":
+                # MacOS hardware UUID
+                cmd = "ioreg -rd1 -c IOPlatformExpertDevice | grep -E '(IOPlatformUUID)'"
+                uuid = subprocess.check_output(cmd, shell=True).decode().split('"')[-2]
+                if uuid: return uuid
+            else:
+                # Linux machine-id
+                if os.path.exists("/etc/machine-id"):
+                    with open("/etc/machine-id", "r") as f:
+                        return f.read().strip()
+        except:
+            pass
+            
+        # Fallback to a hash of the node (MAC address)
+        import uuid as _uuid
+        return str(_uuid.getnode())
+
+    @classmethod
+    def _get_fernet_key(cls) -> bytes:
+        """Derives a Fernet-compatible key from the machine ID."""
+        if cls._cached_key:
+            return cls._cached_key
+            
+        machine_id = cls.get_machine_id()
+        # Derive a 32-byte key using SHA256
+        key_hash = hashlib.sha256(machine_id.encode()).digest()
+        # Fernet keys must be base64-encoded 32-byte keys
+        cls._cached_key = base64.urlsafe_b64encode(key_hash)
+        return cls._cached_key
+
+    @classmethod
+    def encrypt(cls, data: str) -> str:
+        """Encrypts a string using the machine-bound key."""
+        if not data: return ""
+        try:
+            f = Fernet(cls._get_fernet_key())
+            return f.encrypt(data.encode()).decode()
+        except Exception as e:
+            # Fallback if cryptography fails (unlikely)
+            return data
+
+    @classmethod
+    def decrypt(cls, encrypted_data: str) -> str:
+        """Decrypts a string using the machine-bound key."""
+        if not encrypted_data: return ""
+        try:
+            # If it doesn't look like Fernet, return as is (for migration)
+            if not encrypted_data.startswith("gAAAA"):
+                return encrypted_data
+                
+            f = Fernet(cls._get_fernet_key())
+            return f.decrypt(encrypted_data.encode()).decode()
+        except:
+            # If decryption fails, it might be raw data
+            return encrypted_data

hacxgpt/utils/system.py

@@ -12,7 +12,8 @@ def check_dependencies():
         ("dotenv", "python-dotenv"),
         ("rich", "rich"),
         ("pyperclip", "pyperclip"),
-        ("requests", "requests")
+        ("requests", "requests"),
+        ("cryptography", "cryptography")
     ]
 
     missing_pip_names = []

requirements.txt

@@ -5,3 +5,4 @@ pyperclip>=1.8.0
 colorama>=0.4.6
 prompt_toolkit>=3.0.0
 requests>=2.31.0
+cryptography>=42.0.0