Merge branch 'dev'

Signed-off-by: salmonik <raisersoft@proton.me>

18 files changed, 587 insertions, 199 deletions

diff --git a/cogs/ai.py b/cogs/ai.py
index 6f79ac5..c9237c4 100644
--- a/cogs/ai.py
+++ b/cogs/ai.py
@@ -66,7 +66,7 @@ class AI(commands.Cog):
                     tts_buffer = io.BytesIO()
                     tts_obj.write_to_fp(tts_buffer)
                     tts_buffer.seek(0)
-                    await audio_playback.AudioPlaybackManager.play(ctx, discord.FFmpegPCMAudio(tts_buffer), delete_after_play=True)
+                    await audio_playback.AudioPlaybackManager.play(ctx, discord.FFmpegPCMAudio(tts_buffer), delete_after_play=True, interrupt=False)
 
                 else:
                     await ctx.send_followup(response_text)
diff --git a/cogs/assistant.py b/cogs/assistant.py
index a89c356..a91d027 100644
--- a/cogs/assistant.py
+++ b/cogs/assistant.py
@@ -16,8 +16,6 @@ from cogs.downloader import Downloader
 
 logger = logging.getLogger(__name__)
 
-AI_MODEL = "z-ai/glm-4.5-air:free"
-
 class Jarvis(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
@@ -102,7 +100,7 @@ class Jarvis(commands.Cog):
     @staticmethod
     def _build_payload(messages):
         return {
-            "model": AI_MODEL,
+            "model": os.getenv("OPENROUTER_MODEL"),
             "messages": messages,
             "response_format": Jarvis._get_response_schema(),
             "plugins": [{"id": "response-healing"}]
diff --git a/cogs/compression.py b/cogs/compression.py
index acc9eda..7171abb 100644
--- a/cogs/compression.py
+++ b/cogs/compression.py
@@ -38,7 +38,7 @@ class Compression(commands.Cog):
         self.bot = bot
         self.temp_dir = get_temp_dir()
         self._cached_urls = {}
-        self._baseurl = os.getenv("COPYPARTY_URL") or get_baseurl()
+        self._baseurl = get_baseurl()
 
     async def _file_autocomplete(self, ctx: AutocompleteContext):
         query = ctx.value.lower() if ctx.value else ""
diff --git a/cogs/conversion.py b/cogs/conversion.py
index 1117caf..455bfde 100644
--- a/cogs/conversion.py
+++ b/cogs/conversion.py
@@ -35,11 +35,11 @@ class Conversion(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
         from cogs.utils.temp import get_temp_dir
-        from cogs.utils.settings import get_baseurl
+        from cogs.utils.settings import get_baseurl, get_uploadurl
         self.temp_dir = get_temp_dir()
         self._cached_urls = {}
-        self._baseurl = os.getenv("COPYPARTY_URL") or get_baseurl()
-        self._uploadurl = os.getenv("COPYPARTY_URL_UPLOAD")
+        self._baseurl = get_baseurl()
+        self._uploadurl = get_uploadurl()
 
     async def _file_autocomplete(self, ctx: AutocompleteContext):
         query = ctx.value.lower() if ctx.value else ""
diff --git a/cogs/cron.py b/cogs/cron.py
index da8127b..aad43d2 100644
--- a/cogs/cron.py
+++ b/cogs/cron.py
@@ -4,9 +4,7 @@
 # https://codeberg.org/salmonik/senator-sperma
 
 import asyncio
-import json
 import logging
-import os
 from datetime import datetime
 from venv import logger
 
@@ -16,37 +14,67 @@ from discord.ext import commands
 
 from cogs.utils import file_search as search_utils
 from cogs.voice import get_voice_manager
+from cogs.utils.database import get_connection, init_database
 
 logger = logging.getLogger(__name__)
 
+init_database()
+
 
 class Cron(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
         self.scheduled_tasks = []
-        self.cron_file = "data/cron_jobs.json"
         self.load_tasks()
         self.task = bot.loop.create_task(self.schedule_checker())
 
     def load_tasks(self):
-        """Load scheduled tasks from file"""
         try:
-            if os.path.exists(self.cron_file):
-                with open(self.cron_file, "r") as f:
-                    self.scheduled_tasks = json.load(f)
-                logger.info(f"Loaded {len(self.scheduled_tasks)} cron jobs")
-            else:
-                self.scheduled_tasks = []
+            with get_connection() as conn:
+                c = conn.cursor()
+                c.execute("SELECT id, cron_expression, type, channel_id, active, audio_filename, message FROM cron_jobs")
+                rows = c.fetchall()
+
+            self.scheduled_tasks = [
+                {
+                    "id": row[0],
+                    "cron_expression": row[1],
+                    "type": row[2],
+                    "channel_id": row[3],
+                    "active": bool(row[4]),
+                    "audio_filename": row[5],
+                    "message": row[6],
+                }
+                for row in rows
+            ]
+            logger.info(f"Loaded {len(self.scheduled_tasks)} cron jobs from database")
         except Exception as e:
             logger.error(f"Error loading cron jobs: {e}")
             self.scheduled_tasks = []
 
     def save_tasks(self):
-        """Save scheduled tasks to file"""
         try:
-            os.makedirs(os.path.dirname(self.cron_file), exist_ok=True)
-            with open(self.cron_file, "w") as f:
-                json.dump(self.scheduled_tasks, f, indent=2)
+            with get_connection() as conn:
+                c = conn.cursor()
+                c.execute("PRAGMA foreign_keys = ON")
+
+                c.execute("DELETE FROM cron_jobs")
+
+                for task in self.scheduled_tasks:
+                    c.execute(
+                        """INSERT INTO cron_jobs (id, cron_expression, type, channel_id, active, audio_filename, message)
+                        VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                        (
+                            task.get("id"),
+                            task["cron_expression"],
+                            task["type"],
+                            task["channel_id"],
+                            int(task.get("active", True)),
+                            task.get("audio_filename"),
+                            task.get("message"),
+                        ),
+                    )
+                conn.commit()
         except Exception as e:
             logger.error(f"Error saving cron jobs: {e}")
 
@@ -104,7 +132,7 @@ class Cron(commands.Cog):
 
             if task_type in ("zagraj_audio", "audio"):
                 await self.play_audio_task(task, channel)
-            elif task_type in ("wyślij_wiadomość", "send_message"):
+            elif task_type in ("wyślij_wiadomość", "send_message", "wiadomość"):
                 await self.send_message_task(task, channel)
 
             logger.info(f"Executed task {task['id']} of type {task_type}")
@@ -132,11 +160,13 @@ class Cron(commands.Cog):
                 while voice_client.is_playing():
                     await asyncio.sleep(1)
 
+                logger.info("Audio playback finished normally - disconnecting")
                 await voice_client.disconnect()
                 logger.info(f"Finished playing audio: {audio_url}")
             except Exception as e:
                 logger.error(f"Error playing audio: {e}")
                 if voice_client.is_connected():
+                    logger.info("Audio playback failed - disconnecting")
                     await voice_client.disconnect()
                 if channel.guild.system_channel:
                     await channel.guild.system_channel.send(
@@ -176,8 +206,19 @@ class Cron(commands.Cog):
             else [discord.OptionChoice(name="Brak wyników", value="")]
         )
 
-    @commands.slash_command(
-        name="cron_dodaj_audio", description="Dodaj nowe zadanie cron audio"
+        def _get_baseurl(self):
+            """Get base URL from settings"""
+            try:
+                from cogs.utils.settings import get_baseurl
+
+                return get_baseurl()
+            except Exception:
+                return ""
+
+    trigger_group = discord.SlashCommandGroup("cron", "komendy cron")
+
+    @trigger_group.command(
+        name="dodaj_audio", description="Dodaj nowe zadanie cron audio"
     )
     async def cron_add_audio(
         self,
@@ -227,8 +268,8 @@ class Cron(commands.Cog):
             f"Zadanie cron dodane. ID: {task_id}\nSkładnia: `{cron_expression}`\nAkcja: audio\nKanał: <#{channel.id}>"
         )
 
-    @commands.slash_command(
-        name="cron_dodaj_wiadomość", description="Dodaj nowe zadanie cron wiadomość"
+    @trigger_group.command(
+        name="dodaj_wiadomość", description="Dodaj nowe zadanie cron wiadomość"
     )
     async def cron_add_message(
         self,
@@ -272,17 +313,8 @@ class Cron(commands.Cog):
             f"Zadanie cron dodane. ID: {task_id}\nSkładnia: `{cron_expression}`\nAkcja: wiadomość\nKanał: <#{channel.id}>"
         )
 
-    def _get_baseurl(self):
-        """Get base URL from settings"""
-        try:
-            from cogs.utils.settings import get_baseurl
-
-            return get_baseurl()
-        except Exception:
-            return ""
-
-    @commands.slash_command(
-        name="cron_pokaż", description="Pokaż wszystkie zadania cron"
+    @trigger_group.command(
+        name="pokaż", description="Pokaż wszystkie zadania cron"
     )
     async def cron_list(self, ctx):
         """List all cron jobs"""
@@ -313,7 +345,7 @@ class Cron(commands.Cog):
 
         await ctx.respond(embed=embed)
 
-    @commands.slash_command(name="cron_usuń", description="Usuń zadanie cron z ID")
+    @trigger_group.command(name="usuń", description="Usuń zadanie cron z ID")
     async def cron_remove(
         self,
         ctx,
@@ -331,7 +363,7 @@ class Cron(commands.Cog):
 
         await ctx.respond(f"Nie znaleziono zadania cron z ID {job_id}")
 
-    @commands.slash_command(name="cron_pauza", description="Zapauzuj zadanie cron z ID")
+    @trigger_group.command(name="pauza", description="Zapauzuj zadanie cron z ID")
     async def cron_pause(
         self,
         ctx,
@@ -349,7 +381,7 @@ class Cron(commands.Cog):
 
         await ctx.respond(f"Nie znaleziono zadania cron z ID {job_id}")
 
-    @commands.slash_command(name="cron_wznów", description="Wznów zadanie cron z ID")
+    @trigger_group.command(name="wznów", description="Wznów zadanie cron z ID")
     async def cron_resume(
         self,
         ctx,
diff --git a/cogs/downloader.py b/cogs/downloader.py
index 36bd723..900bafb 100644
--- a/cogs/downloader.py
+++ b/cogs/downloader.py
@@ -12,6 +12,7 @@ import re
 import yt_dlp
 from discord.ext import commands
 import aiofiles
+from cogs.utils.url_helper import clean_url_for_ytdlp
 
 logger = logging.getLogger(__name__)
 
@@ -61,6 +62,10 @@ class Downloader(commands.Cog):
                     file_data = response["content"]
                     await ctx.respond(file=discord.File(file_data))
             else:
+                error_msg = response["content"]
+                if 'details' in response:
+                    error_msg += f"\n{response['details']}"
+                await ctx.respond(f"Błąd: {error_msg}", ephemeral=True)
                 logger.error(f"Error: {response['content']}")
                 if 'details' in response:
                     logger.error(f"Details: {response['details']}")
@@ -68,10 +73,11 @@ class Downloader(commands.Cog):
     @staticmethod
     async def download_standalone(url: str, catbox: bool = False, fformat: str = "mp4", filename_user: str | None = None):
         try:
+            url = clean_url_for_ytdlp(url)
             logger.info(f"Downloading {url} as {fformat}")
 
             with tempfile.TemporaryDirectory(delete=False) as temp_dir:
-                ydl_opts = Downloader._get_ydl_options(fformat, temp_dir)
+                ydl_opts = Downloader._get_ydl_options(filename_user, fformat, temp_dir)
 
                 with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                     ydl.download([url])
@@ -87,15 +93,23 @@ class Downloader(commands.Cog):
             return Downloader._create_error_response("Download failed", str(e), None)
 
     @staticmethod
-    def _get_ydl_options(fformat: str, temp_dir: str) -> dict:
+    def _sanitize_filename(name: str) -> str:
+        invalid = '<>:"/\\|?*'
+        for c in invalid:
+            name = name.replace(c, '')
+        return name.strip()
+
+    @staticmethod
+    def _get_ydl_options(filename: str = None, fformat: str = None, temp_dir: str = None) -> dict:
+        if filename:
+            filename = Downloader._sanitize_filename(filename)[:100]
         ydl_opts = {
-            'outtmpl': os.path.join(temp_dir, '%(title)s.%(ext)s'),
+            'outtmpl': os.path.join(temp_dir, filename if filename is not None else '%(title).100s.%(ext)s'),
             'format': 'bestaudio/best' if fformat in ['mp3', 'wav', 'm4a'] else 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
             'merge_output_format': 'mp4',
             'postprocessors': [],
             'remote-components': 'ejs:github',
             'js-runtimes': {'deno': {'path': '/usr/bin/deno'}},
-            'o': '"%(title)s.%(ext)s"'
         }
 
         if fformat in ['mp3', 'wav', 'm4a']:
@@ -120,10 +134,15 @@ class Downloader(commands.Cog):
 
         actual_file = os.path.join(temp_dir, files[0])
         extension = actual_file.split('.')[-1]
+        extension = Downloader._sanitize_filename(extension)
 
         if not filename_user:
             filename = os.path.basename(actual_file)
+            filename = Downloader._sanitize_filename(filename)
+            if len(filename) > 100:
+                filename = filename[:100]
         else:
+            filename_user = Downloader._sanitize_filename(filename_user)[:100]
             filename = filename_user + '.' + extension
             actual_file = os.path.join(temp_dir, filename)
 
@@ -144,12 +163,18 @@ class Downloader(commands.Cog):
                 files = {'f': (filename, content, 'application/octet-stream')}
                 headers = {'Cookie': f'cppwd={os.getenv("COPYPARTY_PASSWORD")}'}
                 params = {'j': '1', 'ck': 'b2'}
-                base_url = "https://catbox.2137697.xyz/sperma/"
+                base_url = os.getenv("COPYPARTY_URL_UPLOAD")
 
                 response = requests.post(base_url, files=files, headers=headers, params=params)
 
                 if response.status_code in [200, 201]:
                     return Downloader._handle_upload_success(response, filename, temp_dir)
+                elif response.status_code == 413:
+                    return Downloader._create_error_response(
+                        "File too large for upload",
+                        "Plik jest za duży, by wysłać go na serwer (limit to ok. 100MB)",
+                        temp_dir
+                    )
                 else:
                     return Downloader._create_error_response(
                         f"Server returned {response.status_code}",
diff --git a/cogs/music/audio_playback.py b/cogs/music/audio_playback.py
index 28c6118..1313d01 100644
--- a/cogs/music/audio_playback.py
+++ b/cogs/music/audio_playback.py
@@ -137,8 +137,16 @@ class AudioPlaybackManager:
         return absolute_source, display_name, is_url
 
     @staticmethod
-    async def execute_playback(ctx, source, display_name, is_url):
-        """Execute the actual audio playback."""
+    async def execute_playback(ctx, source, display_name, is_url, interrupt=True):
+        """Execute the actual audio playback.
+
+        Args:
+            ctx: Discord context
+            source: Audio source path or URL
+            display_name: Name to display
+            is_url: Whether source is a URL
+            interrupt: If True, stop any currently playing audio. If False, skip if audio is playing.
+        """
         target_channel = await AudioPlaybackManager.validate_voice_channel(ctx)
         if not target_channel:
             return False
@@ -169,9 +177,12 @@ class AudioPlaybackManager:
                 logger.info(f"Moving to voice channel: {target_channel.name}")
                 await vc.move_to(target_channel)
 
-            # Stop any currently playing audio
-            if vc.is_playing() or vc.is_paused():  # type: ignore[union-attr]
+            # Stop any currently playing audio (if interrupt is True)
+            if interrupt and (vc.is_playing() or vc.is_paused()):  # type: ignore[union-attr]
                 vc.stop()  # type: ignore[union-attr]
+            elif not interrupt and vc.is_playing():  # type: ignore[union-attr]
+                logger.info("Audio already playing and interrupt=False, skipping playback")
+                return False
 
             # Prepare audio source
             (
@@ -181,13 +192,14 @@ class AudioPlaybackManager:
                 source, is_url, display_name
             )
 
-            # Track if playback failed
-            playback_failed = {"error": None}
+            # Track playback state
+            playback_state = {"error": None, "finished": False}
 
             def after_playing(error):
                 if error:
-                    playback_failed["error"] = str(error)
+                    playback_state["error"] = str(error)
                     logger.error(f"Playback error: {error}")
+                playback_state["finished"] = True
 
             # Play the audio
             vc.play(audio_source, after=after_playing)
@@ -197,14 +209,19 @@ class AudioPlaybackManager:
             # Wait for FFmpeg to attempt connection - errors usually happen within 5 seconds
             await asyncio.sleep(5)
 
-            # Check if playback actually started
-            if playback_failed["error"]:
-                logger.error(f"Playback failed: {playback_failed['error']}")
+            # Check if playback failed to start (not just finished quickly)
+            if playback_state["error"]:
+                logger.error(f"Playback failed: {playback_state['error']}")
                 await ctx.followup.send(
                     "eror: Timeout - nie udało się połączyć ze streamem", ephemeral=True
                 )
                 return False
 
+            # If playback finished within 5s, it was a short file - not an error
+            if playback_state["finished"]:
+                logger.info(f"Playback completed quickly: {final_display_name}")
+                return True
+
             if not vc.is_playing():
                 logger.error(f"Stream failed - not playing after 5s: {source}")
                 await ctx.followup.send(
@@ -232,13 +249,14 @@ class AudioPlaybackManager:
         return prepared_source, display_name, is_url
 
     @staticmethod
-    async def play(ctx, source, delete_after_play=False):
+    async def play(ctx, source, delete_after_play=False, interrupt=True):
         """Play audio from a local file or URL.
 
         Args:
             ctx: Discord context
             source: Either a local file path or a URL to stream from
             delete_after_play: If True, delete the file after playing (only for local files)
+            interrupt: If True, stop any currently playing audio. If False, skip if audio is playing.
         """
         # Validate and prepare source
         (
@@ -254,7 +272,7 @@ class AudioPlaybackManager:
 
         # Execute playback
         success = await AudioPlaybackManager.execute_playback(
-            ctx, prepared_source, display_name, is_url
+            ctx, prepared_source, display_name, is_url, interrupt
         )
 
         # Cleanup if needed
diff --git a/cogs/music/media_processing.py b/cogs/music/media_processing.py
index b9b814c..91bd406 100644
--- a/cogs/music/media_processing.py
+++ b/cogs/music/media_processing.py
@@ -9,6 +9,7 @@ import os
 
 import yt_dlp
 from youtubesearchpython import VideosSearch
+from cogs.utils.url_helper import clean_url_for_ytdlp
 
 logger = logging.getLogger(__name__)
 
@@ -36,6 +37,7 @@ class MediaDownloader:
         }
 
         try:
+            url = clean_url_for_ytdlp(url)
             with yt_dlp.YoutubeDL(ytdl_opts) as ydl:
                 info_dict = ydl.extract_info(url, download=True)
                 # Get the base filename without extension
diff --git a/cogs/music/play_commands.py b/cogs/music/play_commands.py
index 5373436..bdb021d 100644
--- a/cogs/music/play_commands.py
+++ b/cogs/music/play_commands.py
@@ -18,6 +18,8 @@ from discord.ext import commands
 
 from cogs.music import audio_playback, media_processing
 from cogs.utils.file_search import UniversalSearcher
+from cogs.utils.settings import get_uploadurl
+from cogs.utils.url_helper import clean_url_for_ytdlp
 
 logger = logging.getLogger(__name__)
 
@@ -192,6 +194,7 @@ class PlayCommands(commands.Cog):
             }
 
             loop = asyncio.get_event_loop()
+            url = clean_url_for_ytdlp(url)
             with YoutubeDL(ytdl_opts) as ydl:
                 info_dict = await loop.run_in_executor(
                     None, lambda: ydl.extract_info(url, download=True)
@@ -229,14 +232,13 @@ class PlayCommands(commands.Cog):
 
         try:
             logger.info(f"Starting async upload: {file_path}")
-            baseurl = os.getenv("COPYPARTY_URL_UPLOAD")
+            baseurl = get_uploadurl()
             password = os.getenv("COPYPARTY_PASSWORD", "")
 
             logger.info(f"Upload - baseurl: {baseurl}, password set: {bool(password)}")
 
-            if not baseurl:
-                logger.error("COPYPARTY_URL_UPLOAD not set!")
-                return
+            if baseurl == "http://localhost:3939":
+                logger.warning("COPYPARTY_URL_UPLOAD not set! Using default")
 
             with open(file_path, "rb") as f:
                 content = f.read()
diff --git a/cogs/trigger.py b/cogs/trigger.py
index 02e5573..ce80d43 100644
--- a/cogs/trigger.py
+++ b/cogs/trigger.py
@@ -7,13 +7,13 @@ import os
 import discord
 from discord.ext import commands
 import random
-import sqlite3
 import logging
 
-logger = logging.getLogger(__name__)
+from cogs.utils.database import get_connection, init_database
 
+logger = logging.getLogger(__name__)
 
-DB_PATH = 'data/triggers.db'
+init_database()
 
 _SELECT_KEYWORD_SQL = "SELECT keyword FROM trigger_keywords WHERE trigger_id=?"
 _SELECT_RESPONSE_SQL = "SELECT response_text FROM trigger_responses WHERE trigger_id=?"
@@ -22,88 +22,12 @@ _TRIGGER_NOT_FOUND_MSG = "Trigger not found."
 _TRIGGER_NAME_OPTION = "the name of the trigger"
 
 
-def get_connection():
-    return sqlite3.connect(DB_PATH)
-
-
 class Trigger(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
-        self.db_check()
 
     trigger_group = discord.SlashCommandGroup("trigger", "trigger commands")
 
-    @staticmethod
-    def db_check():
-        if not os.path.exists('data'):
-            os.makedirs('data')
-
-        db_exists = os.path.exists(DB_PATH)
-        if not db_exists:
-            logger.warning("Triggers database not found. Creating new database.")
-
-        try:
-            conn = sqlite3.connect(DB_PATH)
-            c = conn.cursor()
-
-            # Enable foreign key constraints
-            c.execute('PRAGMA foreign_keys = ON')
-
-            # Create triggers table
-            c.execute('''
-            CREATE TABLE IF NOT EXISTS triggers (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                name TEXT NOT NULL UNIQUE,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )''')
-
-            # Create trigger_keywords table with foreign key constraint
-            c.execute('''
-            CREATE TABLE IF NOT EXISTS trigger_keywords (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                trigger_id INTEGER NOT NULL,
-                keyword TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (trigger_id) REFERENCES triggers(id) ON DELETE CASCADE,
-                UNIQUE(trigger_id, keyword)
-            )''')
-
-            # Create trigger_responses table with foreign key constraint
-            c.execute('''
-            CREATE TABLE IF NOT EXISTS trigger_responses (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                trigger_id INTEGER NOT NULL,
-                response_text TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (trigger_id) REFERENCES triggers(id) ON DELETE CASCADE
-            )''')
-
-            # Create indexes for better query performance
-            c.execute('CREATE INDEX IF NOT EXISTS idx_trigger_keywords_trigger_id ON trigger_keywords(trigger_id)')
-            c.execute('CREATE INDEX IF NOT EXISTS idx_trigger_keywords_keyword ON trigger_keywords(keyword)')
-            c.execute('CREATE INDEX IF NOT EXISTS idx_trigger_responses_trigger_id ON trigger_responses(trigger_id)')
-
-            # Run integrity check
-            integrity_check = c.execute('PRAGMA integrity_check').fetchone()
-            if integrity_check and integrity_check[0] == 'ok':
-                logger.info("Triggers database integrity check passed")
-            else:
-                logger.warning(f"Triggers database integrity check: {integrity_check}")
-
-            conn.commit()
-
-        except sqlite3.Error as e:
-            logger.error(f"Triggers database error: {e}")
-            raise
-
-        finally:
-            if 'conn' in locals():
-                conn.close()
-
-        if not db_exists:
-            logger.info("Triggers database initialized successfully")
-
     @commands.Cog.listener()
     async def on_message(self, message):
         if message.author == self.bot.user:
@@ -130,7 +54,7 @@ class Trigger(commands.Cog):
 
     @staticmethod
     def get_type(name):
-        with sqlite3.connect(DB_PATH) as conn:
+        with get_connection() as conn:
             c = conn.cursor()
             c.execute("SELECT name FROM triggers")
             return [row[0] for row in c.fetchall()]
diff --git a/cogs/uploader.py b/cogs/uploader.py
new file mode 100644
index 0000000..df6908e
--- /dev/null
+++ b/cogs/uploader.py
@@ -0,0 +1,155 @@
+# This file is part of Senator Sperma
+# Licensed under the GPL-3.0 License
+# Copyright (C) 2026 Salmonik @ salmonik@tuta.io
+# https://codeberg.org/salmonik/senator-sperma
+
+import os
+import aiofiles
+import requests
+import urllib.parse
+from typing import Optional
+import discord
+from discord.ext import commands
+from discord import AutocompleteContext
+from cogs.utils import file_search as search_utils
+from cogs.utils.settings import get_uploadurl
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Uploader(commands.Cog):
+    def __init__(self, bot):
+        from cogs.utils.temp import get_temp_dir
+        self.bot = bot
+        self.temp_dir = get_temp_dir()
+        self._cached_urls = {}
+        self._uploadurl = get_uploadurl()
+
+    async def _file_autocomplete(self, ctx: AutocompleteContext):
+        query = ctx.value.lower() if ctx.value else ""
+        results = await search_utils.UniversalSearcher.search_copyparty_autocomplete(query, max_results=25)
+
+        user_id = ctx.interaction.user.id
+        self._cached_urls[user_id] = {urllib.parse.unquote(url.split('/')[-1]): url for url in results}
+
+        choices = []
+        for url in results[:25]:
+            filename = urllib.parse.unquote(url.split('/')[-1])
+            display_name = filename[:99] + "…" if len(filename) > 100 else filename
+            choices.append(discord.OptionChoice(name=display_name, value=filename))
+        return choices
+
+    async def _download_from_url(self, url: str) -> Optional[str]:
+        """Download file from copyparty URL and return local path"""
+        try:
+            response = requests.get(url)
+            if response.status_code != 200:
+                return None
+
+            filename = url.split('/')[-1].split('?')[0]
+            file_path = os.path.join(self.temp_dir, filename)
+
+            async with aiofiles.open(file_path, 'wb') as f:
+                await f.write(response.content)
+            return file_path
+        except Exception as e:
+            logger.error(f"Error downloading from {url}: {e}")
+            return None
+
+    async def _upload_to_copyparty(self, file_path: str) -> Optional[str]:
+        """Upload file to copyparty and return download URL"""
+        try:
+            async with aiofiles.open(file_path, 'rb') as f:
+                file_content = await f.read()
+
+            files = {'f': (os.path.basename(file_path), file_content, 'application/octet-stream')}
+            headers = {'Cookie': f'cppwd={os.getenv("COPYPARTY_PASSWORD")}'}
+            params = {'j': '1', 'ck': 'b2'}
+
+            response = requests.post(self._uploadurl, files=files, headers=headers, params=params)
+
+            if response.status_code in [200, 201]:
+                result = response.json()
+                return result.get('fileurl')
+        except Exception as e:
+            logger.error(f"Upload error: {e}")
+            return None
+
+    async def _upload_file(self, file_path: str) -> Optional[str]:
+        """Upload a file and return the URL"""
+        if self._uploadurl == "http://localhost:3939":
+            logger.warning("COPYPARTY_URL_UPLOAD not set! Using default")
+            return None
+
+        return await self._upload_to_copyparty(file_path)
+
+    @commands.message_command(
+        name="upload",
+        description="wyślij załączniki na copyparty",
+    )
+    async def message_upload(self, ctx, message: discord.Message):
+        if not message.attachments:
+            await ctx.respond("Brak załączników w wiadomości", ephemeral=True)
+            return
+
+        await ctx.defer()
+
+        uploaded_urls = []
+        failed_count = 0
+
+        for attachment in message.attachments:
+            file_path = os.path.join(self.temp_dir, attachment.filename)
+            await attachment.save(file_path)
+
+            url = await self._upload_file(file_path)
+            if url:
+                uploaded_urls.append(url)
+            else:
+                failed_count += 1
+
+            if os.path.exists(file_path):
+                os.remove(file_path)
+
+        if uploaded_urls:
+            response = f"Wysłano {len(uploaded_urls)} plików:\n" + "\n".join(uploaded_urls)
+            if failed_count > 0:
+                response += f"\n\nNie wysłano {failed_count} plików"
+            await ctx.respond(response)
+        else:
+            await ctx.respond("Nie udało się wysłać żadnych plików", ephemeral=True)
+
+    @commands.slash_command(
+        name="upload",
+        description="wyślij plik na copyparty",
+    )
+    @discord.option(
+        name="zalacznik",
+        description="plik z discorda",
+        required=True,
+        type=discord.Attachment
+    )
+    async def upload(self, ctx, zalacznik: discord.Attachment = None):
+        await ctx.defer()
+
+        file_path = None
+        file_path = os.path.join(self.temp_dir, zalacznik.filename)
+        await zalacznik.save(file_path)
+
+        if not file_path or not os.path.exists(file_path):
+            await ctx.respond("Nie udało się pobrać pliku", ephemeral=True)
+            return
+
+        try:
+            dl_url = await self._upload_file(file_path)
+            if dl_url:
+                await ctx.respond(dl_url)
+            else:
+                await ctx.respond("Nie udało się wysłać pliku", ephemeral=True)
+        finally:
+            if file_path and os.path.exists(file_path):
+                os.remove(file_path)
+
+
+def setup(bot):
+    bot.add_cog(Uploader(bot))
diff --git a/cogs/utils/database.py b/cogs/utils/database.py
new file mode 100644
index 0000000..ea7d356
--- /dev/null
+++ b/cogs/utils/database.py
@@ -0,0 +1,126 @@
+import os
+import sqlite3
+import logging
+from contextlib import contextmanager
+
+logger = logging.getLogger(__name__)
+
+DB_PATH = "data/senator.db"
+
+_initialized = False
+
+
+def get_connection():
+    conn = sqlite3.connect(get_db_path())
+    return _ConnectionContextManager(conn)
+
+
+def get_db_path():
+    return os.getenv("SENATOR_DB_PATH", DB_PATH)
+
+
+def set_db_path(path):
+    global DB_PATH
+    DB_PATH = path
+
+
+class _ConnectionContextManager:
+    """Context manager for sqlite3 connections that auto-closes."""
+    def __init__(self, conn):
+        self.conn = conn
+
+    def __enter__(self):
+        return self.conn
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.conn.close()
+        return False
+
+
+def init_database():
+    global _initialized
+    if _initialized:
+        return
+
+    _initialized = True
+
+    db_path = get_db_path()
+    db_dir = os.path.dirname(db_path)
+    if db_dir and not os.path.exists(db_dir):
+        os.makedirs(db_dir)
+
+    conn = sqlite3.connect(db_path)
+    try:
+        c = conn.cursor()
+
+        c.execute("PRAGMA foreign_keys = ON")
+
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS settings (
+            key TEXT PRIMARY KEY,
+            value TEXT
+        )""")
+
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS cron_jobs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            cron_expression TEXT NOT NULL,
+            type TEXT NOT NULL,
+            channel_id INTEGER NOT NULL,
+            active INTEGER DEFAULT 1,
+            audio_filename TEXT,
+            message TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )""")
+
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS voice_activity (
+            user_id TEXT PRIMARY KEY,
+            join_time REAL,
+            total_active REAL DEFAULT 0,
+            total_afk REAL DEFAULT 0,
+            is_afk INTEGER DEFAULT 0,
+            afk_start REAL,
+            active_start REAL,
+            channel_name TEXT,
+            last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )""")
+
+        c.execute("CREATE INDEX IF NOT EXISTS idx_voice_activity_user_id ON voice_activity(user_id)")
+        c.execute("CREATE INDEX IF NOT EXISTS idx_cron_jobs_active ON cron_jobs(active)")
+
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS triggers (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL UNIQUE,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )""")
+
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS trigger_keywords (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            trigger_id INTEGER NOT NULL,
+            keyword TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (trigger_id) REFERENCES triggers(id) ON DELETE CASCADE,
+            UNIQUE(trigger_id, keyword)
+        )""")
+
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS trigger_responses (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            trigger_id INTEGER NOT NULL,
+            response_text TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (trigger_id) REFERENCES triggers(id) ON DELETE CASCADE
+        )""")
+
+        c.execute("CREATE INDEX IF NOT EXISTS idx_trigger_keywords_trigger_id ON trigger_keywords(trigger_id)")
+        c.execute("CREATE INDEX IF NOT EXISTS idx_trigger_keywords_keyword ON trigger_keywords(keyword)")
+        c.execute("CREATE INDEX IF NOT EXISTS idx_trigger_responses_trigger_id ON trigger_responses(trigger_id)")
+
+        conn.commit()
+        logger.info("Database initialized successfully")
+    finally:
+        conn.close()
diff --git a/cogs/utils/file_search.py b/cogs/utils/file_search.py
index 8111216..788f50c 100644
--- a/cogs/utils/file_search.py
+++ b/cogs/utils/file_search.py
@@ -34,10 +34,22 @@ class UniversalSearcher:
         query = query.strip()
         logger.info(f"Starting copyparty search for query: '{query}'")
 
-        # Build the query with optional extension filtering
-        name_query = f'name like "*{query}*"'
+        tokens = query.split()
+        if not tokens:
+            return []
+
+        token_queries = []
+        for token in tokens:
+            path_query = f'path like "*{token}*"'
+            name_query = f'name like "*{token}*"'
+            token_queries.append(f"({path_query} or {name_query})")
+
+        if len(token_queries) == 1:
+            name_query = token_queries[0]
+        else:
+            name_query = " and ".join(token_queries)
+
         if file_extensions:
-            # Create extension filters using copyparty's .ext$ syntax
             ext_filters = [f"name like \"*.{ext.lower()}\"" for ext in file_extensions]
             ext_query = " or ".join(ext_filters)
             query = f"{name_query} and ({ext_query})"
diff --git a/cogs/utils/settings.py b/cogs/utils/settings.py
index d66ce7f..b1a585c 100644
--- a/cogs/utils/settings.py
+++ b/cogs/utils/settings.py
@@ -3,16 +3,18 @@
 # Copyright (C) 2026 Salmonik @ salmonik@tuta.io
 # https://codeberg.org/salmonik/senator-sperma
 
-import json
 import logging
-import aiofiles
+import sqlite3
 import os
 from dataclasses import dataclass, field
 
+from cogs.utils.database import get_connection, init_database
+
 logger = logging.getLogger(__name__)
 
-settings_file = "data/settings.json"
-DEFAULT_BASEURL = "http://localhost:8080"
+DEFAULT_BASEURL = "http://localhost:3939"
+
+init_database()
 
 
 @dataclass
@@ -28,24 +30,21 @@ class Settings:
         }
 
         try:
-            if os.path.exists(settings_file):
-                async with aiofiles.open(settings_file, "r") as f:
-                    content = await f.read()
-                    if content.strip():
-                        self._data = json.loads(content)
-                        self._sync_from_data()
-                        logger.info("Settings loaded into memory")
-                    else:
-                        self._data = default_settings.copy()
-                        self._sync_from_data()
-                        await self.save()
-                        logger.warning("Empty settings.json, reset to defaults")
+            with get_connection() as conn:
+                c = conn.cursor()
+                c.execute("SELECT key, value FROM settings")
+                rows = c.fetchall()
+
+            if rows:
+                self._data = {row[0]: row[1] for row in rows}
+                self._sync_from_data()
+                logger.info("Settings loaded from database")
             else:
                 self._data = default_settings.copy()
                 self._sync_from_data()
                 await self.save()
-                logger.info("Created default settings.json")
-        except json.JSONDecodeError as e:
+                logger.info("Created default settings in database")
+        except Exception as e:
             logger.error(f"Error loading settings: {e}")
             self._data = default_settings.copy()
             self._sync_from_data()
@@ -53,17 +52,27 @@ class Settings:
         return self
 
     def _sync_from_data(self):
-        self.volume = self._data.get("volume", 1.0)
+        try:
+            self.volume = float(self._data.get("volume", 1.0))
+        except (ValueError, TypeError):
+            self.volume = 1.0
         self.baseurl = self._data.get("baseurl", DEFAULT_BASEURL)
 
     def _sync_to_data(self):
-        self._data["volume"] = self.volume
+        self._data["volume"] = str(self.volume)
         self._data["baseurl"] = self.baseurl
 
     async def save(self):
         self._sync_to_data()
-        async with aiofiles.open(settings_file, "w") as f:
-            await f.write(json.dumps(self._data, indent=2))
+        with get_connection() as conn:
+            c = conn.cursor()
+            c.execute("PRAGMA foreign_keys = ON")
+            for key, value in self._data.items():
+                c.execute(
+                    "INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)",
+                    (key, value),
+                )
+            conn.commit()
 
 
 _settings_instance: Settings | None = None
@@ -90,4 +99,16 @@ def get_volume() -> float:
 
 
 def get_baseurl() -> str:
-    return _settings_instance.baseurl.rstrip("/") if _settings_instance else DEFAULT_BASEURL
+    url = os.getenv("COPYPARTY_URL")
+    if not url:
+        logger.warning("COPYPARTY_URL not set! Using default http://localhost:3939")
+        return DEFAULT_BASEURL
+    return url.rstrip("/")
+
+
+def get_uploadurl() -> str:
+    url = os.getenv("COPYPARTY_URL_UPLOAD")
+    if not url:
+        logger.warning("COPYPARTY_URL_UPLOAD not set! Using default http://localhost:3939")
+        return DEFAULT_BASEURL
+    return url.rstrip("/")
diff --git a/cogs/utils/url_helper.py b/cogs/utils/url_helper.py
new file mode 100644
index 0000000..eac06f1
--- /dev/null
+++ b/cogs/utils/url_helper.py
@@ -0,0 +1,21 @@
+# This file is part of Senator Sperma
+# Licensed under the GPL-3.0 License
+# Copyright (C) 2026 Salmonik @ salmonik@tuta.io
+# https://codeberg.org/salmonik/senator-sperma
+
+
+def clean_url_for_ytdlp(url: str) -> str:
+    """Clean URL by removing everything after the first '&'.
+
+    This prevents yt-dlp from interpreting additional query parameters
+    (like &list=...) as playlist URLs.
+
+    Example:
+        Input: https://www.youtube.com/watch?v=lPGipwoJiOM&list=RDlPGipwoJiOM&
+        Output: https://www.youtube.com/watch?v=lPGipwoJiOM
+    """
+    # Find the first '&' and truncate
+    first_ampersand = url.find('&')
+    if first_ampersand != -1:
+        return url[:first_ampersand]
+    return url
diff --git a/cogs/vclogs.py b/cogs/vclogs.py
index fb0a2e0..e5ca202 100644
--- a/cogs/vclogs.py
+++ b/cogs/vclogs.py
@@ -4,7 +4,6 @@
 # https://codeberg.org/salmonik/senator-sperma
 
 import datetime
-import json
 import logging
 import os
 import asyncio
@@ -13,24 +12,66 @@ from discord.ext import commands
 from gtts import gTTS
 from cogs.voice import get_voice_manager
 from cogs.utils.settings import get_volume, save_settings
+from cogs.utils.database import get_connection, init_database
 
 import tempfile
 
 logger = logging.getLogger(__name__)
 
-ACTIVITY_FILE = os.path.join(tempfile.gettempdir(), 'voice_activity.json')
+init_database()
 
 
 def load_activity_data():
-    if os.path.exists(ACTIVITY_FILE):
-        with open(ACTIVITY_FILE, 'r') as f:
-            return json.load(f)
-    return {}
+    try:
+        with get_connection() as conn:
+            c = conn.cursor()
+            c.execute("SELECT user_id, join_time, total_active, total_afk, is_afk, afk_start, active_start, channel_name FROM voice_activity")
+            rows = c.fetchall()
+
+        return {
+            row[0]: {
+                "join_time": row[1],
+                "total_active": row[2],
+                "total_afk": row[3],
+                "is_afk": bool(row[4]),
+                "afk_start": row[5],
+                "active_start": row[6],
+                "channel_name": row[7],
+            }
+            for row in rows
+        }
+    except Exception as e:
+        logger.error(f"Error loading voice activity: {e}")
+        return {}
 
 
 def save_activity_data(data):
-    with open(ACTIVITY_FILE, 'w') as f:
-        json.dump(data, f, indent=4)
+    try:
+        with get_connection() as conn:
+            c = conn.cursor()
+            c.execute("PRAGMA foreign_keys = ON")
+
+            c.execute("DELETE FROM voice_activity")
+
+            for user_id, user_data in data.items():
+                c.execute(
+                    """INSERT INTO voice_activity (user_id, join_time, total_active, total_afk, is_afk, afk_start, active_start, channel_name)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+                    (
+                        user_id,
+                        user_data.get("join_time"),
+                        user_data.get("total_active", 0),
+                        user_data.get("total_afk", 0),
+                        int(user_data.get("is_afk", False)),
+                        user_data.get("afk_start"),
+                        user_data.get("active_start"),
+                        user_data.get("channel_name"),
+                    ),
+                )
+            conn.commit()
+        logger.info(f"Saved voice activity for {len(data)} users")
+    except Exception as e:
+        logger.error(f"Error saving voice activity: {e}")
 
 
 def format_duration(seconds):
@@ -104,9 +145,8 @@ class VcLogs(commands.Cog):
 
             if voice_client:
                 if is_playing:
-                    logger.info("voice already playing, stopping current audio")
-                    voice_client.stop()
-                    await asyncio.sleep(0.1)
+                    logger.info("voice already playing, skipping TTS")
+                    return
 
                 logger.info("preparing to play audio")
                 audio_source = discord.FFmpegPCMAudio(tts_file)
@@ -169,7 +209,7 @@ class VcLogs(commands.Cog):
             }
             save_activity_data(activity_data)
 
-            message = f"[{current_time}] {member.name} dołączył na {after.channel.name}"
+            message = f"[{current_time}] {member.name} dołączył na {after.channel.name} <t:{int(current_ts)}:R>"
             tts_text = f"{member.display_name} sie zespawnił"
             tts_channel = after.channel
             await log_channel.send(message)
@@ -190,7 +230,7 @@ class VcLogs(commands.Cog):
                 afk_str = format_duration(data['total_afk'])
 
                 message = (
-                    f"[{current_time}] {member.name} rozłączył się z {before.channel.name}\n"
+                    f"[{current_time}] {member.name} rozłączył się z {before.channel.name} <t:{int(current_ts)}:R>\n"
                     f"Aktywny: {active_str} | AFK: {afk_str}"
                 )
                 tts_text = f"{member.display_name} jest chujem"
@@ -201,7 +241,7 @@ class VcLogs(commands.Cog):
                 del activity_data[user_id]
                 save_activity_data(activity_data)
             else:
-                message = f"[{current_time}] {member.name} rozłączył się z {before.channel.name}"
+                message = f"[{current_time}] {member.name} rozłączył się z {before.channel.name} <t:{int(current_ts)}:R>"
                 tts_text = f"{member.display_name} jest chujem"
                 tts_channel = before.channel
                 await log_channel.send(message)
@@ -225,7 +265,7 @@ class VcLogs(commands.Cog):
                 else:
                     activity = "odgłuchnął"
 
-                message = ( f"[{current_time}] {member.name} {activity} się na {after.channel.name}\n"
+                message = ( f"[{current_time}] {member.name} {activity} się na {after.channel.name} <t:{int(current_ts)}:R>\n"
                                  f"AFK: {afk_str}" )
                 await log_channel.send(message)
                 logger.info(f"User returned from AFK: {message}")
@@ -245,7 +285,7 @@ class VcLogs(commands.Cog):
                     activity = "ogłuchnął"
 
                 active_str = format_duration(active_since_start)
-                message = ( f"[{current_time}] {member.name} {activity} się na {after.channel.name}\n"
+                message = ( f"[{current_time}] {member.name} {activity} się na {after.channel.name} <t:{int(current_ts)}:R>\n"
                                  f"Aktywny: {active_str}" )
                 await log_channel.send(message)
                 logger.info(f"User went AFK: {message}")
diff --git a/cogs/voice.py b/cogs/voice.py
index 319bb16..046c2a8 100644
--- a/cogs/voice.py
+++ b/cogs/voice.py
@@ -45,6 +45,7 @@ class VoiceManager:
                     return voice_client
                 except Exception as e:
                     logger.error(f"Failed to move voice client: {e}")
+                    logger.info("Disconnecting after failed move attempt")
                     try:
                         await voice_client.disconnect()
                     except Exception:
@@ -55,6 +56,25 @@ class VoiceManager:
                 voice_client = await channel.connect(timeout=30.0, reconnect=False)
                 logger.info(f"Connected to voice channel: {channel}")
                 return voice_client
+            except discord.ClientException as e:
+                if "Already connected" in str(e):
+                    logger.warning(f"Stale voice state detected, forcing disconnect and reconnect: {e}")
+                    voice_client = discord.utils.get(self.bot.voice_clients, guild=guild)
+                    if voice_client:
+                        try:
+                            await voice_client.disconnect()
+                        except Exception:
+                            pass
+                    await asyncio.sleep(0.3)
+                    try:
+                        voice_client = await channel.connect(timeout=30.0, reconnect=False)
+                        logger.info(f"Reconnected to voice channel: {channel}")
+                        return voice_client
+                    except Exception as e2:
+                        logger.error(f"Failed to reconnect after stale cleanup: {e2}")
+                        return None
+                logger.error(f"Failed to connect to voice channel: {e}")
+                return None
             except Exception as e:
                 logger.error(f"Failed to connect to voice channel: {e}")
                 return None
@@ -113,6 +133,7 @@ class VoiceManager:
         voice_client = await self.get_voice_client(guild)
         if voice_client:
             voice_client.stop()
+            logger.info("stop() called - disconnecting from voice")
             await voice_client.disconnect()
             logger.info(f"Stopped and disconnected from guild {guild}")
 
@@ -174,6 +195,7 @@ class Voice(commands.Cog):
 
         if voice_client and not voice_client.is_connected():
             try:
+                logger.info("Voice client exists but not connected - disconnecting stale client")
                 await voice_client.disconnect()
             except Exception:
                 pass
diff --git a/cogs/web.py b/cogs/web.py
index b072e99..fd22f9f 100644
--- a/cogs/web.py
+++ b/cogs/web.py
@@ -11,6 +11,7 @@ from bs4 import BeautifulSoup
 import urllib.parse
 import yt_dlp
 import logging
+from cogs.utils.url_helper import clean_url_for_ytdlp
 
 logger = logging.getLogger(__name__)
 
@@ -24,6 +25,7 @@ class Web(commands.Cog):
         if "youtube.com/watch" not in url:
             return None
 
+        url = clean_url_for_ytdlp(url)
         logger.info("youtube link")
         try:
             ydl_opts = {"quiet": True, "nowarnings": True}
@@ -34,18 +36,8 @@ class Web(commands.Cog):
             pass
         return None
 
-    def _create_button(self, index, link):
-        """Create a button for sending search result."""
-        button = discord.ui.Button(label=f"Send Result {index}")
-
-        async def button_callback(interaction: discord.Interaction):
-            await interaction.response.send_message(link.get("href"))
-
-        button.callback = button_callback
-        return button
-
     def _process_search_results(self, links, query):
-        """Process search results and create embed with buttons."""
+        """Process search results and create embed."""
         embed = Embed(title="Search Results", description=f"Top results for: {query}", color=0x1E90FF)
         view = discord.ui.View(disable_on_timeout=True)
 
@@ -56,8 +48,6 @@ class Web(commands.Cog):
                 title = youtube_title
 
             embed.add_field(name=f"Result {i}", value=f"[{title}]({link.get('href')})", inline=False)
-            button = self._create_button(i, link)
-            view.add_item(button)
 
         return embed, view
 
@@ -70,7 +60,7 @@ class Web(commands.Cog):
         ctx: discord.ApplicationContext,
         query: str
     ):
-        await ctx.defer(ephemeral=True)
+        await ctx.defer()
         headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"}
         encoded_query = urllib.parse.quote_plus(query)
         url = f"https://duckduckgo.com/html/?q={encoded_query}"
@@ -92,7 +82,7 @@ class Web(commands.Cog):
             return
 
         embed, view = self._process_search_results(links, query)
-        await ctx.respond(embed=embed, view=view, ephemeral=True)
+        await ctx.respond(embed=embed, view=view)
         logger.info("Search results sent")