feat: Support bot.session file and improve bot session handling - Add support for bot.session file in root/sessions directory - Prioritize bot.session file over session strings - Improve bot_session_gen.py with better error handling - Fix async send_message warning - Update config template with bot session instructions

config_template.env

@@ -10,6 +10,11 @@ MONGO_URI=mongodb://localhost:27017/ultroid
 # Bot token (if using bot mode)
 BOT_TOKEN=your_bot_token_here
 
+# Bot session string (alternative to BOT_TOKEN - generate using bot_session_gen.py)
+# You can use either BOT_SESSION or bot.session as the key name
+# BOT_SESSION=your_bot_session_string_here
+# bot.session=your_bot_session_string_here
+
 # API credentials
 API_ID=your_api_id
 API_HASH=your_api_hash

pyUltroid/__init__.py

@@ -78,8 +78,27 @@ if run_as_module:
         asst = ultroid_bot
     else:
         try:
+            # Check for bot.session file first (in root or sessions directory)
+            bot_session_file = None
+            if os.path.exists("bot.session"):
+                bot_session_file = "bot.session"
+            elif os.path.exists("sessions/bot.session"):
+                bot_session_file = "sessions/bot.session"
+            
+            # Also check for session string from env/db
             BOT_SESSION = Var.BOT_SESSION or udB.get_key("BOT_SESSION") or udB.get_key("bot.session")
-            if BOT_SESSION:
+            
+            if bot_session_file:
+                # Use the bot.session file directly
+                LOGS.info(f"Using bot session file: {bot_session_file}")
+                asst = UltroidClient(
+                    bot_session_file,
+                    udB=udB,
+                    app_version=ultroid_version,
+                    device_model="Ultroid",
+                )
+            elif BOT_SESSION:
+                # Use session string from env/db
                 asst = UltroidClient(
                     validate_session(BOT_SESSION, LOGS),
                     udB=udB,
@@ -87,40 +106,49 @@ if run_as_module:
                     device_model="Ultroid",
                 )
             else:
-                # Try to create session from bot_token
+                # Use bot_token directly (recommended: create BOT_SESSION manually)
                 bot_token = udB.get_key("BOT_TOKEN")
                 if bot_token:
-                    try:
-                        # Create temporary client with bot_token to generate session
-                        from telethon.sessions import StringSession
-                        temp_session = StringSession()
-                        temp_client = UltroidClient(
-                            temp_session,
-                            bot_token=bot_token,
-                            udB=udB,
-                            log_attempt=False,
-                            exit_on_error=False,
-                        )
-                        # The client auto-starts in __init__, so session should be ready
-                        # Generate session string from the bot client
-                        bot_session_string = temp_client.session.save()
-                        # Save the session to database
-                        udB.set_key("BOT_SESSION", bot_session_string)
-                        LOGS.info("Generated bot session from bot token and saved it.")
-                        # Close temp client and create new one with session
-                        temp_client.disconnect()
-                        asst = UltroidClient(
-                            validate_session(bot_session_string, LOGS),
-                            udB=udB,
-                            app_version=ultroid_version,
-                            device_model="Ultroid",
-                        )
-                    except Exception as session_error:
-                        LOGS.warning(f"Failed to create session from bot token: {session_error}")
-                        # Fall back to bot_token method
+                    # Optionally auto-generate session if enabled and connection is available
+                    # Note: Manual session generation is recommended for reliability
+                    auto_gen_session = udB.get_key("AUTO_GEN_BOT_SESSION")
+                    if auto_gen_session:
+                        try:
+                            # Create temporary client with bot_token to generate session
+                            from telethon.sessions import StringSession
+                            temp_session = StringSession()
+                            temp_client = UltroidClient(
+                                temp_session,
+                                bot_token=bot_token,
+                                udB=udB,
+                                log_attempt=False,
+                                exit_on_error=False,
+                            )
+                            # The client auto-starts in __init__, so session should be ready
+                            # Generate session string from the bot client
+                            bot_session_string = temp_client.session.save()
+                            # Save the session to database
+                            udB.set_key("BOT_SESSION", bot_session_string)
+                            LOGS.info("Generated bot session from bot token and saved it.")
+                            # Close temp client and create new one with session
+                            temp_client.disconnect()
+                            asst = UltroidClient(
+                                validate_session(bot_session_string, LOGS),
+                                udB=udB,
+                                app_version=ultroid_version,
+                                device_model="Ultroid",
+                            )
+                        except Exception as session_error:
+                            LOGS.warning(f"Failed to create session from bot token: {session_error}")
+                            LOGS.info("Falling back to bot_token method. Consider creating BOT_SESSION manually.")
+                            # Fall back to bot_token method
+                            asst = UltroidClient("sessions/asst", bot_token=bot_token, udB=udB)
+                    else:
+                        # Use bot_token directly (default behavior)
                         asst = UltroidClient("sessions/asst", bot_token=bot_token, udB=udB)
                 else:
-                    asst = UltroidClient("sessions/asst", bot_token=None, udB=udB)
+                    LOGS.warning("No BOT_TOKEN found. Assistant bot will not be available.")
+                    asst = ultroid_bot
         except Exception as e:
             LOGS.warning(f"Failed to initialize assistant bot: {e}")
             LOGS.info("Running without assistant bot...")

pyUltroid/configs.py

@@ -38,7 +38,7 @@ class Var:
     )
     # extras
     BOT_TOKEN = config("BOT_TOKEN", default=None)
-    BOT_SESSION = config("BOT_SESSION", default=None)
+    BOT_SESSION = config("BOT_SESSION", default=None) or config("bot.session", default=None)
     LOG_CHANNEL = config("LOG_CHANNEL", default=0, cast=int)
     HEROKU_APP_NAME = config("HEROKU_APP_NAME", default=None)
     HEROKU_API = config("HEROKU_API", default=None)

resources/session/bot_session_gen.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""
+Generate Bot Session String for Ultroid
+This script generates a session string for your bot account.
+"""
+
+import os
+import sys
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+try:
+    from decouple import config
+except ImportError:
+    print("Installing python-decouple...")
+    os.system("pip install python-decouple")
+    from decouple import config
+
+try:
+    from telethon.sessions import StringSession
+    from telethon import TelegramClient
+except ImportError:
+    print("Installing Telethon...")
+    os.system("pip install telethon")
+    from telethon.sessions import StringSession
+    from telethon import TelegramClient
+
+
+def get_api_credentials():
+    """Get API ID and API HASH from environment or config"""
+    # Try to get from config without casting first
+    api_id_str = config("API_ID", default=None)
+    API_HASH = config("API_HASH", default=None)
+    
+    # Convert API_ID to int if it exists
+    API_ID = None
+    if api_id_str:
+        try:
+            API_ID = int(api_id_str)
+        except (ValueError, TypeError):
+            API_ID = None
+    
+    # Prompt user if not found in config
+    if not API_ID or not API_HASH:
+        print("Please set API_ID and API_HASH in your .env file or environment variables.")
+        if not API_ID:
+            api_id_input = input("Enter API_ID: ").strip()
+            try:
+                API_ID = int(api_id_input)
+            except ValueError:
+                print("Error: API_ID must be a number!")
+                sys.exit(1)
+        if not API_HASH:
+            API_HASH = input("Enter API_HASH: ").strip()
+            if not API_HASH:
+                print("Error: API_HASH is required!")
+                sys.exit(1)
+    
+    return API_ID, API_HASH
+
+
+def generate_bot_session():
+    """Generate a session string for bot account"""
+    print("Bot Session Generator for Ultroid")
+    print("=" * 50)
+    
+    API_ID, API_HASH = get_api_credentials()
+    
+    bot_token = config("BOT_TOKEN", default=None)
+    if not bot_token:
+        bot_token = input("Enter your Bot Token (from @BotFather): ").strip()
+    
+    if not bot_token:
+        print("Error: Bot token is required!")
+        return
+    
+    print("\nGenerating bot session...")
+    print("This may take a few seconds...\n")
+    
+    try:
+        # Create a fresh in-memory session to avoid reusing existing sessions
+        import tempfile
+        import os
+        
+        # Create a temporary session file that won't conflict
+        temp_session_file = os.path.join(tempfile.gettempdir(), f"bot_session_temp_{os.getpid()}.session")
+        
+        # Remove if exists to ensure fresh session
+        if os.path.exists(temp_session_file):
+            os.remove(temp_session_file)
+        
+        with TelegramClient(temp_session_file, API_ID, API_HASH) as client:
+            # Start with bot_token - this will authenticate as bot
+            client.start(bot_token=bot_token)
+            
+            # Verify it's actually a bot account
+            if not client.is_bot():
+                print("\n⚠️  Warning: The session appears to be for a user account, not a bot account.")
+                print("Make sure your BOT_TOKEN is correct.\n")
+            
+            # Get bot session string
+            session_string = client.session.save()
+            
+            # Clean up temp session file
+            try:
+                if os.path.exists(temp_session_file):
+                    os.remove(temp_session_file)
+            except Exception:
+                pass
+            
+            print("\n" + "=" * 50)
+            print("✓ Bot session generated successfully!")
+            print("=" * 50)
+            print(f"\nYour BOT_SESSION string:\n\n{session_string}\n")
+            print("=" * 50)
+            print("\nIMPORTANT:")
+            print("1. Copy the session string above")
+            print("2. Add it to your .env file as:")
+            print("   BOT_SESSION=your_session_string")
+            print("   OR")
+            print("   bot.session=your_session_string")
+            print("3. Or set it in your database with key: BOT_SESSION or bot.session")
+            print("4. Do NOT share this session string with anyone!\n")
+            
+            # Try to send to saved messages (async call)
+            try:
+                import asyncio
+                if client.is_connected():
+                    asyncio.run(client.send_message("me", f"**ULTROID BOT SESSION**\n\n`{session_string}`\n\n**DO NOT SHARE THIS!**"))
+                    print("✓ Session string also sent to your Telegram saved messages.\n")
+            except Exception as e:
+                # Ignore errors sending to saved messages - not critical
+                pass
+                
+    except Exception as e:
+        print(f"\n✗ Error generating session: {e}")
+        print("\nPlease check:")
+        print("- Your API_ID and API_HASH are correct")
+        print("- Your BOT_TOKEN is valid")
+        print("- You have a stable internet connection")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    generate_bot_session()
+