cite-agent 1.0.5__py3-none-any.whl → 1.2.3__py3-none-any.whl

cite_agent/session_manager.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""
+User-Friendly Session Manager for Cite-Agent
+Handles session detection, user choices, and authentication flow
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+from rich.text import Text
+
+class SessionManager:
+    """User-friendly session management for Cite-Agent"""
+    
+    def __init__(self):
+        self.console = Console()
+        self.session_file = Path.home() / ".nocturnal_archive" / "session.json"
+        self.config_file = Path.home() / ".nocturnal_archive" / "config.env"
+        self.session_data: Optional[Dict[str, Any]] = None
+    
+    def detect_existing_session(self) -> bool:
+        """Detect if there's an existing session and load it"""
+        if not self.session_file.exists():
+            return False
+        
+        try:
+            with open(self.session_file, 'r') as f:
+                self.session_data = json.load(f)
+                return True
+        except Exception as e:
+            self.console.print(f"[red]⚠️ Session file corrupted: {e}[/red]")
+            return False
+    
+    def show_session_info(self):
+        """Display existing session information in a user-friendly way"""
+        if not self.session_data:
+            return
+        
+        email = self.session_data.get('email', 'Unknown')
+        user_id = self.session_data.get('user_id', 'Unknown')[:8] + "..."
+        expires_at = self.session_data.get('expires_at', 'Unknown')
+        daily_limit = self.session_data.get('daily_token_limit', 0)
+        
+        # Create a nice table
+        table = Table(title="🔑 Existing Session Found", show_header=True, header_style="bold green")
+        table.add_column("Property", style="cyan", width=15)
+        table.add_column("Value", style="white")
+        
+        table.add_row("Email", email)
+        table.add_row("User ID", user_id)
+        table.add_row("Daily Limit", f"{daily_limit:,} queries")
+        table.add_row("Expires", expires_at)
+        
+        self.console.print()
+        self.console.print(table)
+        self.console.print()
+    
+    def ask_session_choice(self) -> str:
+        """Ask user what they want to do with the existing session"""
+        self.console.print("[bold cyan]What would you like to do?[/bold cyan]")
+        self.console.print()
+        
+        # Create a nice menu
+        menu_table = Table(show_header=False, box=None, padding=(0, 1))
+        menu_table.add_column("Choice", style="bold green", width=3)
+        menu_table.add_column("Action", style="white", width=20)
+        menu_table.add_column("Description", style="dim", width=40)
+        
+        menu_table.add_row("1", "Resume", "Continue with this session")
+        menu_table.add_row("2", "Switch", "Login with different account")
+        menu_table.add_row("3", "Logout", "Clear session and start fresh")
+        menu_table.add_row("4", "Help", "Show session management help")
+        
+        self.console.print(menu_table)
+        self.console.print()
+        
+        while True:
+            choice = Prompt.ask(
+                "Choose an option",
+                choices=["1", "2", "3", "4", "resume", "switch", "logout", "help"],
+                default="1"
+            ).lower()
+            
+            if choice in ["1", "resume"]:
+                return "resume"
+            elif choice in ["2", "switch"]:
+                return "switch"
+            elif choice in ["3", "logout"]:
+                return "logout"
+            elif choice in ["4", "help"]:
+                self.show_help()
+                continue
+            else:
+                self.console.print("[red]Invalid choice. Please try again.[/red]")
+    
+    def show_help(self):
+        """Show help for session management"""
+        help_text = """
+[bold cyan]Session Management Help[/bold cyan]
+
+[bold green]Resume:[/bold green] Continue with your existing session
+• Use your current login and settings
+• No need to re-authenticate
+• All your data and preferences are preserved
+
+[bold yellow]Switch:[/bold yellow] Login with a different account
+• Logout from current session
+• Start fresh with new account
+• Previous session data will be cleared
+
+[bold red]Logout:[/bold red] Clear session and start fresh
+• Remove all saved login information
+• Start completely fresh
+• You'll need to login again
+
+[bold blue]Session Files:[/bold blue]
+• Session: ~/.nocturnal_archive/session.json
+• Config: ~/.nocturnal_archive/config.env
+
+[bold blue]Manual Session Management:[/bold blue]
+• To clear session manually: rm ~/.nocturnal_archive/session.json
+• To clear config: rm ~/.nocturnal_archive/config.env
+        """
+        
+        self.console.print(Panel(help_text, title="Help", border_style="blue"))
+        self.console.print()
+    
+    def clear_session(self) -> bool:
+        """Clear the existing session"""
+        try:
+            if self.session_file.exists():
+                self.session_file.unlink()
+            if self.config_file.exists():
+                self.config_file.unlink()
+            self.console.print("[green]✅ Session cleared successfully[/green]")
+            return True
+        except Exception as e:
+            self.console.print(f"[red]❌ Error clearing session: {e}[/red]")
+            return False
+    
+    def handle_session_affirmation(self) -> str:
+        """Main function to handle session affirmation with user-friendly interface"""
+        # Check for existing session
+        has_session = self.detect_existing_session()
+        
+        if not has_session:
+            self.console.print("[yellow]No existing session found. Starting fresh...[/yellow]")
+            return "fresh"
+        
+        # Show session information
+        self.show_session_info()
+        
+        # Ask user what to do
+        choice = self.ask_session_choice()
+        
+        if choice == "resume":
+            self.console.print("[green]✅ Resuming existing session...[/green]")
+            return "resume"
+        elif choice == "switch":
+            self.console.print("[yellow]🔄 Switching to different account...[/yellow]")
+            if self.clear_session():
+                return "fresh"
+            else:
+                return "error"
+        elif choice == "logout":
+            self.console.print("[red]🚪 Logging out...[/red]")
+            if self.clear_session():
+                return "fresh"
+            else:
+                return "error"
+        
+        return "error"
+    
+    def setup_environment_variables(self):
+        """Set up environment variables for backend mode"""
+        # PRODUCTION MODE: Force backend, ensure monetization
+        # NEVER load user's .env files in production
+        
+        # Set backend URL if not already set
+        if "NOCTURNAL_API_URL" not in os.environ:
+            os.environ["NOCTURNAL_API_URL"] = "https://cite-agent-api-720dfadd602c.herokuapp.com/api"
+        
+        # SECURITY: Default to backend mode (USE_LOCAL_KEYS=false)
+        # This ensures users MUST authenticate and pay
+        if "USE_LOCAL_KEYS" not in os.environ:
+            os.environ["USE_LOCAL_KEYS"] = "false"
+    
+    def get_session_status(self) -> Dict[str, Any]:
+        """Get current session status for debugging"""
+        return {
+            "session_file_exists": self.session_file.exists(),
+            "config_file_exists": self.config_file.exists(),
+            "session_data": self.session_data,
+            "use_local_keys": os.environ.get("USE_LOCAL_KEYS", "not set"),
+            "api_url": os.environ.get("NOCTURNAL_API_URL", "not set")
+        }
+
+def main():
+    """Test the session manager"""
+    sm = SessionManager()
+    result = sm.handle_session_affirmation()
+    print(f"Result: {result}")
+    
+    # Show status
+    status = sm.get_session_status()
+    print(f"Status: {status}")
+
+if __name__ == "__main__":
+    main()

cite_agent/updater.py

@@ -12,18 +12,29 @@ from pathlib import Path
 from typing import Optional, Dict, Any
 
 try:
-    import pkg_resources
+    # Use modern importlib.metadata instead of deprecated pkg_resources
+    from importlib.metadata import version as get_version
+    pkg_resources = None  # Not needed anymore
 except ImportError:
-    pkg_resources = None
+    # Fallback for Python < 3.8
+    try:
+        import warnings
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            warnings.filterwarnings("ignore", category=UserWarning)
+            import pkg_resources
+    except ImportError:
+        pkg_resources = None
+        get_version = None
 
 class NocturnalUpdater:
     """Handles automatic updates for Nocturnal Archive"""
     
     def __init__(self):
         self.current_version = self.get_current_version()
-        self.package_name = "nocturnal-archive"
+        self.package_name = "cite-agent"  # Fixed: was "nocturnal-archive"
         self.pypi_url = f"https://pypi.org/pypi/{self.package_name}/json"
-        self.kill_switch_url = "https://api.nocturnal.dev/api/admin/status"
+        self.kill_switch_url = "https://cite-agent-api-720dfadd602c.herokuapp.com/api/health"
     
     def check_kill_switch(self) -> Dict[str, Any]:
         """Check if kill switch is activated"""
@@ -37,16 +48,23 @@ class NocturnalUpdater:
     
     def get_current_version(self) -> str:
         """Get current installed version"""
+        # Try modern importlib.metadata first
+        try:
+            return get_version(self.package_name)
+        except Exception:
+            pass
+        
+        # Fallback to pkg_resources (deprecated)
         if pkg_resources:
             try:
                 return pkg_resources.get_distribution(self.package_name).version
-            except (pkg_resources.DistributionNotFound, Exception):
+            except Exception:
                 pass
         
-        # Fallback: try to get version from installed package
+        # Last resort: try to get version from installed package
         try:
-            import nocturnal_archive
-            return getattr(nocturnal_archive, '__version__', '1.0.0')
+            import cite_agent
+            return getattr(cite_agent, '__version__', '1.0.0')
         except ImportError:
             return "1.0.0"
     
@@ -103,32 +121,47 @@ class NocturnalUpdater:
         except:
             return False
     
-    def update_package(self, force: bool = False) -> bool:
+    def update_package(self, force: bool = False, silent: bool = False) -> bool:
         """Update the package to latest version"""
         try:
-            print("🔄 Updating Nocturnal Archive...")
+            if not silent:
+                print("🔄 Updating cite-agent...")
             
             # Check if update is needed
             if not force:
                 update_info = self.check_for_updates()
                 if not update_info or not update_info["available"]:
-                    print("✅ No updates available")
+                    if not silent:
+                        print("✅ No updates available")
                     return True
             
-            # Perform update
-            cmd = [sys.executable, "-m", "pip", "install", "--upgrade", self.package_name]
+            # Perform update with user flag to avoid system package conflicts
+            cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "--user", self.package_name]
             result = subprocess.run(cmd, capture_output=True, text=True)
             
             if result.returncode == 0:
-                new_version = self.get_current_version()
-                print(f"✅ Updated to version {new_version}")
+                # Create flag file to notify next launch
+                try:
+                    from pathlib import Path
+                    update_flag = Path.home() / ".nocturnal_archive" / ".updated"
+                    update_flag.parent.mkdir(exist_ok=True)
+                    update_flag.write_text(self.get_current_version())
+                except:
+                    pass
+                
+                if not silent:
+                    new_version = self.get_current_version()
+                    print(f"✅ Updated to version {new_version}")
+                    print("🔄 Restart cite-agent to use the new version")
                 return True
             else:
-                print(f"❌ Update failed: {result.stderr}")
+                if not silent:
+                    print(f"❌ Update failed: {result.stderr}")
                 return False
                 
         except Exception as e:
-            print(f"❌ Update error: {e}")
+            if not silent:
+                print(f"❌ Update error: {e}")
             return False
     
     def show_update_status(self):