Fix and integrate the conanjurer (Conan Exiles) bridge

Fixes the broken, never-loaded conanjurer module and wires it into the bot
following the project convention (cog in *_commands, logic in *_functions).

- conanjurer_functions.py: move 'from __future__' to the top (was a
  SyntaxError on line 6), drop duplicate import; config now comes from
  constants instead of dotenv/.env; guard optional deps (aiomcrcon,
  asyncssh) so the extension loads even when they are absent
- conanjurer_commands.py: single ConanModule(commands.Cog) with the
  standard (bot, logger_name)+setup() shape; owns its RconClient (no more
  undefined bot.cfg/bot.rcon); GM check uses CONAN_GM_ROLE_ID; commands
  report cleanly when RCON is unconfigured
- bot.py: load_extension('conanjurer_commands')
- constants.py: CONAN_* config (env-overridable); integration is dormant
  unless configured
- requirements_bot.txt: add aiomcrcon, asyncssh

Player-join notifications (task 2): watch_players() polls RCON
'listplayers', diffs against the previous set and announces new players on
CONAN_JOIN_CHANNEL_ID. Disabled when that channel is not defined (0).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

ai_functions.py

@@ -19,13 +19,26 @@ from constants import (
     OPENAICLIENT,
     SYSTEM_GPT_SETTINGS,
     WORD_REACTIONS,
+    CHEAP_MODEL,
+    LATEST_MODEL
 )
 
-#this do per user
+# this do per user
 VECTOR_STORE_ID = -1
+def select_model(req_type: str, algo: str) -> str:
+    # Jeżeli jawnie podano algorithm (i nie jest 'auto'/''):
+    if algo and str(algo).strip().lower() not in ("auto",):
+        # wyjątek: MUZYKA ma zawsze być tania — nadpisujemy TYLKO jeśli przyszedł domyślny 'gpt-4o'
+        if req_type == "MUSIC" and algo.strip() in (LATEST_MODEL,):
+            return CHEAP_MODEL
+        return algo
+    # Auto-dobór:
+    if req_type == "MUSIC":
+        return CHEAP_MODEL
+    return LATEST_MODEL
 
 
-async def _openai_call(messages, model, temperature=0.2):
+async def openai_call(messages, model, temperature=0.2):
     """
     Responses API dla 4o/4.1*, fallback Chat Completions dla gpt-3.5-turbo.
     Zwraca czysty string odpowiedzi.
@@ -47,23 +60,26 @@ async def _openai_call(messages, model, temperature=0.2):
 
     else:
         logger.info("4.0+")
-    # Responses API (zalecane dla 4o/4.1*)
+        # Responses API (zalecane dla 4o/4.1*)
         resp = await OPENAICLIENT.responses.create(
             model=model,
             temperature=temperature,
             input=messages,
         )
         # SDK zapewnia output_text dla zwykłych odpowiedzi
-        return (getattr(resp.output_text, "output_text", None) or "").strip() or str(resp.output_text)
+        return (getattr(resp.output_text, "output_text", None) or "").strip() or str(
+            resp.output_text
+        )
 
 
 def create_vector_store():
     # Create a vector store caled "Financial Statements"
     return OPENAICLIENT.beta.vector_stores.create_and_poll(name="Hammer Stash")
-    #expires_after={
-    #"anchor": "last_active_at",
-    #"days": 7}
-    #)
+    # expires_after={
+    # "anchor": "last_active_at",
+    # "days": 7}
+    # )
+
 
 def upload_files_to_vector_store(assistant):
 
@@ -71,15 +87,14 @@ def upload_files_to_vector_store(assistant):
     file_paths = ["edgar/goog-10k.pdf", "edgar/brka-10k.txt"]
     file_streams = [open(path, "rb") for path in file_paths]
 
-    #file = client.beta.vector_stores.files.create_and_poll(
-    #vector_store_id="vs_abc123",
-    #file_id="file-abc123"
-    #)
-    #batch = client.beta.vector_stores.file_batches.create_and_poll(
-    #vector_store_id="vs_abc123",
-    #file_ids=['file_1', 'file_2', 'file_3', 'file_4', 'file_5']
-    #)
-
+    # file = client.beta.vector_stores.files.create_and_poll(
+    # vector_store_id="vs_abc123",
+    # file_id="file-abc123"
+    # )
+    # batch = client.beta.vector_stores.file_batches.create_and_poll(
+    # vector_store_id="vs_abc123",
+    # file_ids=['file_1', 'file_2', 'file_3', 'file_4', 'file_5']
+    # )
 
     # Use the upload and poll SDK helper to upload the files, add them to the vector store,
     # and poll the status of the file batch for completion.
@@ -91,10 +106,11 @@ def upload_files_to_vector_store(assistant):
     print(file_batch.status)
     print(file_batch.file_counts)
     assistant = OPENAICLIENT.beta.assistants.update(
-    assistant_id=assistant.id,
-    tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}},
+        assistant_id=assistant.id,
+        tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}},
     )
 
+
 def delete_files_from_vector_store(assistant, file_id):
     result = OPENAICLIENT.beta.vector_stores.file_batches.delete(
         vector_store_id=VECTOR_STORE_ID, files=file_id
@@ -103,8 +119,8 @@ def delete_files_from_vector_store(assistant, file_id):
     # You can print the status and the file counts of the batch to see the result of this operation.
     print(result)
     assistant = OPENAICLIENT.beta.assistants.update(
-    assistant_id=assistant.id,
-    tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}},
+        assistant_id=assistant.id,
+        tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}},
     )
 
 
@@ -133,7 +149,15 @@ def num_tokens_from_string(message, model):
 
 
 async def handle_response(
-    prompt, vykidailo, bartender, history, username, request_type, algorithm="gpt-4o", none_request=""
+    prompt,
+    vykidailo,
+    bartender,
+    history,
+    username,
+    request_type,
+    algorithm="gpt-4o",
+    none_request="",
+    internal_retry: bool = False
 ):
     """
     Handle responses by appending them to a history, use OpenAI to
@@ -157,104 +181,83 @@ async def handle_response(
     """
     logger = logging.getLogger("discord")
     logger.info("Wywolanie procedury openai z promptem: %s", prompt)
-    temp = {"role": "user", "content": username + ":" + prompt}
     if vykidailo or bartender:
         logger.info("Administrator coś chciał")
-    history.append(temp)
-    if request_type == "MUSIC":
-        with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as file_music_memory:
-            # First we load existing data into a dict.
-            file_data = json.load(file_music_memory)
-            # Join new_data with file_data inside emp_details
-            file_data.append(temp)
-            file_music_memory.seek(0)
-            # convert back to json.
-            json.dump(file_data, file_music_memory, indent=4)
-    elif request_type == "RANDOM":
-        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
-            # First we load existing data into a dict.
-            file_data = json.load(file_memory)
-            # Join new_data with file_data inside emp_details
-            file_data.append(temp)
-            file_memory.seek(0)
-            # convert back to json.
-            json.dump(file_data, file_memory, indent=4)
-    elif request_type == "GENERAL":
-        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
-            # First we load existing data into a dict.
-            file_data = json.load(file_memory)
-            # Join new_data with file_data inside emp_details
-            file_data.append(temp)
-            file_memory.seek(0)
-            # convert back to json.
-            json.dump(file_data, file_memory, indent=4)
-    history = []
-    if request_type != "NONE":
-        history.append(GPT_SETTINGS[0])
-        chat_gpt_config_request_size = num_tokens_from_string(GPT_SETTINGS[0], "gpt-4")
+    model_to_use = select_model(request_type, algorithm)
+    logger.info("Wybrany model: %s", model_to_use)
+    if request_type == "MUSIC" and model_to_use == "gpt-4o-mini":
+        try:
+            # nic — normalnie pójdzie Responses API
+            pass
+        except Exception:
+            model_to_use = "gpt-3.5-turbo"
+    # --- 2) Budowa historii (token budget + reguły systemowe) ---
+    # NOTE: ignorujemy przekazany 'history' jako listę (tak było wcześniej),
+    # ale zwracamy aktualną tablicę do nadpisania w miejscach wołania (back-compat).
+    base_system = GPT_SETTINGS[0]  # zakładamy {"role":"system","content":...}
+    history_msgs = []
 
+    if request_type != "NONE":
+        history_msgs.append(base_system)
+        chat_gpt_config_request_size = num_tokens_from_string(base_system, "gpt-4")
+
+        # Dynamiczne mikro-reguły (WORD_REACTIONS), jak w Twoim kodzie
         for slowo, reakcja in WORD_REACTIONS.items():
             if not reakcja[3]:
-                content = (
-                    "Kiedy słyszysz "
-                    + slowo
-                    + " to reagujesz lub dzieje się to "
-                    + reakcja[0]
-                )
-                temp = {"role": "system", "content": content}
-                chat_gpt_config_request_size += num_tokens_from_string(temp, "gpt-4")
-                history.append(temp)
+                content = f"Kiedy słyszysz {slowo} to reagujesz lub dzieje się to {reakcja[0]}"
+                sys_msg = {"role": "system", "content": content}
+                chat_gpt_config_request_size += num_tokens_from_string(sys_msg, "gpt-4")
+                history_msgs.append(sys_msg)
 
-        final_prompt = username + ":" + prompt
-        logger.debug(
-            "Rozmiar zapytania przed dodaniem historii %s", chat_gpt_config_request_size
-        )
+        # wybór właściwej tablicy pamięci i budżetu
         if request_type == "MUSIC":
             table = MESSAGE_TABLE_MUZYKA
             token_amount = 10700
-        elif request_type == "RANDOM":
-            table = MESSAGE_TABLE
-            token_amount = 10700
-        elif request_type == "GENERAL":
+        elif request_type in ("RANDOM", "GENERAL"):
             table = MESSAGE_TABLE
             token_amount = 10700
         else:
             table = []
             token_amount = 10000
 
+        # doklejanie historii od końca aż do limitu (zachowana kolejność czasowa)
+        final_prompt = f"{username}:{prompt}"
+        prompt_gpt_request_size = num_tokens_from_string({"role": "user", "content": final_prompt}, "gpt-4")
+
+        acc = []
+        for msg in reversed(table):
+            t = num_tokens_from_string(msg, "gpt-4")
+            if chat_gpt_config_request_size + prompt_gpt_request_size + t <= token_amount:
+                acc.append(msg)
+                chat_gpt_config_request_size += t
+            else:
+                break
+        # przywróć chronologicznie
+        history_msgs.extend(reversed(acc))
+
+        # aktualny prompt
+        history_msgs.append({"role": "user", "content": final_prompt})
+        logger.info("Rozmiar zapytania (tok): %s", prompt_gpt_request_size)  # tokeny już policzone wyżej
 
-        prompt_gpt_request_size = num_tokens_from_string(
-            {"role": "user", "content": final_prompt}, "gpt-4"
-        )
-        temptable = []
-        for i in reversed(table):
-            temp_token = num_tokens_from_string(i, "gpt-4")
-            logger.debug(
-                "Rozmiar zapytania %s prompt %s temp %s",
-                chat_gpt_config_request_size,
-                prompt_gpt_request_size,
-                temp_token,
-            )
-            if (
-                chat_gpt_config_request_size
-                < token_amount + prompt_gpt_request_size + temp_token
-            ):
-                temptable.insert(1, i)
-                chat_gpt_config_request_size += temp_token
-        history.extend(temptable)
-        temp = {"role": "user", "content": final_prompt}
-        history.append(temp)
     else:
-        history = none_request
-    logger.info("Rozmiar zapytania po wyslaniu %s", chat_gpt_config_request_size)
+        # --- tryb NONE: nie dotykamy pamięci i pozwalamy przekazać własny 'none_request' ---
+        if isinstance(none_request, list):
+            history_msgs = none_request
+        elif isinstance(none_request, str) and none_request.strip():
+            history_msgs = [{"role": "user", "content": none_request}]
+        else:
+            history_msgs = [{"role": "user", "content": f"{username}:{prompt}"}]
+
+        logger.info("Rozmiar zapytania (tok): %s", "n/a")  # tokeny już policzone wyżej
+
     try:
         # ...przygotowanie messages/system prompt/itp. jak masz...
         # retry/backoff + deadline (zachowuje Twoją semantykę logowania)
         timeout_sec = 120
         deadline = time.time() + timeout_sec
         response = await asyncio.wait_for(
-            _openai_call(messages=history, model=algorithm),
-            timeout=max(0.1, deadline - time.time())
+            openai_call(messages=history_msgs, model=model_to_use),
+            timeout=max(0.1, deadline - time.time()),
         )
 
     except openai.APITimeoutError as e:
@@ -264,26 +267,33 @@ async def handle_response(
         response = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai. *Na ekranie pojawia się*: {e}"
     except openai.BadRequestError as e:
         # Handle invalid request error, e.g. validate parameters or log
-        resp, _ = await handle_response(
-            f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'",
-            True,
-            True,
-            MESSAGE_TABLE,
-            username,
-            "RANDOM",
-        )
-        response = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
+        if internal_retry:
+            resp = "Nie umiem tego teraz ładnie wytłumaczyć — OpenAI mnie zastrzeliło."
+        else:
+            resp, _ = await handle_response(
+
+                f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'",
+                True,
+                True,
+                MESSAGE_TABLE,
+                username,
+                "RANDOM",
+            )
+            response = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
     except openai.APIResponseValidationError as e:
         # Handle invalid request error, e.g. validate parameters or log
-        resp, _ = await handle_response(
-            f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'",
-            True,
-            True,
-            MESSAGE_TABLE,
-            username,
-            "RANDOM",
-        )
-        response = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
+        if internal_retry:
+            resp = "Nie umiem tego teraz ładnie wytłumaczyć — OpenAI mnie zastrzeliło."
+        else:
+            resp, _ = await handle_response(
+                f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'",
+                True,
+                True,
+                MESSAGE_TABLE,
+                username,
+                "RANDOM",
+            )
+            response = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
     except openai.AuthenticationError as e:
         # Handle authentication error, e.g. check credentials or log
         response = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z hasłem zjebało. *Na terminalu pojawia się:* {e}"
@@ -299,43 +309,31 @@ async def handle_response(
         response = f"*Kondziu nurkuje za bar, terminal wybucha. Przed tobą ląduje pergamin zapisany pięknym gotykiem a na nim*: {e}"
 
     logger.info("Historia wysłana:")
-    logger.info(history)
-    await asyncio.sleep(15)
-    temp = {"role": "assistant", "content": response}
-    history.append(temp)
+    temp_assistant = {"role": "assistant", "content": response}
+    logger.info(temp_assistant)
     if request_type == "MUSIC":
-        with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as file_music_memory:
-            # First we load existing data into a dict.
-            file_data = json.load(file_music_memory)
-            # Join new_data with file_data inside emp_details
-            file_data.append(temp)
-            file_music_memory.seek(0)
-            # convert back to json.
-            json.dump(file_data, file_music_memory, indent=4)
+        # zapis do pliku MUZYKA
+        with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as fh:
+            file_data = json.load(fh)
+            file_data.append({"role": "user", "content": f"{username}:{prompt}"})
+            file_data.append(temp_assistant)
+            fh.seek(0)
+            json.dump(file_data, fh, indent=4)
         return response, MESSAGE_TABLE_MUZYKA
-    elif request_type == "RANDOM":
-        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
-            # First we load existing data into a dict.
-            file_data = json.load(file_memory)
-            # Join new_data with file_data inside emp_details
-            file_data.append(temp)
-            file_memory.seek(0)
-            # convert back to json.
-            json.dump(file_data, file_memory, indent=4)
+
+    elif request_type in ("RANDOM", "GENERAL"):
+        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as fh:
+            file_data = json.load(fh)
+            file_data.append({"role": "user", "content": f"{username}:{prompt}"})
+            file_data.append(temp_assistant)
+            fh.seek(0)
+            json.dump(file_data, fh, indent=4)
         return response, MESSAGE_TABLE
-    elif request_type == "GENERAL":
-        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
-            # First we load existing data into a dict.
-            file_data = json.load(file_memory)
-            # Join new_data with file_data inside emp_details
-            file_data.append(temp)
-            file_memory.seek(0)
-            # convert back to json.
-            json.dump(file_data, file_memory, indent=4)
-        return response, MESSAGE_TABLE
-    else:
+
+    else:  # NONE
         return response, []
 
+
 async def get_random_cyclic_message(client):
     """
     The function `get_random_cyclic_message` returns a random cyclic message from a list of cyclic
@@ -438,7 +436,7 @@ async def chat_with_assistant(message, assistant_name):
                 logger.info(block.text.value)
                 chat_response += block.text.value
                 await discord_friendly_send(message.channel, chat_response)
-                #await message.channel.send(chat_response)
+                # await message.channel.send(chat_response)
             done = True
         elif run.status == "cancelled":
             await discord_friendly_send(message.channel, "Cos sie wywaliło")

cogs/music.py

@@ -1,46 +0,0 @@
-import discord
-from discord.ext import commands
-from typing import  Optional
-
-class Music(commands.Cog):
-    def __init__(self, bot):
-        self.bot = bot # This is so you can access Bot instance in your cog
-
-# You must have this function for `bot.load_extension` to call
-def setup(bot):
-    bot.add_cog(Music(bot))
-
-@commands.hybrid_command(
-    name="przytul", description="Przytul kogoś - daj mention po komendzie :)"
-)
-async def przytul(ctx, arg: Optional[discord.Member] = None):
-    """
-    Generate a text about hugging mentioned user.
-
-    :param ctx: ctx stands for "context" and is a required parameter in Discord.py commands. It
-    represents the context in which the command was invoked, including information such as the message,
-    the channel, the server, and the user who invoked the command
-    :param arg: arg is a parameter of the function "przytul" that expects a Discord member object. The
-    parameter is optional, meaning that if no member object is provided, it will default to None
-    :type arg: Optional[discord.Member]
-    """
-    async with ctx.typing():
-        nieprzytulac = False
-        for mention in ctx.message.mentions:
-            for role in mention.roles:
-                if role.name == "NIEPRZYTULAĆ!":
-                    nieprzytulac = True
-
-        if arg and nieprzytulac:
-            await ctx.send(
-                f"Żebym ja Ciebie nie przytulił {ctx.message.author.mention}"
-            )
-        elif arg:
-            await ctx.send(
-                # trunk-ignore(codespell/misspelled)
-                f"Już dobrze.... Już dobrze... Ojej.. Biedactwo... :( *W ułamku sekundy {arg.mention} znajduje sie w duszącym uścisku. Żebra trzeszczą - kilka pęka. Pacnięcia po plecach grożą odbiciem nerek, a głaskanie po głowie powoduje wstrząs mózgu*"
-            )
-        else:
-            await ctx.send(
-                "Kogo mam przytulić? *Wyłamuje kostki i przeciąga się - jego 200 kilowa sylwetka złożona z samych mięśni świadczy o tym że jest gotowy*"
-            )

communication_subroutine.py

@@ -1,17 +1,20 @@
 import json
 import logging
+import os
 import re
 import threading
 import time
 from queue import Empty, Queue
+from typing import Optional
 from urllib import request as urequest
 
-from flask import Flask, jsonify, request
+from flask import Flask, abort, jsonify, request
 from waitress import serve
 
-HOST_ADDRESS = "192.168.1.191"
-PORT_ADDRESS = 5000
-ICECAST_ADDRESS = "http://192.168.1.15:8000"
+HOST_ADDRESS = os.getenv("CONJURER_DISCORD_HOST", "192.168.1.31")
+PORT_ADDRESS = int(os.getenv("CONJURER_DISCORD_PORT", "5000"))
+ICECAST_ADDRESS = os.getenv("CONJURER_ICECAST", "http://192.168.1.15:8000")
+API_KEY = os.getenv("CONJURER_API_KEY")
 OUT_COMM_Q = Queue()
 IN_COMM_Q = Queue()
 SRCHTITLE = re.compile(rb"StreamTitle=\\*(?P<title>[^;]*);").search
@@ -19,6 +22,12 @@ SRCHTITLE = re.compile(rb"StreamTitle=\\*(?P<title>[^;]*);").search
 awaiting_q = []
 incoming_q = Queue()
 app = Flask(__name__)
+
+
+def _authorize_request() -> None:
+    """Reject inbound calls lacking the shared key (no-op if key is unset)."""
+    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
+        abort(401)
 PREPPED_TRACKS = {
     "requests": "",
     "hit": "",
@@ -53,6 +62,7 @@ class QueryControl:
 
 @app.route("/prepped_tracks", methods=["POST"])
 def log_radio_tracks():
+    _authorize_request()
     app.logger = logging.getLogger("discord")
 
     app.logger.info(request)
@@ -85,6 +95,7 @@ def answer_external_command():
     :return: The function `answer_external_command()` is returning a JSON response with the message
     "SUCCESS".
     """
+    _authorize_request()
     logger = logging.getLogger("discord")
     logger.info(request)
     record = json.loads(request.data)
@@ -129,34 +140,42 @@ def waitress_run():
     serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
 
 
-def scan_queue():
+def scan_queue(stop_event: Optional[threading.Event] = None):
     """
     The function `scan_queue` reads data from a queue, logs it, and appends it to another queue.
 
-    :param _logger: The `_logger` parameter is typically an instance of a logging object that is used to
-    record and store log messages. It is commonly used to track the flow of the program, record errors,
-    and provide information for debugging purposes. In this code snippet, the `_logger` object is used
-    to log the
+    A bounded ``get(timeout=1)`` is used instead of a blocking ``get()`` so the
+    worker can observe ``stop_event`` and exit cleanly during shutdown.
+
+    :param stop_event: optional :class:`threading.Event`; when set the loop
+    stops at the next iteration.
     """
     logger = logging.getLogger("discord")
     while True:
-        data = OUT_COMM_Q.get()
+        if stop_event and stop_event.is_set():
+            logger.info("scan_queue: stop requested")
+            break
+        try:
+            data = OUT_COMM_Q.get(timeout=1)
+        except Empty:
+            continue
         logger.info(data)
         awaiting_q.append(data)
 
 
-def scan_incoming():
+def scan_incoming(stop_event: Optional[threading.Event] = None):
     """
     The `scan_incoming` function continuously checks for incoming data, processes it, and logs when data
     is found.
 
-    :param _logger: The `_logger` parameter in the `scan_incoming` function is a logger object that is
-    used to log messages or information during the execution of the function. It is typically used for
-    debugging, monitoring, or tracking the flow of the program. In this case, the `_logger` is being
-    used
+    :param stop_event: optional :class:`threading.Event`; when set the loop
+    stops at the next iteration.
     """
     logger = logging.getLogger("discord")
     while True:
+        if stop_event and stop_event.is_set():
+            logger.info("scan_incoming: stop requested")
+            break
         try:
             answer = incoming_q.get(block=False)
             logger.info("DATA FOUND")
@@ -204,27 +223,45 @@ def id3(url: str) -> dict:
         return tagdata
 
 
-def comm_subroutine():
+def comm_subroutine(stop_event: Optional[threading.Event] = None):
     """
     The `comm_subroutine` function starts multiple threads to run different tasks concurrently.
 
-    :param logger: The `logger` parameter in the `comm_subroutine` function is an instance of a logger
-    object that is used for logging messages at various levels (e.g., debug, info, warning, error). In
-    the provided code snippet, the logger is used to log messages at the "info" level
+    Workers run as daemon threads and honour an optional ``stop_event`` so the
+    bot can shut the communication layer down cleanly instead of blocking
+    forever on ``join()``.
+
+    :param stop_event: optional :class:`threading.Event` shared with the caller
+    to coordinate a cooperative shutdown.
     """
     # logger.setLevel(logging.DEBUG)
     logger = logging.getLogger("discord")
     logger.info("Started comms")
     threads = []
     # threads.append(threading.Thread(target=flask_debug))
-    threads.append(threading.Thread(target=waitress_run))
-    threads.append(threading.Thread(target=scan_queue))
-    threads.append(threading.Thread(target=scan_incoming))
+    threads.append(threading.Thread(target=waitress_run, daemon=True))
+    threads.append(
+        threading.Thread(
+            target=scan_queue, kwargs={"stop_event": stop_event}, daemon=True
+        )
+    )
+    threads.append(
+        threading.Thread(
+            target=scan_incoming, kwargs={"stop_event": stop_event}, daemon=True
+        )
+    )
 
     for worker in threads:
         worker.start()
-    for worker in threads:
-        worker.join()
+
+    try:
+        while any(thread.is_alive() for thread in threads):
+            if stop_event and stop_event.is_set():
+                break
+            time.sleep(0.5)
+    finally:
+        if stop_event:
+            stop_event.set()
 
 
 if __name__ == "__main__":

conanjurer_commands.py

@@ -0,0 +1,217 @@
+# This Python file uses the following encoding: utf-8
+"""Conan Exiles <-> Discord bridge (cog).
+
+Follows the project convention (cog here, helpers in
+``conanjurer_functions.py``).  The integration is dormant unless configured in
+:mod:`constants`: with no RCON host / channels the background watchers simply
+do not start and the GM commands report that RCON is unavailable, so loading
+this extension is always safe even on hosts without a Conan server.
+"""
+import asyncio
+import logging
+
+import discord
+from discord.ext import commands
+
+from conanjurer_functions import ConanConfig, Event, RconClient, watch, watch_players
+from constants import (
+    CONAN_CHAT_CHANNEL_ID,
+    CONAN_EVENTS_CHANNEL_ID,
+    CONAN_GM_ROLE_ID,
+    CONAN_JOIN_CHANNEL_ID,
+    CONAN_LOG_MODE,
+    CONAN_LOG_PATH,
+    CONAN_PLAYER_POLL_SECONDS,
+    CONAN_RCON_HOST,
+    CONAN_RCON_PASSWORD,
+    CONAN_RCON_PORT,
+    CONAN_SFTP_HOST,
+    CONAN_SFTP_PASSWORD,
+    CONAN_SFTP_PORT,
+    CONAN_SFTP_USER,
+)
+
+
+def is_gm():
+    """Allow only members holding the configured Conan GM role."""
+
+    async def predicate(ctx: commands.Context) -> bool:
+        if not CONAN_GM_ROLE_ID:
+            await ctx.reply(
+                "⛔ Rola GM Conana nie jest skonfigurowana.", mention_author=False
+            )
+            return False
+        ok = any(r.id == CONAN_GM_ROLE_ID for r in getattr(ctx.author, "roles", []))
+        if not ok:
+            await ctx.reply("⛔ Tylko GM.", mention_author=False)
+        return ok
+
+    return commands.check(predicate)
+
+
+class ConanModule(commands.Cog):
+    """Bridges a Conan Exiles server with Discord over RCON + log following."""
+
+    def __init__(self, bot, logger_name):
+        self.bot = bot
+        self.logger = logging.getLogger(logger_name)
+        self.cfg = ConanConfig(
+            rcon_host=CONAN_RCON_HOST,
+            rcon_port=CONAN_RCON_PORT,
+            rcon_password=CONAN_RCON_PASSWORD,
+            log_mode=CONAN_LOG_MODE,
+            log_path=CONAN_LOG_PATH,
+            sftp_host=CONAN_SFTP_HOST,
+            sftp_port=CONAN_SFTP_PORT,
+            sftp_user=CONAN_SFTP_USER,
+            sftp_password=CONAN_SFTP_PASSWORD,
+        )
+        self.rcon = (
+            RconClient(CONAN_RCON_HOST, CONAN_RCON_PORT, CONAN_RCON_PASSWORD)
+            if self.cfg.rcon_enabled
+            else None
+        )
+        self._log_task = None
+        self._player_task = None
+
+    async def cog_load(self):
+        # Conan -> Discord chat/event mirroring (only with a log source + target)
+        if self.cfg.log_enabled and (CONAN_CHAT_CHANNEL_ID or CONAN_EVENTS_CHANNEL_ID):
+            self._log_task = asyncio.create_task(self._run_log_watch())
+        else:
+            self.logger.info("Conan: log watch disabled (not configured)")
+
+        # Player-join notifications — disabled when the channel is not defined
+        if CONAN_JOIN_CHANNEL_ID and self.rcon is not None:
+            self._player_task = asyncio.create_task(self._run_player_watch())
+        else:
+            self.logger.info(
+                "Conan: player-join notifications disabled (no channel or RCON)"
+            )
+
+    async def cog_unload(self):
+        for task in (self._log_task, self._player_task):
+            if task is not None:
+                task.cancel()
+        if self.rcon is not None:
+            await self.rcon.close()
+
+    # ---------------------------------------------------------------- watchers
+    async def _run_log_watch(self):
+        await self.bot.wait_until_ready()
+        chat_ch = (
+            self.bot.get_channel(CONAN_CHAT_CHANNEL_ID) if CONAN_CHAT_CHANNEL_ID else None
+        )
+        evt_ch = (
+            self.bot.get_channel(CONAN_EVENTS_CHANNEL_ID)
+            if CONAN_EVENTS_CHANNEL_ID
+            else None
+        )
+
+        async def on_event(event: Event):
+            target = chat_ch if event.kind == "chat" else evt_ch
+            if target is not None:
+                await target.send(
+                    event.text, allowed_mentions=discord.AllowedMentions.none()
+                )
+
+        self.logger.info("Conan: starting log watch (mode=%s)", self.cfg.log_mode)
+        await watch(self.cfg, on_event)
+
+    async def _run_player_watch(self):
+        """Task 2: announce on a defined channel when a player joins the server."""
+        await self.bot.wait_until_ready()
+        channel = self.bot.get_channel(CONAN_JOIN_CHANNEL_ID)
+        if channel is None:
+            self.logger.warning(
+                "Conan: join channel %s not found — player notifications off",
+                CONAN_JOIN_CHANNEL_ID,
+            )
+            return
+
+        async def on_join(name: str):
+            await channel.send(
+                f"🟢 **{name}** wszedł na serwer Conan",
+                allowed_mentions=discord.AllowedMentions.none(),
+            )
+
+        self.logger.info(
+            "Conan: starting player-join watch (channel=%s, every %ss)",
+            CONAN_JOIN_CHANNEL_ID,
+            CONAN_PLAYER_POLL_SECONDS,
+        )
+        await watch_players(self.rcon, CONAN_PLAYER_POLL_SECONDS, on_join)
+
+    # ----------------------------------------------------- Discord -> Conan
+    async def _require_rcon(self, ctx: commands.Context):
+        if self.rcon is None:
+            await ctx.reply(
+                "⛔ RCON Conana nie jest skonfigurowany/dostępny.",
+                mention_author=False,
+            )
+            return None
+        return self.rcon
+
+    @commands.command(name="say")
+    @is_gm()
+    async def say(self, ctx: commands.Context, *, message: str):
+        """Discord -> Conan: ogłoszenie widoczne dla wszystkich graczy w grze."""
+        rcon = await self._require_rcon(ctx)
+        if rcon is None:
+            return
+        resp = await rcon.command(f"broadcast {message}")
+        await ctx.reply(
+            f"✅ Wysłano do gry. (serwer: `{resp.strip() or 'OK'}`)",
+            mention_author=False,
+        )
+
+    @commands.command(name="players")
+    @is_gm()
+    async def players(self, ctx: commands.Context):
+        """Lista graczy online (RCON listplayers)."""
+        rcon = await self._require_rcon(ctx)
+        if rcon is None:
+            return
+        resp = await rcon.command("listplayers")
+        await ctx.reply(
+            f"```\n{resp.strip() or 'brak danych'}\n```", mention_author=False
+        )
+
+    @commands.command(name="kick")
+    @is_gm()
+    async def kick(self, ctx: commands.Context, *, who: str):
+        """Wyrzuć gracza (po nazwie/charname — zależnie od wersji serwera)."""
+        rcon = await self._require_rcon(ctx)
+        if rcon is None:
+            return
+        resp = await rcon.command(f"kick {who}")
+        await ctx.reply(f"👢 `{resp.strip() or 'OK'}`", mention_author=False)
+
+    @commands.command(name="rcon")
+    @is_gm()
+    async def raw_rcon(self, ctx: commands.Context, *, cmd: str):
+        """Surowa komenda RCON (dla zaawansowanych GM). Używaj ostrożnie."""
+        rcon = await self._require_rcon(ctx)
+        if rcon is None:
+            return
+        resp = await rcon.command(cmd)
+        await ctx.reply(f"```\n{resp.strip() or 'OK'}\n```", mention_author=False)
+
+    @commands.command(name="ogłoś", aliases=["oglos", "rp"])
+    @is_gm()
+    async def rp_announce(self, ctx: commands.Context, nadawca: str, *, message: str):
+        """Wiadomość RP 'z nadawcą' (np. ogłoszenie w imieniu Króla Khasara).
+
+        Na samym RCON realizujemy to jako sformatowany broadcast.
+        """
+        rcon = await self._require_rcon(ctx)
+        if rcon is None:
+            return
+        resp = await rcon.command(f"broadcast [{nadawca}]: {message}")
+        await ctx.reply(f"📜 Ogłoszono jako **{nadawca}**.", mention_author=False)
+
+
+async def setup(bot):
+    logger = logging.getLogger("discord")
+    await bot.add_cog(ConanModule(bot, "discord"))
+    logger.info("Loading conanjurer commands module done")

conanjurer_functions.py

@@ -0,0 +1,266 @@
+# This Python file uses the following encoding: utf-8
+"""Helper logic for the Conan Exiles <-> Discord bridge.
+
+Mirrors the project layout: the cog lives in ``conanjurer_commands.py`` and the
+reusable logic lives here.  Configuration comes from :mod:`constants` (env-var
+overridable); optional third-party dependencies (``aiomcrcon``/``asyncssh``)
+are imported defensively so the main bot can still load the extension when the
+Conan integration is not installed or not in use.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import re
+from dataclasses import dataclass
+from typing import AsyncIterator, Awaitable, Callable, Optional, Set
+
+try:
+    from aiomcrcon import Client as _Rcon  # Source RCON over TCP
+except ImportError:  # pragma: no cover - optional component
+    _Rcon = None
+
+try:
+    import asyncssh
+except ImportError:  # pragma: no cover - optional component
+    asyncssh = None
+
+logger = logging.getLogger("discord")
+
+
+@dataclass
+class Event:
+    kind: str  # "chat" | "login" | "logout" | "death" | "raw"
+    text: str  # ready-to-display text
+    raw: str   # original line (for debugging)
+
+
+@dataclass
+class ConanConfig:
+    """Runtime configuration for the bridge, built from :mod:`constants`."""
+
+    rcon_host: str
+    rcon_port: int
+    rcon_password: str
+    log_mode: str  # "local" | "sftp"
+    log_path: str
+    sftp_host: str
+    sftp_port: int
+    sftp_user: str
+    sftp_password: str
+
+    @property
+    def rcon_enabled(self) -> bool:
+        """RCON usable only when host+password are set and the lib is present."""
+        return bool(self.rcon_host and self.rcon_password and _Rcon is not None)
+
+    @property
+    def log_enabled(self) -> bool:
+        """Log following usable only when its prerequisites are configured."""
+        if not self.log_path:
+            return False
+        if self.log_mode == "sftp":
+            return bool(self.sftp_host and asyncssh is not None)
+        return True
+
+
+# --- REGEXY DO DOSTROJENIA NA WŁASNYM LOGU ---
+# Conan/Pippi/Tot logują różnie — dopasuj do swojego logu. Linie niepasujące są
+# ignorowane (nie zgadujemy).
+_PATTERNS: list[tuple[str, re.Pattern]] = [
+    ("chat", re.compile(r"Chat:\s*(?P<who>.+?):\s*(?P<msg>.+)$", re.I)),
+    ("login", re.compile(r"(?P<who>.+?)\s+(joined|connected|logged in)", re.I)),
+    ("logout", re.compile(r"(?P<who>.+?)\s+(left|disconnected|logged out)", re.I)),
+    ("death", re.compile(r"(?P<who>.+?)\s+was killed by\s+(?P<by>.+)$", re.I)),
+]
+
+
+class RconClient:
+    """Thin async wrapper around a Source-RCON connection to the Conan server."""
+
+    def __init__(self, host: str, port: int, password: str):
+        self._host, self._port, self._pw = host, port, password
+        self._client: Optional["_Rcon"] = None
+        self._lock = asyncio.Lock()
+
+    async def _ensure(self) -> "_Rcon":
+        if _Rcon is None:
+            raise RuntimeError("aiomcrcon not installed — RCON unavailable")
+        if self._client is None:
+            client = _Rcon(self._host, self._port, self._pw)
+            await client.connect()
+            self._client = client
+            logger.info("RCON connected %s:%s", self._host, self._port)
+        return self._client
+
+    async def command(self, cmd: str) -> str:
+        """Send a command to the Conan server and return its response.
+
+        Discord -> Conan channel, e.g. ``command("broadcast Hi!")``.
+        """
+        async with self._lock:
+            for attempt in (1, 2):
+                try:
+                    client = await self._ensure()
+                    resp, _ = await client.send_cmd(cmd)
+                    return resp
+                except Exception as exc:  # disconnect / server restart
+                    logger.warning("RCON error (attempt %s): %s", attempt, exc)
+                    await self.close()
+                    if attempt == 2:
+                        raise
+                    await asyncio.sleep(1.0)
+            return ""
+
+    async def close(self) -> None:
+        if self._client is not None:
+            try:
+                await self._client.close()
+            except Exception:  # pragma: no cover - best effort
+                pass
+            self._client = None
+
+
+def parse_line(line: str) -> Optional[Event]:
+    line = line.rstrip("\n")
+    if not line.strip():
+        return None
+    for kind, pat in _PATTERNS:
+        match = pat.search(line)
+        if match:
+            g = match.groupdict()
+            if kind == "chat":
+                return Event(kind, f"💬 **{g['who']}**: {g['msg']}", line)
+            if kind == "login":
+                return Event(kind, f"🟢 **{g['who']}** dołączył do gry", line)
+            if kind == "logout":
+                return Event(kind, f"⚪ **{g['who']}** opuścił grę", line)
+            if kind == "death":
+                return Event(kind, f"💀 **{g['who']}** zginął z ręki {g['by']}", line)
+    return None  # nierozpoznane -> ignoruj
+
+
+def parse_players(listplayers_output: str) -> Set[str]:
+    """Extract the set of connected player char-names from RCON ``listplayers``.
+
+    Conan's table is roughly::
+
+        Idx | Char name | Player name | User ID | Platform ID | Platform Name
+        0   | Conan     | SomeUser    | 12345   | 765...      | Steam
+
+    The char-name column (index 1) is used.  The exact format varies between
+    server builds, so this is best-effort and intentionally tunable.
+    """
+    players: Set[str] = set()
+    for raw in listplayers_output.splitlines():
+        line = raw.strip()
+        if not line or "|" not in line:
+            continue
+        cols = [c.strip() for c in line.split("|")]
+        head = cols[0].lower()
+        # skip the header row and any separator rows (e.g. "---|---")
+        if head in ("idx", "") or set(cols[0]) <= set("-"):
+            continue
+        if len(cols) >= 2 and cols[1]:
+            players.add(cols[1])
+    return players
+
+
+async def watch_players(
+    rcon: RconClient,
+    interval: float,
+    on_join: Callable[[str], Awaitable[None]],
+) -> None:
+    """Poll RCON ``listplayers`` and call *on_join* for each new player.
+
+    The first poll seeds the known-player set without announcing, so restarting
+    the bot does not re-announce everyone already online.  RCON failures are
+    logged and retried on the next tick rather than killing the task.
+    """
+    known: Optional[Set[str]] = None
+    while True:
+        try:
+            response = await rcon.command("listplayers")
+            current = parse_players(response)
+            if known is None:
+                known = current
+            else:
+                for name in current - known:
+                    try:
+                        await on_join(name)
+                    except Exception:  # pragma: no cover - handler guard
+                        logger.exception("Conan: on_join handler failed")
+                known = current
+        except Exception as exc:
+            logger.warning("Conan: player poll failed: %s", exc)
+        await asyncio.sleep(interval)
+
+
+async def _follow_local(path: str) -> AsyncIterator[str]:
+    """``tail -f`` in pure asyncio, following log rotation."""
+    while True:
+        try:
+            with open(path, "r", encoding="utf-8", errors="replace") as handle:
+                handle.seek(0, os.SEEK_END)
+                inode = os.fstat(handle.fileno()).st_ino
+                while True:
+                    line = handle.readline()
+                    if line:
+                        yield line
+                        continue
+                    await asyncio.sleep(0.5)
+                    try:
+                        if os.stat(path).st_ino != inode:  # rotation
+                            break
+                    except FileNotFoundError:
+                        break
+        except FileNotFoundError:
+            logger.warning("Conan log not present yet: %s", path)
+            await asyncio.sleep(3.0)
+
+
+async def _follow_sftp(cfg: ConanConfig) -> AsyncIterator[str]:
+    """Incremental SFTP polling (e.g. Host Havoc): reads only new bytes."""
+    offset = 0
+    while True:
+        try:
+            async with asyncssh.connect(
+                cfg.sftp_host,
+                port=cfg.sftp_port,
+                username=cfg.sftp_user,
+                password=cfg.sftp_password,
+                known_hosts=None,
+            ) as conn:
+                async with conn.start_sftp_client() as sftp:
+                    while True:
+                        try:
+                            attrs = await sftp.stat(cfg.log_path)
+                            size = attrs.size or 0
+                            if size < offset:  # rotation
+                                offset = 0
+                            if size > offset:
+                                async with sftp.open(cfg.log_path, "r") as remote:
+                                    await remote.seek(offset)
+                                    chunk = await remote.read()
+                                    offset = size
+                                    for line in chunk.splitlines():
+                                        yield line
+                        except FileNotFoundError:
+                            logger.warning("SFTP: missing log %s", cfg.log_path)
+                        await asyncio.sleep(2.0)
+        except Exception as exc:
+            logger.warning("SFTP disconnected: %s — retrying", exc)
+            await asyncio.sleep(5.0)
+
+
+async def watch(cfg: ConanConfig, on_event: Callable[[Event], Awaitable[None]]) -> None:
+    """Follow the Conan log and dispatch recognised lines to *on_event*."""
+    source = _follow_local(cfg.log_path) if cfg.log_mode != "sftp" else _follow_sftp(cfg)
+    async for line in source:
+        event = parse_line(line)
+        if event is not None:
+            try:
+                await on_event(event)
+            except Exception:  # pragma: no cover - handler guard
+                logger.exception("Conan: event handler failed")

conjurer_librarian/conjurer_librarian.py

@@ -16,34 +16,52 @@ Functions:
 import asyncio
 import json
 import logging
-import netrc
+import os
 import threading
-import time
 from json.decoder import JSONDecodeError
 from logging import handlers
+from pathlib import Path
 from queue import Queue
+from typing import Dict, Optional
 
 import requests
 import scrape_bot
 import search_bot
-#import search_bot2 as search_bot
-from flask import Flask, jsonify, request
+# import search_bot2 as search_bot
+from flask import Flask, jsonify, request, abort
 from habanero import Crossref
 from waitress import serve
 
+try:
+    import netrc
+except ImportError:  # pragma: no cover
+    netrc = None
+
 # Constants
-NETRC_FILE = r"C:\Users\Activcom.pl\.netrc"
-HOST_ADDRESS = "192.168.1.192"
-PORT_ADDRESS = 5001
-MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
-SEND_RESULTS = "/conjurer"
-BDSM_UUID_TEST = "96b7f85a-1142-4908-8986-62a2ea25a147"
 
-MAX_CR_RESULTS = 500
-#TEST PURPOSES ONLY!
-#MAX_CR_RESULTS = 5
 
-ENCODING = "utf-8"
+def _env(name: str, default: str) -> str:
+    return os.getenv(name, default)
+
+
+def _env_path(name: str, default: str) -> Path:
+    return Path(os.getenv(name, default)).expanduser().resolve()
+
+
+BASE_DIR = Path(
+    os.getenv("CONJURER_LIBRARIAN_BASE", str(Path(__file__).resolve().parent))
+)
+NETRC_FILE = _env_path("CONJURER_NETRC_FILE", str(Path.home() / ".netrc"))
+HOST_ADDRESS = _env("CONJURER_LIBRARIAN_HOST", "0.0.0.0")
+PORT_ADDRESS = int(_env("CONJURER_LIBRARIAN_PORT", "5001"))
+MAIN_BOT_ADDRESS = _env("CONJURER_MAIN_BOT", "http://127.0.0.1:5000")
+SEND_RESULTS = _env("CONJURER_LIBRARIAN_RESULTS_ENDPOINT", "/conjurer")
+MAX_CR_RESULTS = int(_env("CONJURER_LIBRARIAN_MAX_RESULTS", "500"))
+ENCODING = _env("CONJURER_ENCODING", "utf-8")
+API_KEY = os.getenv("CONJURER_API_KEY")
+LOGFILE_PATH = _env_path(
+    "CONJURER_LIBRARIAN_LOG", str(BASE_DIR / "librarian.log")
+)
 
 app = Flask(__name__)
 
@@ -51,6 +69,17 @@ librarian_queue = Queue()
 librarian_list = []
 
 
+def _service_headers() -> Dict[str, str]:
+    if API_KEY:
+        return {"X-Conjurer-Api-Key": API_KEY}
+    return {}
+
+
+def _authorize_request() -> None:
+    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
+        abort(401)
+
+
 # trunk-ignore(pylint/R0902)
 class Librarian(object):
     """
@@ -81,11 +110,24 @@ class Librarian(object):
         - search_result_from_cr: A dictionary to store the search results from Crossref.
         - done: A flag indicating if the search is done.
         """
-        netrc_mod = netrc.netrc(NETRC_FILE)
-        auth_tokens = netrc_mod.authenticators("crossref")
+        mailto_contact: Optional[str] = os.getenv("CONJURER_CROSSREF_MAILTO")
+        if netrc:
+            try:
+                netrc_mod = netrc.netrc(str(NETRC_FILE))
+                auth_tokens = netrc_mod.authenticators("crossref")
+                if auth_tokens:
+                    mailto_contact = auth_tokens[0]
+            except (FileNotFoundError, netrc.NetrcParseError):
+                logging.getLogger("conjurer_librarian").warning(
+                    "Crossref credentials missing in netrc %s", NETRC_FILE
+                )
+        if not mailto_contact:
+            raise RuntimeError(
+                "Crossref credentials not configured. Set CONJURER_CROSSREF_MAILTO or add to netrc."
+            )
         self.cr = Crossref(
-            mailto=auth_tokens[0],
-            ua_string=f"Conjurer project. mailto:{auth_tokens[0]}"
+            mailto=mailto_contact,
+            ua_string=f"Conjurer project. mailto:{mailto_contact}"
         )
         self.query = query
         self.uuid = str(uuid)
@@ -132,7 +174,7 @@ class Librarian(object):
                 self.fetched = len(cr_result["message"]["items"])
                 self.app.logger.info(self.total)
                 self.app.logger.info(self.fetched)
-                time.sleep(0.1)
+                await asyncio.sleep(0.1)
 
         else:
             cr_result = self.cr.works(query=query, cursor_max=15000, cursor='*', progress_bar = True)
@@ -411,18 +453,20 @@ class BackgroundTaskSearch(threading.Thread):
                 requests.post,
                 f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
                 json=result,
+                headers=_service_headers(),
                 timeout=360,
             )
             self.app.logger.info("SENT")
             result = await coroutine
             self.app.logger.info(result.status_code)
             self.app.logger.info("SEND CONFIRMED")
-            time.sleep(1)
+            await asyncio.sleep(1)
 
 
 # ==================================SERVER ROUTES==========================================
 @app.route("/query", methods=["POST"])
 async def query_database():
+    _authorize_request()
     """
     Endpoint for querying the database.
 
@@ -455,6 +499,7 @@ async def query_database():
 
 @app.route("/get_partial_result", methods=["POST"])
 async def get_partial():
+    _authorize_request()
     """
     Retrieves the partial result for a given UUID.
 
@@ -478,9 +523,10 @@ async def get_partial():
 # =======================================MAIN===================================================
 if __name__ == "__main__":
     app.logger.setLevel(logging.DEBUG)
+    LOGFILE_PATH.parent.mkdir(parents=True, exist_ok=True)
     h1 = handlers.RotatingFileHandler(
-        filename="D:\\logs\\librarian.log",
-        encoding="utf-8",
+        filename=str(LOGFILE_PATH),
+        encoding=ENCODING,
         mode="a",
         maxBytes=6 * 1024 * 1024,
         backupCount=6,
@@ -488,20 +534,24 @@ if __name__ == "__main__":
 
     app.logger.addHandler(h1)
     threads = []
-    threads.append(threading.Thread(target=waitress_run))
+    threads.append(threading.Thread(target=waitress_run, daemon=True))
     # threads.append(threading.Thread(target=flask_debug))
     bgtask = BackgroundTaskSearch()
     bgtask.app = app
+    bgtask.daemon = True
     threads.append(bgtask)
-    threads.append(threading.Thread(target=scrape_bot.scraper, args=(app.logger,)))
+    threads.append(
+        threading.Thread(
+            target=scrape_bot.scraper, args=(app.logger,), daemon=True
+        )
+    )
     i = 0
-    for worker in threads:
-        try:
+    try:
+        for worker in threads:
             app.logger.info("App number: %s", i)
             i += 1
             worker.start()
-        except RuntimeError as e:
-            app.logger.error("Exploded")
-            print(str(e))
-    for worker in threads:
-        worker.join()
+        for worker in threads:
+            worker.join()
+    except KeyboardInterrupt:
+        app.logger.info("Shutdown requested - exiting librarian service")

conjurer_musician/.gitignore

@@ -0,0 +1,7 @@
+# Runtime-generated radio data — keep out of the repo
+all_playlist.playlist
+hit.playlist
+request.playlist
+priority_queue.playlist
+prio_playlist.json
+*.mp3

conjurer_musician/conjurer_musician.py

@@ -11,17 +11,15 @@ import random
 import re
 import threading
 import time
-
-# from flask_autoindex import AutoIndex
 from datetime import datetime
 from logging import handlers
 from pathlib import Path
-from platform import uname
-from sys import platform
+from typing import Dict, List
 
 import requests
 from flask import (
     Flask,
+    abort,
     jsonify,
     redirect,
     render_template,
@@ -29,37 +27,99 @@ from flask import (
     send_from_directory,
 )
 from waitress import serve
+
 import media_search_functions
 
 
-MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
-MUSIC_TRACKER = "/prepped_tracks"
-HOST_ADDRESS = "192.168.1.15"
-PORT_ADDRESS = 5000
-if platform in ("linux", "linux2"):
-    SEPARATOR_FILE_PATH = "/"
-    if "microsoft-standard" in uname().release:
-        LOGFILE = "/home/mtuszowski/conjurer/discord_mus_service.log"
-        MUSIC_FOLDER = "/mnt/g/Muzyka/"
-        NETRC_FILE = "/home/mtuszowski/.netrc"
-        LOGSTORE = "/home/mtuszowski/conjurer/logs/"
-        ENCODING = "utf-8"
-        RADIOLOG_PATH = "/home/pi/Conjurer/radio_log.log"
-        PERSISTENCE_PATH = "/home/pi/Conjurer/persistence.log"
+def _env(name: str, default: str) -> str:
+    return os.getenv(name, default)
 
-    else:
-        LOGFILE = "/home/pi/Conjurer/discord_mus_service.log"
-        NETRC_FILE = "/home/pi/.netrc"
-        LOGSTORE = "/home/pi/MediaFolder/logs/"
-        ENCODING = "utf-8"
-        MUSIC_FOLDER = "/home/pi/MediaFolder/mp3/"
-        PRIORITY_FOLDER = "/home/pi/MediaFoldermp3/Magiczne i chuj/"
-        RADIOLOG_PATH = "/home/pi/Conjurer/radio_log.log"
-        PERSISTENCE_PATH = "/home/pi/Conjurer/persistence.log"
+
+def _env_path(name: str, default: str) -> Path:
+    value = os.getenv(name, default)
+    return Path(value).expanduser().resolve()
+
+
+API_KEY = os.getenv("CONJURER_API_KEY")
+MAIN_BOT_ADDRESS = _env("CONJURER_MAIN_BOT", "http://127.0.0.1:5000")
+MUSIC_TRACKER = _env("CONJURER_MUSIC_TRACKER_ENDPOINT", "/prepped_tracks")
+HOST_ADDRESS = _env("CONJURER_MUSICIAN_HOST", "0.0.0.0")
+PORT_ADDRESS = int(_env("CONJURER_MUSICIAN_PORT", "5000"))
+
+BASE_DIR = Path(
+    os.getenv("CONJURER_MUSICIAN_BASE", str(Path(__file__).resolve().parent))
+)
+LOGFILE = _env_path(
+    "CONJURER_MUSICIAN_LOG", str(BASE_DIR / "discord_mus_service.log")
+)
+LOGSTORE = _env_path("CONJURER_LOGSTORE", str(BASE_DIR / "logs"))
+MUSIC_FOLDER = _env_path(
+    "CONJURER_MUSIC_FOLDER", str(BASE_DIR / "music")
+)
+PRIORITY_FOLDER = _env_path(
+    "CONJURER_PRIORITY_FOLDER", str(MUSIC_FOLDER / "priority")
+)
+RADIOLOG_PATH = _env_path(
+    "CONJURER_RADIO_LOG", str(BASE_DIR / "radio_log.log")
+)
+PERSISTENCE_PATH = _env_path(
+    "CONJURER_PERSISTENCE_LOG", str(BASE_DIR / "persistence.log")
+)
+ALL_PLAYLIST_PATH = _env_path(
+    "CONJURER_ALL_PLAYLIST", str(BASE_DIR / "all_playlist.playlist")
+)
+HIT_PLAYLIST_PATH = _env_path(
+    "CONJURER_HIT_PLAYLIST", str(BASE_DIR / "hit.playlist")
+)
+REQUEST_PLAYLIST_PATH = _env_path(
+    "CONJURER_REQUEST_PLAYLIST", str(BASE_DIR / "request.playlist")
+)
+PRIORITY_PLAYLIST_PATH = _env_path(
+    "CONJURER_PRIORITY_PLAYLIST", str(BASE_DIR / "priority_queue.playlist")
+)
+STREAM_TEMPLATE = _env_path(
+    "CONJURER_STREAM_TEMPLATE", str(BASE_DIR / "stream.html")
+)
+
+ENCODING = _env("CONJURER_ENCODING", "utf-8")
+SEPARATOR_FILE_PATH = os.sep
+
+for playlist_path in (
+    ALL_PLAYLIST_PATH,
+    HIT_PLAYLIST_PATH,
+    REQUEST_PLAYLIST_PATH,
+    PRIORITY_PLAYLIST_PATH,
+):
+    playlist_path.parent.mkdir(parents=True, exist_ok=True)
 
 random.seed()
-music_file_list = []
-priority_list = []
+music_file_list: List[str] = []
+priority_list: List[str] = []
+
+
+def _build_headers() -> Dict[str, str]:
+    headers: Dict[str, str] = {}
+    if API_KEY:
+        headers["X-Conjurer-Api-Key"] = API_KEY
+    return headers
+
+
+def _authorize_request() -> None:
+    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
+        abort(401)
+
+
+def _post_to_bot(payload: List[str]) -> None:
+    response = requests.post(
+        f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}",
+        json=payload,
+        headers=_build_headers(),
+        timeout=60,
+    )
+    logger = logging.getLogger("conjurer_musician")
+    logger.info("SENT")
+    logger.info(response.status_code)
+    logger.info("SEND CONFIRMED")
 
 
 def rescan():
@@ -70,28 +130,29 @@ def rescan():
     logger = logging.getLogger("conjurer_musician")
     logger.info("Rescan triggered")
 
-    for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
+    music_file_list.clear()
+    priority_list.clear()
+
+    for mp3_item in MUSIC_FOLDER.glob("**/*.mp3"):
         temp_music_file = mp3_item.as_posix()
-        if platform == "win32":
+        if os.name == "nt":
             temp_music_file = temp_music_file.replace("/", "\\")
         music_file_list.append(temp_music_file)
 
-    for mp3_item in Path.glob(Path(PRIORITY_FOLDER), "**/*.mp3"):
+    for mp3_item in PRIORITY_FOLDER.glob("**/*.mp3"):
         temp_music_file = mp3_item.as_posix()
-        if platform == "win32":
+        if os.name == "nt":
             temp_music_file = temp_music_file.replace("/", "\\")
         priority_list.append(temp_music_file)
 
-    with open(
-        "/home/pi/Conjurer/all_playlist.playlist", "w", encoding="utf-8"
-    ) as w_file:
+    with ALL_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
         try:
             for item in music_file_list:
                 w_file.write(item)
                 w_file.write("\n")
         except json.JSONDecodeError:
             pass
-    with open("/home/pi/Conjurer/hit.playlist", "w", encoding="utf-8") as w_file:
+    with HIT_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
         try:
             for item in priority_list:
                 w_file.write(item)
@@ -116,72 +177,50 @@ def thread_rescan():
 def scan_tracks():
     # Set the filename and open the file
     logger = logging.getLogger("conjurer_musician")
+    with open(RADIOLOG_PATH, "r", encoding=ENCODING) as log_file:
+        log_file.seek(os.stat(RADIOLOG_PATH).st_size)
+        prev_size = os.stat(PERSISTENCE_PATH).st_size
 
-    file = open(RADIOLOG_PATH, "r")
-    # Find the size of the file and move to the end
-    st_results = os.stat(RADIOLOG_PATH)
-    st_size = st_results[6]
-    file.seek(st_size)
-    st_results1 = os.stat(PERSISTENCE_PATH)
-    prev_st_size1 = st_results[6]
+        while True:
+            current_size = os.stat(PERSISTENCE_PATH).st_size
+            if prev_size != current_size:
+                while prev_size != current_size:
+                    prev_size = current_size
+                    time.sleep(0.1)
+                    current_size = os.stat(PERSISTENCE_PATH).st_size
+                with open(PERSISTENCE_PATH, "r", encoding=ENCODING) as persistence:
+                    lines = persistence.readlines()
+                if len(lines) >= 3:
+                    _post_to_bot(["next", lines[2]])
 
-    while 1:
+            position = log_file.tell()
+            line = log_file.readline()
+            if not line:
+                time.sleep(1)
+                log_file.seek(position)
+                continue
 
-        st_results1 = os.stat(PERSISTENCE_PATH)
-        st_size1 = st_results1[6]
-        if prev_st_size1 != st_size1:
-            while prev_st_size1 != st_size1:
-                prev_st_size1 = st_size1
-                st_results1 = os.stat(PERSISTENCE_PATH)
-                st_size1 = st_results1[6]
+            if not re.match(r".*Prepared.*", line):
                 time.sleep(0.1)
-            file1 = open(PERSISTENCE_PATH, "r")
-            lines = file1.readlines()
-            result = ["next", lines[2]]
-            file1.close()
-            returned = requests.post(
-                f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}", json=result, timeout=360
-            )
-            logger.info("SENT")
-            logger.info(returned.status_code)
-            logger.info("SEND CONFIRMED")
+                continue
 
-        where = file.tell()
-        line = file.readline()
-        if not line:
-            time.sleep(1)
-            file.seek(where)
-        else:
-            if re.match(".*Prepared.*", line):
-                result = None
-                if re.match(".*jingles.*", line):
-                    logger.info("jingles")
-                    logger.info(line)  # already has newline
-                    result = ["jingles", line]
-                elif re.match(".*priority.*", line):
-                    logger.info("priority")
-                    logger.info(line)  # already has newline
-                    result = ["priority", line]
-                elif re.match(".*hit.*", line):
-                    logger.info("hit")
-                    logger.info(line)  # already has newline
-                    result = ["hit", line]
-                elif re.match(".*all_playlist.*", line):
-                    logger.info("all")
-                    logger.info(line)  # already has newline
-                    result = ["all", line]
-                elif re.match(".*request.*", line):
-                    logger.info("requests")
-                    logger.info(line)  # already has newline
-                    result = ["requests", line]
-                if result:
-                    returned = requests.post(
-                        f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}", json=result, timeout=360
-                    )
-                    logger.info("SENT")
-                    logger.info(returned.status_code)
-                    logger.info("SEND CONFIRMED")
-        time.sleep(0.1)
+            result = None
+            if re.match(r".*jingles.*", line):
+                result = ["jingles", line]
+            elif re.match(r".*priority.*", line):
+                result = ["priority", line]
+            elif re.match(r".*hit.*", line):
+                result = ["hit", line]
+            elif re.match(r".*all_playlist.*", line):
+                result = ["all", line]
+            elif re.match(r".*request.*", line):
+                result = ["requests", line]
+
+            if result:
+                logger.info("Forwarding radio log entry: %s", result[0])
+                _post_to_bot(result)
+
+            time.sleep(0.1)
 
 
 app = Flask(__name__)
@@ -290,12 +329,8 @@ def wyszukaj(word_list, how_many, _logger=None, return_to_bot=True):
             if search_weight[itr][0] == item_to_search:
                 return_list.append(search_weight[itr])
                 if not return_to_bot:
-                    with open(
-                        "/home/pi/Conjurer/priority_queue.playlist",
-                        "r+",
-                        encoding="utf-8",
-                    ) as s_file:
-                        s_file.write(search_weight[itr][1])
+                    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
+                        s_file.write(search_weight[itr][1] + "\n")
                 break
             itr += 1
     else:
@@ -336,6 +371,7 @@ def remove_characters(string, character):
 
 @app.route('/get_share_list', methods=['POST'])
 def get_share_list():
+    _authorize_request()
     data = request.get_json()
     entries = data.get('entries')
     keywords = data.get('keywords')
@@ -352,6 +388,7 @@ def get_share_list():
 
 @app.route('/get_share_links', methods=['POST'])
 def get_share_links():
+    _authorize_request()
     data = request.get_json()
     file_paths = data.get('file_paths')
     # Validate file_paths list
@@ -374,7 +411,7 @@ def stream_music():
     """
 
     # return send_from_directory("/tmp/hls", "stream.m3u8")
-    return render_template("/home/pi/Conjurer/stream.html")
+    return render_template(str(STREAM_TEMPLATE))
 
 
 @app.route("/<string:file_name>")
@@ -406,15 +443,14 @@ def stream_music_mp3():
 
 @app.route("/clear_pr_pls", methods=["GET"])
 def clear_pr_pls():
+    _authorize_request()
     """
     The function `clear_pr_pls` clears the contents of the priority queue playlist file.
 
     :return: A JSON response indicating the success of the operation.
     """
     app.logger.info("CLEARING PLAYLIST")
-    with open(
-        "/home/pi/Conjurer/priority_queue.playlist", "w", encoding="utf-8"
-    ) as cleared_pl:
+    with PRIORITY_PLAYLIST_PATH.open("w", encoding=ENCODING) as cleared_pl:
         cleared_pl.write("")
 
     return_data = jsonify(isError=False, message="Success", statusCode=200, data=[])
@@ -442,6 +478,7 @@ def update_music_list():
     received and added to the `music_file_list`.
     The status code returned is 200, indicating a successful response.
     """
+    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record["item"])
     music_file_list.append(record["item"])
@@ -463,6 +500,7 @@ def look_for_playlist():
              data that was received and added to the `music_file_list`. The status code returned is 200,
              indicating a successful response.
     """
+    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["lista_slow"])
@@ -481,13 +519,14 @@ def look_for_playlist():
 
 @app.route("/request_radio_file", methods=["POST"])
 def add_request():
+    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["lista_slow"])
     app.logger.info(record["UUID"])
     return_data = wyszukaj(record["lista_slow"], 0, app.logger, False)
 
-    with open("/home/pi/Conjurer/request.playlist", "a", encoding="utf-8") as s_file:
+    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
         for item in return_data:
             s_file.write(item[1] + "\n")
     return_data = (
@@ -512,6 +551,7 @@ def create_priority_playlist():
         data that was received and added to the `music_file_list`.
         The status code returned is 200,indicating a successful response.
     """
+    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["lista_slow"])
@@ -521,7 +561,7 @@ def create_priority_playlist():
         record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
     )
     random.shuffle(return_data)
-    with open("/home/pi/Conjurer/request.playlist", "a", encoding="utf-8") as s_file:
+    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
         for item in return_data:
             s_file.write(item[1] + "\n")
     return_data = (
@@ -546,6 +586,7 @@ def add_to_priority():
         data that was received and added to the `music_file_list`.
         The status code returned is 200,indicating a successful response.
     """
+    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["lista_slow"])
@@ -554,9 +595,7 @@ def add_to_priority():
     return_data = wyszukaj(
         record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
     )
-    with open(
-        "/home/pi/Conjurer/priority_queue.playlist", "a", encoding="utf-8"
-    ) as s_file:
+    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
         for item in return_data:
             s_file.write(item[1] + "\n")
     return_data = (
@@ -615,15 +654,19 @@ if __name__ == "__main__":
     logger.info("Started")
     threads = []
     # threads.append(threading.Thread(target=flask_debug))
-    threads.append(threading.Thread(target=waitress_run))
-    threads.append(threading.Thread(target=thread_rescan))
+    threads.append(threading.Thread(target=waitress_run, daemon=True))
+    threads.append(threading.Thread(target=thread_rescan, daemon=True))
 
     for worker in threads:
         worker.start()
 
     time.sleep(60)
-    threads.append(threading.Thread(target=scan_tracks))
-    threads[2].start()
+    track_thread = threading.Thread(target=scan_tracks, daemon=True)
+    track_thread.start()
 
-    for worker in threads:
-        worker.join()
+    try:
+        for worker in threads:
+            worker.join()
+        track_thread.join()
+    except KeyboardInterrupt:
+        logger.info("Shutdown requested - exiting musician service")

conjurer_musician/script.params

@@ -45,7 +45,7 @@
   ],
     [
     "compress_release5",
-    170.0
+    120.0
   ],
     [
     "compress_attack5",
@@ -69,7 +69,7 @@
   ],
     [
     "compress_release4",
-    180.0
+    130.0
   ],
     [
     "compress_attack4",
@@ -81,7 +81,7 @@
   ],
     [
     "compress_gain3",
-    8.2
+    5.5
   ],
     [
     "compress_ratio3",
@@ -93,7 +93,7 @@
   ],
     [
     "compress_release3",
-    180.0
+    140.0
   ],
     [
     "compress_attack3",
@@ -105,7 +105,7 @@
   ],
     [
     "compress_gain2",
-    7.4
+    3.3
   ],
     [
     "compress_ratio2",
@@ -117,7 +117,7 @@
   ],
     [
     "compress_release2",
-    190.0
+    120.0
   ],
     [
     "compress_attack2",
@@ -129,7 +129,7 @@
   ],
     [
     "compress_gain1",
-    11.1
+    5.6
   ],
     [
     "compress_ratio1",
@@ -137,11 +137,11 @@
   ],
     [
     "compress_threshold1",
-    -12.7
+    -12.2
   ],
     [
     "compress_release1",
-    170.0
+    120.0
   ],
     [
     "compress_attack1",
@@ -153,7 +153,7 @@
   ],
     [
     "compress_gain0",
-    16.0
+    7.5
   ],
     [
     "compress_ratio0",
@@ -161,15 +161,15 @@
   ],
     [
     "compress_threshold0",
-    -15.3
+    -13.1
   ],
     [
     "compress_release0",
-    200.0
+    110.0
   ],
     [
     "compress_attack0",
-    90.0
+    140.0
   ],
     [
     "compress_frequency0",
@@ -185,11 +185,11 @@
   ],
     [
     "g",
-    9.5
+    1.0
   ],
     [
     "f",
-    64.2
+    106.4
   ]
   ]
 }

constants.py

@@ -1,13 +1,51 @@
+"""Centralised configuration and runtime constants for Conjurer.
+
+Historically this module performed heavy filesystem and credential reads at
+import time which made the bot brittle on hosts that did not mirror the
+original paths.  This version keeps the original platform defaults (so the
+behaviour on the Raspberry Pi / WSL / Windows deployments is unchanged when no
+environment variables are set) but adds three robustness improvements ported
+from the dockerised experiment:
+
+* every path/endpoint can be overridden via an environment variable,
+* JSON state files are loaded defensively (a missing or corrupt file no longer
+  crashes the whole bot at import time),
+* optional dependencies (openai, spotipy, netrc) and credentials are guarded so
+  the bot can still start when a secondary integration is offline, and
+* a shared ``CONJURER_API_KEY`` plus ``service_headers()`` helper enables
+  authenticated internal HTTP calls.
+
+All path constants intentionally remain plain ``str`` (with their original
+trailing separators) to stay byte-for-byte compatible with the existing string
+concatenation in the command modules.
+"""
+
 import json
-import netrc
+import logging
+import os
 from datetime import datetime
 from platform import uname
 from sys import platform
 from typing import List, Optional, TypedDict
 
-import openai
-import spotipy
-from spotipy.oauth2 import SpotifyClientCredentials
+try:
+    import netrc
+except ImportError:  # pragma: no cover - standard on CPython
+    netrc = None
+
+try:
+    import openai
+except ImportError:  # pragma: no cover - optional at runtime
+    openai = None
+
+try:
+    import spotipy
+    from spotipy.oauth2 import SpotifyClientCredentials
+except ImportError:  # pragma: no cover - optional component
+    spotipy = None
+    SpotifyClientCredentials = None
+
+logger = logging.getLogger("discord")
 
 Music_Config = TypedDict(
     "Music_Config",
@@ -30,16 +68,12 @@ MUSIC_FOLDER = ""
 MEMORY_FIVE_SIARA = ""
 MEMORY_FIVE_MUZYKA = ""
 SETTINGS_FILE = ""
-ENCODING = ""
+ENCODING = "utf-8"
 GRAPHICS_PATH = ""
 MUZYKA_MOJEGO_LUDU_HISTORIA = 1500
 MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE = 15
 MUZYKA_MOJEGO_LUDU_PLAJLISTA = 30
 
-FILE_SERVICE_ADDRESS = "http://192.168.1.15:5000"
-RADIO_HARBOR_ADDRESS = "http://192.168.1.15:54321"
-SKIP_TRACK = "/skip"
-
 GET_MP3 = "/mp3"
 SEND_MP3 = "/update_mp3"
 GET_PLAYLIST = "/get_music"
@@ -48,14 +82,13 @@ CREATE_PRIO_PLAYLIST = "/create_priority_playlist"
 
 REQUEST_MUSIC = "/request_radio_file"
 CLEAR_PRIO = "/clear_pr_pls"
-LIBRARIAN_SERVICE_ADDRESS = "http://192.168.1.192:5001"
 SEND_QUERY = "/query"
 TIME_BETWEEN_CALLS = 100000
 LAST_SPONTANEOUS_CALL = datetime.now()
-HOST_ADDRESS = "192.168.1.191"
-PORT_ADDRESS = 5000
 
-# *=========================================== Platform Specific Predefines
+# *=========================================== Platform Specific Defaults
+# These blocks only establish *default* values.  Every constant is overridable
+# through the matching environment variable further below.
 
 if platform in ("linux", "linux2"):
     SEPARATOR_FILE_PATH = "/"
@@ -101,47 +134,158 @@ elif platform == "win32":
     ENCODING = "utf-8"
     DIR_PATH_SADOX = "C:\\Users\\mtusz\\OneDrive\\Dokumenty\\Fansadox\\"
     SEPARATOR_FILE_PATH = "\\"
-with open(SETTINGS_FILE, "r", encoding=ENCODING) as f_settings_file:
-    DATA = json.load(f_settings_file)
-REMOTE_HOST_NAME = "openai"
-netrc_mod = netrc.netrc(NETRC_FILE)
-authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
-openai.api_key = authTokens[2]
-OPENAICLIENT = openai.AsyncOpenAI(api_key=openai.api_key)
-REMOTE_HOST_NAME = "discord"
-authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
-TOKEN = authTokens[2]
 
-REMOTE_HOST_NAME = "spotipy"
-authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
-SPOTIFY_CTRL = spotipy.Spotify(
-    client_credentials_manager=SpotifyClientCredentials(
-        client_id=authTokens[0],
-        client_secret=authTokens[2],
-    )
+else:
+    # Fallback for development hosts (macOS, BSD, …) that match none of the
+    # production platforms.  Everything is rooted next to this file so the
+    # module can at least be imported and unit-tested off-deployment.
+    _BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+    SEPARATOR_FILE_PATH = os.sep
+    LOGFILE = os.path.join(_BASE_DIR, "discord.log")
+    MEMORY_FIVE_SIARA = os.path.join(_BASE_DIR, "pamiec.json")
+    SYSTEM_GPT_SETTINGS = os.path.join(_BASE_DIR, "system_gpt_settings.json")
+    MEMORY_FIVE_MUZYKA = os.path.join(_BASE_DIR, "pamiec_muzyki.json")
+    MUSIC_FOLDER = os.path.join(_BASE_DIR, "music") + os.sep
+    SETTINGS_FILE = os.path.join(_BASE_DIR, "settings.json")
+    NETRC_FILE = os.path.join(os.path.expanduser("~"), ".netrc")
+    LOGSTORE = os.path.join(_BASE_DIR, "logs") + os.sep
+    ACCIDENT_LOG = os.path.join(_BASE_DIR, "accident_log.json")
+    GRAPHICS_PATH = os.path.join(_BASE_DIR, "Conjurer_graphics") + os.sep
+    DIR_PATH_SADOX = os.path.join(_BASE_DIR, "Fansadox") + os.sep
+
+
+# *=========================================== Environment overrides
+# Values stay as plain strings so existing ``PATH + filename`` concatenation in
+# the command modules keeps working unchanged.
+
+LOGFILE = os.getenv("CONJURER_LOG_FILE", LOGFILE)
+NETRC_FILE = os.getenv("CONJURER_NETRC_FILE", NETRC_FILE)
+SETTINGS_FILE = os.getenv("CONJURER_SETTINGS_FILE", SETTINGS_FILE)
+MEMORY_FIVE_SIARA = os.getenv("CONJURER_MEMORY_FILE", MEMORY_FIVE_SIARA)
+MEMORY_FIVE_MUZYKA = os.getenv("CONJURER_MUSIC_MEMORY_FILE", MEMORY_FIVE_MUZYKA)
+SYSTEM_GPT_SETTINGS = os.getenv("CONJURER_SYSTEM_GPT_SETTINGS", SYSTEM_GPT_SETTINGS)
+GRAPHICS_PATH = os.getenv("CONJURER_GRAPHICS_PATH", GRAPHICS_PATH)
+MUSIC_FOLDER = os.getenv("CONJURER_MUSIC_FOLDER", MUSIC_FOLDER)
+LOGSTORE = os.getenv("CONJURER_LOGSTORE", LOGSTORE)
+ACCIDENT_LOG = os.getenv("CONJURER_ACCIDENT_LOG", ACCIDENT_LOG)
+DIR_PATH_SADOX = os.getenv("CONJURER_SADOX_DIR", DIR_PATH_SADOX)
+ENCODING = os.getenv("CONJURER_ENCODING", ENCODING)
+SEPARATOR_FILE_PATH = os.getenv("CONJURER_PATH_SEPARATOR", SEPARATOR_FILE_PATH)
+
+FILE_SERVICE_ADDRESS = os.getenv("CONJURER_FILE_SERVICE", "http://192.168.1.15:5000")
+RADIO_HARBOR_ADDRESS = os.getenv("CONJURER_RADIO_HARBOR", "http://192.168.1.15:54321")
+SKIP_TRACK = os.getenv("CONJURER_SKIP_ENDPOINT", "/skip")
+LIBRARIAN_SERVICE_ADDRESS = os.getenv(
+    "CONJURER_LIBRARIAN_SERVICE", "http://192.168.1.192:5001"
 )
-REMOTE_HOST_NAME = "youtube"
-authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
-YOUTUBE_AUTH = [authTokens[0],authTokens[2]]
+HOST_ADDRESS = os.getenv("CONJURER_DISCORD_HOST", "192.168.1.191")
+PORT_ADDRESS = int(os.getenv("CONJURER_DISCORD_PORT", "5000"))
 
-WORD_REACTIONS = DATA["word_reactions"]
-CYCLIC_WORDS = DATA["cyclic_words"]
+# Shared secret for authenticating internal service-to-service HTTP calls.
+API_SHARED_KEY = os.getenv("CONJURER_API_KEY", "")
+
+
+# *=========================================== Defensive state loading
+def _load_json(path: str, fallback):
+    """Load JSON from *path*, falling back gracefully on missing/corrupt files."""
+    try:
+        with open(path, "r", encoding=ENCODING) as handle:
+            return json.load(handle)
+    except FileNotFoundError:
+        logger.warning("Missing JSON file at %s - using fallback", path)
+        return fallback
+    except json.JSONDecodeError:
+        logger.warning("Corrupt JSON at %s - resetting to fallback", path)
+        return fallback
+
+
+DATA = _load_json(SETTINGS_FILE, {})
+WORD_REACTIONS = DATA.get("word_reactions", {})
+CYCLIC_WORDS = DATA.get("cyclic_words", {})
 for key in WORD_REACTIONS:
-    WORD_REACTIONS[key][2] = datetime.now()
-with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as temp_memory_file:
-    # First we load existing data into a dict.
-    MESSAGE_TABLE = json.load(temp_memory_file)
+    if isinstance(WORD_REACTIONS[key], list) and len(WORD_REACTIONS[key]) >= 3:
+        WORD_REACTIONS[key][2] = datetime.now()
 
-with open(SYSTEM_GPT_SETTINGS, "r+", encoding=ENCODING) as temp_settings_file:
-    # First we load existing data into a dict.
-    GPT_SETTINGS = json.load(temp_settings_file)
-with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as temp_music_memory_file:
-    # First we load existing data into a dict.
-    MESSAGE_TABLE_MUZYKA = json.load(temp_music_memory_file)
-SPECJALNE_ZIEMNIACZKI = GPT_SETTINGS[1]
+MESSAGE_TABLE = _load_json(MEMORY_FIVE_SIARA, [])
+GPT_SETTINGS = _load_json(SYSTEM_GPT_SETTINGS, {})
+MESSAGE_TABLE_MUZYKA = _load_json(MEMORY_FIVE_MUZYKA, [])
+
+SPECJALNE_ZIEMNIACZKI = GPT_SETTINGS[1] if isinstance(GPT_SETTINGS, list) else {}
 ASSISTANTS = {}
 
 
+# *=========================================== Credentials
+def _load_netrc_credentials(host: str):
+    """Return the netrc authenticators tuple for *host* or ``None``."""
+    if netrc is None:
+        return None
+    try:
+        parsed = netrc.netrc(NETRC_FILE)
+    except FileNotFoundError:
+        logger.warning("netrc file %s not found", NETRC_FILE)
+        return None
+    except netrc.NetrcParseError:
+        logger.warning("netrc file %s is invalid", NETRC_FILE)
+        return None
+    return parsed.authenticators(host)
+
+
+def _resolve_token(host: str, env_var: str) -> Optional[str]:
+    """Prefer an environment variable, then fall back to netrc."""
+    env_value = os.getenv(env_var)
+    if env_value:
+        return env_value
+    creds = _load_netrc_credentials(host)
+    if creds:
+        return creds[2]
+    logger.warning("Token for %s not configured", host)
+    return None
+
+
+OPENAI_API_KEY = _resolve_token("openai", "OPENAI_API_KEY")
+if openai and OPENAI_API_KEY:
+    openai.api_key = OPENAI_API_KEY
+    OPENAICLIENT = openai.AsyncOpenAI(api_key=OPENAI_API_KEY)
+else:
+    OPENAICLIENT = None
+
+TOKEN = _resolve_token("discord", "DISCORD_TOKEN")
+
+if spotipy:
+    _spotify_creds = _load_netrc_credentials("spotipy")
+    if _spotify_creds and SpotifyClientCredentials:
+        SPOTIFY_CTRL = spotipy.Spotify(
+            client_credentials_manager=SpotifyClientCredentials(
+                client_id=_spotify_creds[0],
+                client_secret=_spotify_creds[2],
+            )
+        )
+    else:
+        SPOTIFY_CTRL = None
+else:
+    SPOTIFY_CTRL = None
+
+_youtube_creds = _load_netrc_credentials("youtube")
+if _youtube_creds:
+    YOUTUBE_AUTH = [_youtube_creds[0], _youtube_creds[2]]
+else:
+    YOUTUBE_AUTH = [
+        os.getenv("YOUTUBE_USERNAME", ""),
+        os.getenv("YOUTUBE_PASSWORD", ""),
+    ]
+
+
+def service_headers():
+    """Shared header dict for internal service-to-service HTTP calls.
+
+    Returns an empty dict when no key is configured, keeping calls backward
+    compatible with deployments that do not (yet) enforce authentication.
+    """
+    if API_SHARED_KEY:
+        return {"X-Conjurer-Api-Key": API_SHARED_KEY}
+    return {}
+
+
 LATEX_TEX_ENGINE = "tectonic"
 LATEX_MAX_COMPILE_SECONDS = 45
 LATEX_MAX_ATTACH_MB = 8
@@ -150,4 +294,29 @@ LATEX_MAX_ZIP_MB =  25
 OPENAI_MODEL = "gpt-4o-mini"
 
 ALLOWED_ROLES = ["Nocna Zmiana", "Jarl", "Thane", "Bartender"]
-GUILD_ID = 664789470779932693
+GUILD_ID = 664789470779932693
+LATEST_MODEL = "gpt-4o"          # najnowszy/do rozmów (możesz zmienić w jednym miejscu)
+CHEAP_MODEL  = "gpt-4o-mini"     # najtańszy (fallback do 3.5 niżej)
+
+
+# *=========================================== Conan Exiles bridge
+# Every value is optional; the conanjurer cog stays dormant unless configured.
+# Channel/role ids default to 0 ("not defined"); RCON host/log path default to
+# "" ("disabled"). See conanjurer_commands.py / conanjurer_functions.py.
+CONAN_GM_ROLE_ID = int(os.getenv("CONAN_GM_ROLE_ID", "0"))
+CONAN_CHAT_CHANNEL_ID = int(os.getenv("CONAN_CHAT_CHANNEL_ID", "0"))
+CONAN_EVENTS_CHANNEL_ID = int(os.getenv("CONAN_EVENTS_CHANNEL_ID", "0"))
+# Player-join notifications: leave at 0 to keep the feature disabled.
+CONAN_JOIN_CHANNEL_ID = int(os.getenv("CONAN_JOIN_CHANNEL_ID", "0"))
+CONAN_PLAYER_POLL_SECONDS = int(os.getenv("CONAN_PLAYER_POLL_SECONDS", "60"))
+
+CONAN_RCON_HOST = os.getenv("CONAN_RCON_HOST", "")
+CONAN_RCON_PORT = int(os.getenv("CONAN_RCON_PORT", "25575"))
+CONAN_RCON_PASSWORD = os.getenv("CONAN_RCON_PASSWORD", "")
+
+CONAN_LOG_MODE = os.getenv("CONAN_LOG_MODE", "local")  # "local" | "sftp"
+CONAN_LOG_PATH = os.getenv("CONAN_LOG_PATH", "")
+CONAN_SFTP_HOST = os.getenv("CONAN_SFTP_HOST", "")
+CONAN_SFTP_PORT = int(os.getenv("CONAN_SFTP_PORT", "22"))
+CONAN_SFTP_USER = os.getenv("CONAN_SFTP_USER", "")
+CONAN_SFTP_PASSWORD = os.getenv("CONAN_SFTP_PASSWORD", "")

deploy.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-total_commands=29
+total_commands=31
 current_command=0
 
 function print_progress {
@@ -95,8 +95,14 @@ print_progress "cp ./conjurer/latex_functions.py ./Conjurer/"
 cp ./conjurer/librarian_functions.py ./Conjurer
 print_progress "cp ./conjurer/librarian_functions.py ./Conjurer/"
 
-cp ./conjurer/thin_client.py ./Conjurer/bot.py
-print_progress "cp ./conjurer/thin_client.py ./Conjurer/bot.py"
+cp ./conjurer/conanjurer_commands.py ./Conjurer/
+print_progress "cp ./conjurer/conanjurer_commands.py ./Conjurer/"
+
+cp ./conjurer/conanjurer_functions.py ./Conjurer/
+print_progress "cp ./conjurer/conanjurer_functions.py ./Conjurer/"
+
+cp ./conjurer/bot.py ./Conjurer/bot.py
+print_progress "cp ./conjurer/bot.py ./Conjurer/bot.py"
 
 sudo systemctl restart conjurer.service
 print_progress "sudo systemctl restart conjurer.service"

dj_debug_fonts.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-exists() { command -v "$1" >/dev/null 2>&1; }
-
-echo "[i] Checking environment..."
-for c in fc-list pdffonts tectonic; do
-  if ! exists "$c"; then
-    echo "  - $c: NOT FOUND (optional but recommended: sudo apt install -y fontconfig poppler-utils tectonic)"
-  else
-    echo "  - $c: OK"
-  fi
-done
-
-echo "[i] Listing local ./fonts content:"
-ls -l ./fonts 2>/dev/null || echo "  (no ./fonts directory)"
-
-if exists fc-list; then
-  echo "[i] System fonts (grep Garamond|Cinzel|FELL):"
-  fc-list | grep -Ei "Garamond|Cinzel|Fell" || echo "  (none found in system)"
-fi
-
-pdfs=(dj_cheat_sheet_transitions.pdf dj_tracklist.pdf dj_mini_sheet.pdf dj_notes.pdf dj_setup_mapping.pdf dj_one_laptop_fallback.pdf dj_rider.pdf dj_podrecznik.pdf)
-if exists pdffonts; then
-  for p in "${pdfs[@]}"; do
-    [ -f "$p" ] || continue
-    echo "[i] Fonts embedded in $p:"
-    pdffonts "$p" || true
-  done
-else
-  echo "[!] pdffonts not installed; cannot list embedded fonts."
-fi
-
-echo "[i] Grepping last Tectonic log (if any .log files exist)..."
-logs=$(ls -1 *.log 2>/dev/null || true)
-if [ -n "$logs" ]; then
-  grep -Ei "fontspec|warning|not found" *.log || echo "  (no relevant warnings)"
-else
-  echo "  (no .log files)"
-fi

dj_fonts_system_install.sh

@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+# System-wide install & verify (Debian/RPi):
+#  - EB Garamond (APT)
+#  - Cinzel Decorative Black (RAW TTF)
+#  - IM Fell English SC (gstatic/RAW)
+# No TeX build here. Very verbose + clear final report.
+
+set -Eeuo pipefail
+
+SUDO=sudo; [ "$(id -u)" -eq 0 ] && SUDO=
+log(){ echo -e "[+] $*"; }
+warn(){ echo -e "[WARN] $*" >&2; }
+die(){ echo -e "[FATAL] $*" >&2; exit 1; }
+
+need(){ command -v "$1" >/dev/null 2>&1 || die "Missing tool: $1"; }
+fetch(){
+  local url="$1" out="$2"
+  if command -v wget >/dev/null 2>&1; then
+    log "wget -> $url"
+    wget -O "$out" --https-only --no-verbose "$url"
+  else
+    log "curl -> $url"
+    curl -L --fail --show-error --output "$out" "$url"
+  fi
+}
+
+# ---- detection using fc-list families (robust, no PCRE) ----
+fc_families_lower() {
+  fc-list -f '%{family}\n' \
+  | tr ',' '\n' \
+  | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' \
+  | tr '[:upper:]' '[:lower:]' \
+  | sort -u
+}
+has_family_re() {  # $1 = POSIX ERE anchored-at-start pattern (lowercase)
+  fc_families_lower | grep -Eiq "$1"
+}
+
+# ---- prereqs ----
+for t in fc-cache fc-list grep sed awk; do need "$t"; done
+command- v wget >/dev/null 2>&1 || command -v curl >/dev/null 2>&1 || die "Need wget or curl"
+
+SYSTEM_DIR="/usr/local/share/fonts/dj"
+DIR_CINZEL="$SYSTEM_DIR/cinzel-decorative"
+DIR_IMFELL="$SYSTEM_DIR/im-fell-english-sc"
+$SUDO mkdir -p "$DIR_CINZEL" "$DIR_IMFELL"
+
+echo "=== APT phase (EB Garamond) ==="
+if command -v apt-get >/dev/null 2>&1; then
+  $SUDO apt-get update -y || warn "apt update failed (continuing)"
+  if $SUDO apt-get install -y --no-install-recommends fonts-ebgaramond; then
+    log "installed: fonts-ebgaramond"
+  else
+    warn "apt install failed: fonts-ebgaramond"
+  fi
+else
+  warn "apt-get not found — skipping"
+fi
+
+echo
+log "Families BEFORE web fallback (sample grep):"
+fc-list | grep -Ei "Garamond|Cinzel|Fell" || echo "  (none)"
+
+echo
+echo "=== Web fallback (system-wide to $SYSTEM_DIR) ==="
+
+# --- Cinzel Decorative Black ---
+CINZEL_TTF="$DIR_CINZEL/CinzelDecorative-Black.ttf"
+if ! has_family_re '^cinzel decorative( |$)'; then
+  fetch "https://github.com/google/fonts/raw/main/ofl/cinzeldecorative/CinzelDecorative-Black.ttf" "$CINZEL_TTF" || warn "Cinzel Decorative Black download failed"
+  [ -s "$CINZEL_TTF" ] && $SUDO chmod 0644 "$CINZEL_TTF"
+else
+  log "Cinzel Decorative already present."
+fi
+
+# --- IM Fell English SC ---
+IMFELL_TTF="$DIR_IMFELL/IMFeENsc.ttf"
+if ! has_family_re '^im fell english sc( |$)'; then
+  # Try known gstatic TTFs (stable direct links)
+  for u in \
+    "https://fonts.gstatic.com/s/imfellenglishsc/v7/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
+    "https://fonts.gstatic.com/s/imfellenglishsc/v6/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf"
+  do
+    if fetch "$u" "$IMFELL_TTF"; then
+      [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from gstatic OK"; break; }
+    fi
+  done
+  # Secondary RAW in google/fonts (names changed over time)
+  if [ ! -s "$IMFELL_TTF" ]; then
+    for u in \
+      "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFeENsc28P.ttf" \
+      "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFellEnglishSC-Regular.ttf"
+    do
+      if fetch "$u" "$IMFELL_TTF"; then
+        [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from google/fonts RAW OK"; break; }
+      fi
+    done
+  fi
+  # Minimal mirror fallback (only if naprawdę trzeba)
+  if [ ! -s "$IMFELL_TTF" ]; then
+    for u in \
+      "https://www.wfonts.com/download/data/2016/06/14/im-fell-english-sc/IMFeENsc28P.ttf" \
+      "https://www.1001freefonts.com/d/6800/IMFeENsc28P.ttf"
+    do
+      fetch "$u" "$IMFELL_TTF" || true
+      [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from mirror OK"; break; }
+    done
+  fi
+  [ -s "$IMFELL_TTF" ] || warn "IM Fell English SC still missing."
+else
+  log "IM Fell English SC already present."
+fi
+
+echo
+log "Fix perms & rebuild cache..."
+$SUDO find "$SYSTEM_DIR" -type f -size 0 -print -delete || true
+$SUDO find "$SYSTEM_DIR" -type f \( -name "*.ttf" -o -name "*.otf" \) -exec chmod 0644 {} \; || true
+$SUDO find "$SYSTEM_DIR" -type d -exec chmod 0755 {} \; || true
+$SUDO fc-cache -f -v >/dev/null || warn "fc-cache returned non-zero"
+
+# ---- FINAL REPORT ----
+echo
+log "FINAL STATUS (fc-list families & file presence)"
+families="$(fc_families_lower)"
+
+report(){
+  local label="$1" fam_re="$2" file_hint="$3"
+  local fam_ok file_ok="n/a"
+  if echo "$families" | grep -Eiq "$fam_re"; then fam_ok="OK"; else fam_ok="MISSING"; fi
+  if [ -n "$file_hint" ]; then
+    if [ -s "$file_hint" ]; then file_ok="yes"; else file_ok="no"; fi
+  fi
+  printf "  %-22s : families=%-8s file=%-3s  (%s)\n" "$label" "$fam_ok" "$file_ok" "${file_hint:-no-file-hint}"
+}
+
+report "EB Garamond"           '^eb garamond( |$)'           ""                 # from APT
+report "Cinzel Decorative"     '^cinzel decorative( |$)'      "$CINZEL_TTF"
+report "IM Fell English SC"    '^im fell english sc( |$)'     "$IMFELL_TTF"
+
+echo
+log "Done. (Run your LaTeX pipeline next.)"

dj_oneclick_fix.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-need() { command -v "$1" >/dev/null 2>&1 || { echo "Missing: $1" >&2; exit 1; }; }
-
-echo "[+] Checking tools..."
-need wget
-need unzip
-need tectonic || { echo "Install tectonic first (e.g. sudo apt install tectonic)"; exit 1; }
-
-mkdir -p fonts
-
-echo "[+] Downloading EB Garamond (Initials) to ./fonts ..."
-tmpzip="/tmp/ebgaramond.zip"
-wget -q -O "$tmpzip" https://github.com/octaviopardo/EBGaramond/releases/download/v0.016/EBGaramond-ttf.zip
-unzip -jq "$tmpzip" "*Initials*.ttf" -d fonts
-ls -1 fonts | grep -i initials || echo "WARN: EBGaramond Initials not found in zip?"
-
-echo "[+] Downloading Cinzel Decorative (Black) to ./fonts ..."
-tmpzip="/tmp/cinzel.zip"
-wget -q -O "$tmpzip" "https://fonts.google.com/download?family=Cinzel%20Decorative" || true
-unzip -jq "$tmpzip" "*Decorative-Black*.ttf" -d fonts || echo "WARN: Cinzel Decorative Black not found; continuing."
-
-echo "[+] (Optional) Downloading IM FELL English SC to ./fonts ..."
-tmpzip="/tmp/imfell.zip"
-wget -q -O "$tmpzip" "https://fonts.google.com/download?family=IM%20Fell%20English%20SC" || true
-unzip -jq "$tmpzip" "*.ttf" -d fonts || echo "INFO: IM FELL SC optional; skip if not needed."
-
-echo "[+] Building PDFs with Tectonic..."
-for f in dj_cheat_sheet_transitions.tex dj_tracklist.tex dj_mini_sheet.tex dj_notes.tex dj_setup_mapping.tex dj_one_laptop_fallback.tex dj_rider.tex dj_podrecznik.tex; do
-  if [ -f "$f" ]; then
-    echo "    -> $f"
-    tectonic "$f" >/dev/null
-  else
-    echo "SKIP: $f not found"
-  fi
-done
-
-echo "[+] Done. Generated PDFs:"
-ls -1 *.pdf 2>/dev/null || true

docs/deployment/DEPLOYMENT_GUIDE.md

@@ -0,0 +1,163 @@
+# Conjurer Deployment Guide
+
+This document walks through deploying the Conjurer stack (Discord bot, music
+service, librarian service) on two Raspberry Pi 4s and one Windows host, first
+with plain Docker Compose, then with a future Kubernetes setup.
+
+## 1. Current Hardware Layout
+
+- **Windows PC**: Stores persistent data (JSON memories, configs, music
+  catalogue). Shares folders over the network (SMB) for the Pis.
+- **Raspberry Pi A** (“radio”): Runs the Liquidsoap/liq radio pipeline and the
+  musician service (Flask + file watcher).
+- **Raspberry Pi B** (“bot”): Runs the Discord bot, communication bridge, and
+  librarian Flask service.
+
+You can rebalance as follows:
+
+| Service             | Recommended Host | Notes |
+|---------------------|------------------|-------|
+| Discord bot + comms | Raspberry Pi B   | Needs outbound internet, moderate CPU |
+| Librarian service   | Raspberry Pi B   | CPU-heavy during Crossref queries; keep close to bot |
+| Musician service    | Raspberry Pi A   | Has direct disk access to music, same box as Liquidsoap |
+| Data storage        | Windows          | Expose via SMB; mount inside containers |
+
+## 2. Prepare Shared Storage on Windows
+
+1. Create directories, e.g. `C:\Conjurer\config`, `C:\Conjurer\logs`,
+   `C:\Conjurer\music`, `C:\Conjurer\playlists`, `C:\Conjurer\secrets`.
+2. Copy your existing JSON settings (`settings.json`, `pamiec.json`,
+   `pamiec_muzyki.json`, `system_gpt_settings.json`, etc.) into `config`.
+3. Create blank placeholder files if they do not exist yet.
+4. Share the root folder (`C:\Conjurer`) over SMB with read/write access for the
+   Pi user (create credentials if necessary).
+
+## 3. Configure Environment Files
+
+1. On your workstation, copy the example env files:
+   ```bash
+   cp docker/env/bot.env.example docker/env/bot.env
+   cp docker/env/musician.env.example docker/env/musician.env
+   cp docker/env/librarian.env.example docker/env/librarian.env
+   ```
+2. Edit each `docker/env/*.env` to replace `HACKME!` with real values:
+   - `DISCORD_TOKEN`, `OPENAI_API_KEY`, `CONJURER_API_KEY` (use the same value for
+     all services).
+   - For musician/librarian, adjust mounts to the SMB paths you will mount on the
+     Pis, e.g. `/mnt/conjurer/music`.
+   - Set `CONJURER_CROSSREF_MAILTO` to a real email as required by Crossref.
+3. If you rely on `.netrc`, copy it to `C:\Conjurer\secrets\.netrc` and set
+   `CONJURER_NETRC_FILE` accordingly.
+
+## 4. Install Docker on Raspberry Pis and Windows
+
+### Raspberry Pi
+```bash
+curl -fsSL https://get.docker.com | sh
+sudo usermod -aG docker $USER
+sudo reboot
+
+# Install docker compose plugin
+sudo apt-get install docker-compose-plugin
+```
+
+### Windows
+- Install **Docker Desktop**.
+- Enable WSL2 backend and expose the shared Windows folders to the containers
+  (Docker Desktop settings → Resources → File Sharing).
+
+## 5. Deploy Musician Service (Pi A)
+
+1. SSH into Raspberry Pi A.
+2. Mount the Windows SMB share:
+   ```bash
+   sudo mkdir -p /mnt/conjurer
+   sudo apt-get install cifs-utils
+   sudo mount -t cifs //WINDOWS_HOST/Conjurer /mnt/conjurer -o user=YOURUSER
+   ```
+   Add an entry to `/etc/fstab` for persistence.
+3. Copy the repo to the Pi or `git clone` it.
+4. On Pi A, create override compose file (optional) pointing volumes to
+   `/mnt/conjurer`.
+5. Start only the musician service:
+   ```bash
+   docker compose up --build -d musician
+   ```
+   Alternatively, duplicate `docker-compose.yml`, strip other services, and run
+   `docker compose up -d`.
+
+## 6. Deploy Bot + Librarian (Pi B)
+
+1. Repeat SMB mount on Pi B (same mount path).
+2. Copy repo / pull latest changes.
+3. Create `.env` files with tokens (or copy from control machine).
+4. Start bot and librarian:
+   ```bash
+   docker compose up -d bot librarian
+   ```
+
+## 7. Optional: Run Supporting Liquidsoap Radio
+
+- Keep Liquidsoap on Pi A as-is, using the same music directories. Ensure the
+  musician container has read access to those directories (bind mount).
+
+## 8. Verifying
+
+1. `docker ps` on each Pi to confirm containers running.
+2. Inspect logs under the mounted logs directory (`/mnt/conjurer/logs`).
+3. Join Discord server; issue commands to confirm functionality.
+4. Hit health endpoints manually (e.g. `curl http://PIB:5000/conjurer`).
+
+## Rebalancing Suggestions
+
+- If librarian CPU spikes become an issue, move it to Pi A or another host.
+- If you add a dedicated NAS, mount the network share read-only for the musician
+  container and read/write for other services.
+
+## 9. Future Kubernetes Deployment (Outline)
+
+### Hardware Considerations
+
+- Minimum three nodes for HA: use the existing two Pis plus one additional Pi 4
+  (8 GB preferred). Use Windows PC as storage provider via NFS/SMB CSI driver or
+  as a data gateway.
+- Consider Pi clusters with USB SSDs for better I/O.
+
+### Cluster Setup Steps
+
+1. Install a lightweight Kubernetes distribution (e.g., k3s) on each Pi:
+   ```bash
+   curl -sfL https://get.k3s.io | sh -
+   # On additional nodes
+   curl -sfL https://get.k3s.io | K3S_URL=https://MASTER:6443 K3S_TOKEN=HACKME sh -
+   ```
+2. Install MetalLB for load balancer support on LAN.
+3. Configure persistent volumes using:
+   - `nfs-subdir-external-provisioner` pointing to Windows share (ensure Windows
+     host supports NFS or run an NFS gateway on another machine).
+   - Alternatively, attach individual USB drives to each Pi and use
+     `local-path-provisioner` for node-local storage.
+4. Create Kubernetes `Secret` objects for tokens (`DISCORD_TOKEN`, etc.).
+5. Define `Deployment` manifests for each service (bot, musician, librarian) and
+   associated `Services`.
+6. Expose Discord bot ports via `NodePort` or Ingress.
+7. Use `StatefulSet` if you need stable identity for the musician service (due to
+   local storage).
+
+### Optimisation Tips
+
+- Keep CPU-heavy librarian pods optionally on a beefier node; use
+  `nodeSelector`/`affinity` to pin workloads.
+- Consider splitting the persistent storage: music on Pi A (USB disk), logs and
+  configs on Pi B, backups on Windows.
+- For improved reliability, add at least one extra Pi for quorum and to host the
+  communication bridge if the bot node fails.
+
+## Summary Checklist
+
+1. Prepare Windows shares & tokens.
+2. Configure `docker/env/*.env` using `HACKME!` templates as reference.
+3. Install Docker on Pis, mount network shares.
+4. Launch musician on Pi A, bot + librarian on Pi B.
+5. Verify Discord functionality and API endpoints.
+6. Plan Kubernetes migration when ready (k3s + MetalLB + storage provisioner).

fontget.sh

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# "apt dla fontów": Google Fonts ZIP → GitHub (ofl RAW) → fonts.gstatic.com → mirrory.
+# System-wide install do /usr/local/share/fonts/fontget/<rodzina> + fc-cache.
+# Usage: sudo ./fontget.sh "IM Fell English SC" "Cinzel Decorative" "EB Garamond"
+
+set -Eeuo pipefail
+SUDO=sudo; [ "$(id -u)" -eq 0 ] && SUDO=
+log(){ echo -e "[+] $*"; }
+warn(){ echo -e "[WARN] $*" >&2; }
+die(){ echo -e "[FATAL] $*" >&2; exit 1; }
+
+need(){ command -v "$1" >/dev/null 2>&1 || die "Missing: $1"; }
+need fc-cache
+command -v wget >/dev/null 2>&1 || command -v curl >/dev/null 2>&1 || die "Need wget/curl"
+command -v unzip >/dev/null 2>&1 || warn "unzip missing — ZIP installs limited"
+command -v file  >/dev/null 2>&1 || warn "file missing — MIME checks limited"
+command -v fc-list >/dev/null 2>&1 || die "Missing: fc-list"
+
+fetch(){ local u="$1" o="$2"; if command -v wget >/dev/null 2>&1; then wget -O "$o" --https-only --no-verbose "$u"; else curl -L --fail --show-error --output "$o" "$u"; fi; }
+slug(){ echo "$1" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-+|-+$//g'; }
+present(){ fc-list -f '%{family}\n' | tr ',' '\n' | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' | tr '[:upper:]' '[:lower:]' | sort -u | grep -Eiq "$1"; }
+
+install_dir="/usr/local/share/fonts/fontget"; $SUDO mkdir -p "$install_dir"
+
+is_zip(){ command -v file >/dev/null 2>&1 && file "$1" | grep -qi zip; }
+gf_zip_try(){
+  local name="$1" outdir="$2" enc zip
+  enc="$(python3 - <<PY
+import urllib.parse,sys
+print(urllib.parse.quote(sys.argv[1]))
+PY
+"$name")" || enc="$(echo "$name" | sed 's/ /%20/g')"
+  zip="$(mktemp /tmp/fontget.XXXXXX.zip)"
+  if fetch "https://fonts.google.com/download?family=${enc}" "$zip"; then
+    if is_zip "$zip"; then $SUDO mkdir -p "$outdir"; $SUDO unzip -o -q "$zip" -d "$outdir" || true; rm -f "$zip"; return 0; fi
+  fi
+  rm -f "$zip" || true; return 1
+}
+gh_ofl_try(){
+  local family="$1" outdir="$2" html
+  html="$(mktemp /tmp/ofl.$(slug "$family").html)"
+  if fetch "https://github.com/google/fonts/tree/main/ofl/$(slug "$family")" "$html"; then
+    mapfile -t paths < <(grep -Eo '/google/fonts/blob/main/ofl/'"$(slug "$family")"'/[^"]+\.(ttf|otf)' "$html" | sed 's|/blob/|/raw/|g' | sort -u)
+    [ "${#paths[@]}" -gt 0 ] || { rm -f "$html"; return 1; }
+    $SUDO mkdir -p "$outdir"
+    for p in "${paths[@]}"; do fetch "https://github.com$p" "$outdir/$(basename "$p")" || true; done
+    rm -f "$html"; return 0
+  fi
+  rm -f "$html"; return 1
+}
+gstatic_try(){ local out="$2"; shift 2; for u in "$@"; do fetch "$u" "$out" && [ -s "$out" ] && return 0; done; return 1; }
+
+report(){ local label="$1" re="$2"; if present "$re"; then printf "RESULT: %-24s : OK\n" "$label"; else printf "RESULT: %-24s : FAIL\n" "$label"; fi }
+
+if [ $# -lt 1 ]; then echo "Usage: $0 <Font Family> [Another ...]"; exit 1; fi
+
+for family in "$@"; do
+  echo; log "=== $family ==="
+  fam_slug="$(slug "$family")"
+  outdir="$install_dir/$fam_slug"
+  $SUDO mkdir -p "$outdir"
+
+  case "$fam_slug" in
+    cinzel-decorative|cinzel|cinzel-decorative-black)
+      fetch "https://github.com/google/fonts/raw/main/ofl/cinzeldecorative/CinzelDecorative-Black.ttf" "$outdir/CinzelDecorative-Black.ttf" || warn "Cinzel fetch failed"
+      ;;
+    im-fell-english-sc)
+      gstatic_try "$fam_slug" "$outdir/IMFeENsc.ttf" \
+        "https://fonts.gstatic.com/s/imfellenglishsc/v7/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
+        "https://fonts.gstatic.com/s/imfellenglishsc/v6/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
+      || { fetch "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true
+           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFellEnglishSC-Regular.ttf" "$outdir/IMFeENsc.ttf" || true
+           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://www.wfonts.com/download/data/2016/06/14/im-fell-english-sc/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true
+           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://www.1001freefonts.com/d/6800/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true; }
+      ;;
+    eb-garamond|ebgaramond)
+      # Najpierw apt (jeśli chcesz: sudo apt install fonts-ebgaramond), tu tylko web:
+      gf_zip_try "$family" "$outdir" || gh_ofl_try "$family" "$outdir" || true
+      ;;
+    *)
+      gf_zip_try "$family" "$outdir" || gh_ofl_try "$family" "$outdir" || true
+      ;;
+  esac
+
+  $SUDO find "$outdir" -type f -size 0 -print -delete || true
+  $SUDO find "$outdir" -type f \( -name "*.ttf" -o -name "*.otf" \) -exec chmod 0644 {} \; || true
+  $SUDO find "$outdir" -type d -exec chmod 0755 {} \; || true
+  $SUDO fc-cache -f -v >/dev/null || true
+
+  case "$fam_slug" in
+    cinzel* )            report "Cinzel Decorative"   '^cinzel decorative( |$)' ;;
+    im-fell-english-sc ) report "IM Fell English SC"  '^im fell english sc( |$)' ;;
+    eb-garamond* )       report "EB Garamond"         '^eb garamond( |$)' ;;
+    * )                  report "$family"             "$(echo "$family" | tr '[:upper:]' '[:lower:]' | sed 's/ /.* /g')" ;;
+  esac
+done
+
+echo; log "All done."

latex_commands.py

@@ -1,22 +1,47 @@
 # latex_commands.py
 # -*- coding: utf-8 -*-
 from __future__ import annotations
+
 import io
-from typing import Optional, List
 import logging
+from typing import Optional
 
 import discord
 from discord import app_commands
 from discord.ext import commands
 
 from constants import (
-    LATEX_TEX_ENGINE, LATEX_MAX_COMPILE_SECONDS, LATEX_MAX_ATTACH_MB, LATEX_MAX_ZIP_MB,
-    OPENAI_MODEL, ALLOWED_ROLES, GUILD_ID
+    ALLOWED_ROLES,
+    GUILD_ID,
+    LATEX_MAX_ATTACH_MB,
+    LATEX_MAX_COMPILE_SECONDS,
+    LATEX_MAX_ZIP_MB,
+    LATEX_TEX_ENGINE,
+    OPENAI_MODEL,
 )
 from latex_functions import (
-    is_tex_attachment, compile_single_tex_bytes, compile_zip_to_zip, ask_openai_diagnosis
+    compile_single_tex_bytes,
+    compile_zip_to_zip,
+    is_safe_asset_name,
+    is_safe_tex_name,
 )
 
+
+async def _collect_attachments_bytes(attachments, max_mb: int):
+    """
+    Zwraca słownik {filename: bytes} dla wszystkich załączników, do limitu MB.
+    Nie podbija wyjątków z .read() — zostawiamy to wyżej; tu zwracamy, co się udało.
+    """
+    out = {}
+    for a in attachments or []:
+        # limit rozmiaru
+        if (getattr(a, "size", 0) or 0) > max_mb * 1024 * 1024:
+            continue
+        data = await a.read()
+        out[a.filename] = data
+    return out
+
+
 class LatexModule(commands.Cog):
     def __init__(self, bot: commands.Bot, logger_name: str):
         self.bot = bot
@@ -31,47 +56,94 @@ class LatexModule(commands.Cog):
         guild=None if GUILD_ID is None else discord.Object(id=GUILD_ID),
     )
     @commands.has_any_role(*ALLOWED_ROLES)
-    async def tex(self, ctx: commands.Context, include_source_excerpt: Optional[bool] = True):
+    async def tex(
+        self, ctx: commands.Context, include_source_excerpt: Optional[bool] = True
+    ):
         self.logger.info("LaTeX command invoked by %s", ctx.author)
         ch = ctx.message.channel
+        # ZBIERZ WSZYSTKIE ZAŁĄCZNIKI
         async with ch.typing():
-            atts = [a for a in (ctx.message.attachments or []) if is_tex_attachment(a, LATEX_MAX_ATTACH_MB)]
-            if not atts:
-                return await ctx.reply(f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False)
-            self.logger.debug("LaTeX attachments: %s", ", ".join(a.filename for a in atts))
-            files: List[discord.File] = []
-            parts: List[str] = []
-            for att in atts:
+            all_bytes = await _collect_attachments_bytes(
+                ctx.message.attachments, LATEX_MAX_ATTACH_MB
+            )
+            if not all_bytes:
+                return await ctx.reply(
+                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
+                )
+
+            # PODZIEL NA GŁÓWNE .TEX i WSPIERAJĄCE
+            tex_names = [
+                n
+                for n in all_bytes.keys()
+                if n.lower().endswith(".tex") and is_safe_tex_name(n)
+            ]
+            if not tex_names:
+                return await ctx.reply(
+                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
+                )
+
+            support_names = [
+                n
+                for n in all_bytes.keys()
+                if n not in tex_names and is_safe_asset_name(n)
+            ]
+
+            files_to_send = []
+            parts = []
+
+            for tex_name in tex_names:
                 try:
-                    data = await att.read()
-                    self.logger.info("LaTeX read %s bytes from %s", len(data), att.filename)
-                    res = await compile_single_tex_bytes(data, att.filename, LATEX_TEX_ENGINE, LATEX_MAX_COMPILE_SECONDS, logger=self.logger_name)
-                    self.logger.info("LaTeX result for %s: %s", att.filename, res)
-                    self.logger.info("LaTeX log (%s)\n%s", att.filename, (res["log_text"] or "")[-2000:])
+                    main_bytes = all_bytes[tex_name]
+                    support = [
+                        (n, all_bytes[n])
+                        for n in support_names
+                        if n != tex_name and is_safe_asset_name(n)
+                    ]
+                    # (ważne) do supportów dopuszczamy również **inne .tex** – dla \input/\include
+                    other_tex = [
+                        (n, all_bytes[n])
+                        for n in tex_names
+                        if n != tex_name and is_safe_tex_name(n)
+                    ]
+                    support.extend(other_tex)
+
+                    res = await compile_single_tex_bytes(
+                        main_bytes,
+                        tex_name,
+                        LATEX_TEX_ENGINE,
+                        LATEX_MAX_COMPILE_SECONDS,
+                        logger="discord",
+                        support_files=support,
+                    )
+
+                    # Twoja dotychczasowa obsługa success/fail – przykładowo:
                     if res["ok"] and res["pdf_bytes"]:
                         b = io.BytesIO(res["pdf_bytes"])
                         b.seek(0)
                         b.name = res["pdf_name"]
-                        files.append(discord.File(b, filename=res["pdf_name"]))
-                        parts.append(f"✅ `{att.filename}` → `{res['pdf_name']}`")
+                        files_to_send.append(discord.File(b, filename=res["pdf_name"]))
+                        parts.append(f"✅ `{tex_name}` → `{res['pdf_name']}`")
                     else:
-                        self.logger.info("LaTeX compile failed for %s", att.filename)
-                        excerpt = ""
-                        if include_source_excerpt:
-                            try:
-                                excerpt = data.decode("utf-8", errors="ignore")[:4000]
-                            except Exception:
-                                excerpt = ""
-                                advice = await ask_openai_diagnosis(res["log_text"] or "", excerpt, OPENAI_MODEL, logger=self.logger_name)
-                                parts.append(f"❌ `{att.filename}` — błąd kompilacji.\nDiagnoza:\n{advice}")
-                                raise
-                except Exception as e:
-                    self.logger.info("Exception %s: %s", att.filename, e)
-                    parts.append(f"⚠️ `{att.filename}` — wyjątek (szczegóły w logu).")
+                        parts.append(
+                            f"❌ `{tex_name}` — błąd kompilacji.)"
+                        )
+                        # Tutaj wywołujesz swoją ścieżkę do OpenAI diagnozy, którą ogarnęliśmy wcześniej.
+                except Exception:
+                    # let it crash — pełny stack w logu i re-raise (Discord.py to pokaże sensownie)
+                    logging.getLogger("discord").exception(
+                        "Unhandled exception while compiling %s", tex_name
+                    )
                     raise
 
-            content = f"**LaTeX** — {len(atts)} plik(ów). Model: `{OPENAI_MODEL}`\n\n" + "\n\n".join(parts)
-            await ctx.reply(content if len(content)<1900 else content[:1900]+"…", files=files, mention_author=False)
+                content = (
+                    f"**LaTeX** — {len(tex_names)} plik(ów). Model: `{OPENAI_MODEL}`\n\n"
+                    + "\n\n".join(parts)
+                )
+                await ctx.reply(
+                    content if len(content) < 1900 else content[:1900] + "…",
+                    files=files_to_send,
+                    mention_author=False,
+                )
 
     # -------- /latexclean (PDF only; log -> debug logger) --------
     @commands.hybrid_command(
@@ -84,57 +156,123 @@ class LatexModule(commands.Cog):
     async def latexclean(self, ctx: commands.Context):
         ch = ctx.message.channel
         async with ch.typing():
-            atts = [a for a in (ctx.message.attachments or []) if is_tex_attachment(a, LATEX_MAX_ATTACH_MB)]
-            if not atts:
-                return await ctx.reply(f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False)
+            all_bytes = await _collect_attachments_bytes(
+                ctx.message.attachments, LATEX_MAX_ATTACH_MB
+            )
+            if not all_bytes:
+                return await ctx.reply(
+                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
+                )
 
-            files: List[discord.File] = []
-            parts: List[str] = []
-            for att in atts:
+            # PODZIEL NA GŁÓWNE .TEX i WSPIERAJĄCE
+            tex_names = [
+                n
+                for n in all_bytes.keys()
+                if n.lower().endswith(".tex") and is_safe_tex_name(n)
+            ]
+            if not tex_names:
+                return await ctx.reply(
+                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
+                )
+
+            support_names = [
+                n
+                for n in all_bytes.keys()
+                if n not in tex_names and is_safe_asset_name(n)
+            ]
+
+            files_to_send = []
+            parts = []
+
+            for tex_name in tex_names:
                 try:
-                    data = await att.read()
-                    res = await compile_single_tex_bytes(data, att.filename, LATEX_TEX_ENGINE, LATEX_MAX_COMPILE_SECONDS, logger=self.logger_name)
-                    self.logger.debug("LaTeX CLEAN (%s)\n%s", att.filename, (res["log_text"] or "")[-2000:])
+                    main_bytes = all_bytes[tex_name]
+                    support = [
+                        (n, all_bytes[n])
+                        for n in support_names
+                        if n != tex_name and is_safe_asset_name(n)
+                    ]
+                    # (ważne) do supportów dopuszczamy również **inne .tex** – dla \input/\include
+                    other_tex = [
+                        (n, all_bytes[n])
+                        for n in tex_names
+                        if n != tex_name and is_safe_tex_name(n)
+                    ]
+                    support.extend(other_tex)
+
+                    res = await compile_single_tex_bytes(
+                        main_bytes,
+                        tex_name,
+                        LATEX_TEX_ENGINE,
+                        LATEX_MAX_COMPILE_SECONDS,
+                        logger="discord",
+                        support_files=support,
+                    )
+
+                    # Twoja dotychczasowa obsługa success/fail – przykładowo:
                     if res["ok"] and res["pdf_bytes"]:
                         b = io.BytesIO(res["pdf_bytes"])
                         b.seek(0)
                         b.name = res["pdf_name"]
-                        files.append(discord.File(b, filename=res["pdf_name"]))
-                        parts.append(f"✅ `{att.filename}`")
+                        files_to_send.append(discord.File(b, filename=res["pdf_name"]))
+                        parts.append(f"✅ `{tex_name}` → `{res['pdf_name']}`")
                     else:
-                        parts.append(f"❌ `{att.filename}` — błąd (log w debug).")
-                except Exception as e:
-                    self.logger.debug("CLEAN exception %s: %s", att.filename, e)
-                    parts.append(f"⚠️ `{att.filename}` — wyjątek (log w debug).")
+                        parts.append(
+                            f"❌ `{tex_name}` — błąd kompilacji.)"
+                        )
+                        # Tutaj wywołujesz swoją ścieżkę do OpenAI diagnozy, którą ogarnęliśmy wcześniej.
+                except Exception:
+                    # let it crash — pełny stack w logu i re-raise (Discord.py to pokaże sensownie)
+                    logging.getLogger("discord").exception(
+                        "Unhandled exception while compiling %s", tex_name
+                    )
                     raise
-
-            await ctx.reply("**LaTeX clean** — " + ", ".join(parts), files=files, mention_author=False)
+            await ctx.reply(
+                "**LaTeX clean** — " + ", ".join(parts),
+                files=files_to_send,
+                mention_author=False,
+            )
 
     # -------- /texbatch (ZIP -> ZIP) --------
     @app_commands.command(
         name="texbatch",
-        description="Wyślij ZIP z .tex → odeślę ZIP z PDF-ami (tylko udane)."
+        description="Wyślij ZIP z .tex → odeślę ZIP z PDF-ami (tylko udane).",
     )
     @app_commands.describe(archive=f"Archiwum .zip (max ~{LATEX_MAX_ZIP_MB} MiB)")
     @app_commands.checks.has_any_role(*ALLOWED_ROLES)
-    async def texbatch(self, interaction: discord.Interaction, archive: discord.Attachment):
+    async def texbatch(
+        self, interaction: discord.Interaction, archive: discord.Attachment
+    ):
         await interaction.response.defer()
         if not archive or not archive.filename.lower().endswith(".zip"):
-            return await interaction.followup.send("Dołącz ZIP (.zip) z plikami .tex.", ephemeral=True)
+            return await interaction.followup.send(
+                "Dołącz ZIP (.zip) z plikami .tex.", ephemeral=True
+            )
         if archive.size > LATEX_MAX_ZIP_MB * 1024 * 1024:
-            return await interaction.followup.send(f"ZIP > {LATEX_MAX_ZIP_MB} MiB — za duży.", ephemeral=True)
+            return await interaction.followup.send(
+                f"ZIP > {LATEX_MAX_ZIP_MB} MiB — za duży.", ephemeral=True
+            )
 
         data = await archive.read()
-        out_zip_bytes, failed = await compile_zip_to_zip(data, LATEX_TEX_ENGINE, LATEX_MAX_COMPILE_SECONDS, logger=self.logger_name)
+        out_zip_bytes, failed = await compile_zip_to_zip(
+            data, LATEX_TEX_ENGINE, LATEX_MAX_COMPILE_SECONDS, logger=self.logger_name
+        )
         if not out_zip_bytes and failed:
-            return await interaction.followup.send("Brak PDF-ów. " + "; ".join(failed[:10]), ephemeral=True)
+            return await interaction.followup.send(
+                "Brak PDF-ów. " + "; ".join(failed[:10]), ephemeral=True
+            )
 
         bio = io.BytesIO(out_zip_bytes)
         bio.seek(0)
         bio.name = "compiled_pdfs.zip"
         if failed:
             self.logger.debug("BATCH failed: %s", ", ".join(failed))
-        await interaction.followup.send("✅ Gotowe (ZIP w załączniku)." + (f" ❌ Błędy: {len(failed)}" if failed else ""), files=[discord.File(bio, filename=bio.name)])
+        await interaction.followup.send(
+            "✅ Gotowe (ZIP w załączniku)."
+            + (f" ❌ Błędy: {len(failed)}" if failed else ""),
+            files=[discord.File(bio, filename=bio.name)],
+        )
+
 
 async def setup(bot):
     logger = logging.getLogger("discord")

latex_functions.py

@@ -1,149 +1,121 @@
-# latex_functions.py
-# -*- coding: utf-8 -*-
-from __future__ import annotations
-
 import asyncio
 import logging
 import re
+import shutil
 import tempfile
 import zipfile
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-
-from ai_functions import handle_response
+from typing import Dict, Iterable, List, Optional, Tuple
 
+# ===== Bezpieczeństwo nazw/rozszerzeń =====
 SAFE_TEX_NAME = re.compile(r"^[\w\-. ]+\.tex$", re.IGNORECASE)
-
+SAFE_ASSET_NAME = re.compile(
+    r"^[\w\-. /]+?\.(tex|png|jpg|jpeg|pdf|svg|eps|bmp|gif|sty|cls|bib|bst|bbx|cbx|def|cfg)$",
+    re.IGNORECASE,
+)
 
 def is_safe_tex_name(name: str) -> bool:
-    return bool(SAFE_TEX_NAME.match(name or "")) and name.lower().endswith(".tex")
+    return bool(SAFE_TEX_NAME.match(name or ""))
 
+def is_safe_asset_name(name: str) -> bool:
+    return bool(SAFE_ASSET_NAME.match(name or ""))
 
-def is_tex_attachment(att, max_mb: int) -> bool:
-    """Filtruje discord.Attachment: tylko .tex + limit MB + nazwa bezpieczna."""
-    return bool(
-        getattr(att, "filename", "")
-        and is_safe_tex_name(att.filename)
-        and getattr(att, "size", 0) <= max_mb * 1024 * 1024
+# ===== Uruchamianie kompilatora =====
+
+async def _run(cmd: List[str], cwd: Path, timeout_sec: int, logger_name: Optional[str]) -> Tuple[int, str]:
+    """Uruchamia proces kompilatora w cwd, zwraca (rc, sklejone_stdout_stderr)."""
+    logger = logging.getLogger(logger_name) if logger_name else logging.getLogger()
+    logger.debug("RUN %s (cwd=%s, timeout=%s)", " ".join(cmd), cwd, timeout_sec)
+
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+        cwd=str(cwd),
     )
+    try:
+        out = await asyncio.wait_for(proc.communicate(), timeout=timeout_sec)
+    except asyncio.TimeoutError:
+        try:
+            proc.kill()
+        finally:
+            pass
+        return 124, "TIMEOUT: compiler took too long"
+    rc = proc.returncode
+    log = (out[0] or b"").decode("utf-8", errors="ignore")
+    logger.debug("RC=%s, LOG TAIL:\n%s", rc, log[-1500:])
+    return rc, log
 
-
-def _build_cmd(engine: str, tex_filename: str) -> list[str]:
-    base = (engine or "").strip().lower()
-    if base in ("pdflatex", "xelatex", "lualatex"):
-        return [
-            base,
-            "-interaction=nonstopmode",
-            "-halt-on-error",
-            "-file-line-error",
-            "-no-shell-escape",
-            tex_filename,
-        ]
-    if base == "latexmk":
-        return [
-            "latexmk",
-            "-pdf",
-            "-interaction=nonstopmode",
-            "-halt-on-error",
-            "-file-line-error",
-            tex_filename,
-        ]
-    if base == "tectonic":
-        return [
-            "tectonic",
-            "-X",
-            "compile",
-            "--keep-logs",
-            "--outdir",
-            ".",
-            tex_filename,
-        ]
-    return [
-        "pdflatex",
-        "-interaction=nonstopmode",
-        "-halt-on-error",
-        "-file-line-error",
-        "-no-shell-escape",
-        tex_filename,
-    ]
-
+def _build_cmd(tex_engine: str, main_tex: str) -> List[str]:
+    """Buduje komendę kompilatora; domyślnie tectonic/pdflatex/xelatex."""
+    if tex_engine.lower() == "tectonic":
+        # Tectonic sam robi wielofazowość, ale i tak uruchamiamy 2x (bezpiecznie dla bib/refs)
+        return ["tectonic", "--keep-intermediates", "--synctex", main_tex]
+    elif tex_engine.lower() in ("pdflatex", "xelatex", "lualatex"):
+        return [tex_engine, "-interaction=nonstopmode", "-halt-on-error", main_tex]
+    else:
+        # fallback – traktujemy jak pdflatex
+        return ["pdflatex", "-interaction=nonstopmode", "-halt-on-error", main_tex]
 
 async def run_latex_two_passes(
-    tex_filename: str,
-    workdir: Path,
-    tex_engine: str,
-    timeout_sec: int,
-    logger: str = None,
-):
-    logger = logging.getLogger(logger) if logger else None
-
-    async def run_once(cmd: list[str]) -> tuple[int, str]:
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            cwd=str(workdir),
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.STDOUT,
-        )
-        try:
-            out_b, _ = await asyncio.wait_for(proc.communicate(), timeout=timeout_sec)
-            return (proc.returncode or 0), (out_b or b"").decode(
-                "utf-8", errors="replace"
-            )
-        except asyncio.TimeoutError:
-            try:
-                proc.kill()
-            except Exception:
-                raise
-            return 124, f"[Timeout] Compilation exceeded {timeout_sec}s.\n"
-
-    logs = []
-    cmd = _build_cmd(tex_engine, tex_filename)
-    if logger:
-        logger.debug("LaTeX cmd: %s (cwd=%s)", " ".join(cmd), workdir)
-
-    rc1, out1 = await run_once(cmd)
-    logs.append(out1)
-    second_pass = not ((tex_engine or "").strip().lower() == "tectonic")
+    tex_filename: str, workdir: Path, tex_engine: str, timeout_sec: int, logger: Optional[str] = None
+) -> Tuple[bool, str, Path]:
+    """
+    Uruchamia kompilację 2 razy (bezpieczeństwo referencji/bib).
+    Zwraca: (ok, log_text, pdf_path).
+    """
+    logger_obj = logging.getLogger(logger) if logger else logging.getLogger()
+    logger_obj.info("Compiling %s with %s engine two passes", tex_filename, tex_engine)
+    logs: List[str] = []
+    pdf_path = workdir / (Path(tex_filename).stem + ".pdf")
 
+    # PASS 1
+    rc1, log1 = await _run(_build_cmd(tex_engine, tex_filename), workdir, timeout_sec, logger)
+    logs.append(log1)
     if rc1 != 0:
-        log_text = "".join(logs)
-        pdf = workdir / (Path(tex_filename).stem + ".pdf")
-        return False, log_text, pdf
+        return False, "".join(logs), pdf_path
 
-    if second_pass:
-        rc2, out2 = await run_once(cmd)
-        logs.append(out2)
-        ok = rc2 == 0
-    else:
-        ok = rc1 == 0
-
-    log_text = "".join(logs)
-    pdf = workdir / (Path(tex_filename).stem + ".pdf")
-    ok = ok and pdf.exists()
-    return ok, log_text, pdf
+    # PASS 2 (często już nic nie robi, ale nie szkodzi)
+    rc2, log2 = await _run(_build_cmd(tex_engine, tex_filename), workdir, timeout_sec, logger)
+    logs.append(log2)
+    ok = (rc2 == 0) and pdf_path.exists()
+    return ok, "".join(logs), pdf_path
 
+# ===== Kompilacje: pojedynczy TEX + ZIP =====
 
 async def compile_single_tex_bytes(
     tex_bytes: bytes,
     filename: str,
     tex_engine: str,
     timeout_sec: int,
-    logger: str = None,
+    logger: Optional[str] = None,
+    support_files: Optional[Iterable[Tuple[str, bytes]]] = None,
 ) -> Dict[str, Optional[object]]:
+    """
+    Kompiluje pojedynczy .tex + dowolne pliki pomocnicze (obrazy, sty/cls/bib, inne .tex).
+    Każdy plik zapisujemy w katalogu roboczym widocznym dla kompilatora.
+    """
+    log = logging.getLogger(logger) if logger else logging.getLogger()
+    log.info("Compiling %s with %s engine single tex", filename, tex_engine)
     if not is_safe_tex_name(filename):
-        return {
-            "ok": False,
-            "pdf_bytes": None,
-            "log_text": "Invalid .tex filename",
-            "pdf_name": None,
-        }
+        return {"ok": False, "pdf_bytes": None, "log_text": "Invalid .tex filename", "pdf_name": None}
+
     with tempfile.TemporaryDirectory(prefix="latex_one_") as td:
         wd = Path(td)
-        tex_path = wd / filename
-        tex_path.write_bytes(tex_bytes)
-        ok, log_text, pdf_path = await run_latex_two_passes(
-            filename, wd, tex_engine, timeout_sec, logger=logger
-        )
+        (wd / Path(filename).name).write_bytes(tex_bytes)
+
+        # Zapisz wszystkie supporty obok głównego pliku
+        if support_files:
+            for fname, data in support_files:
+                if not fname or not is_safe_asset_name(fname):
+                    continue
+                # spłaszczamy do nazwy bazowej (bez podkatalogów z zewn. źródeł)
+                (wd / Path(fname).name).write_bytes(data)
+
+        ok, log_text, pdf_path = await run_latex_two_passes(Path(filename).name, wd, tex_engine, timeout_sec, logger)
+        log.info("LaTeX compile finished: %s", "OK" if ok else "FAIL")
+        log.info("Log text:\n%s", log_text[-2000:])  # Log last 2000 chars
+        log.info("PDF path: %s", pdf_path)
         if ok and pdf_path.exists():
             return {
                 "ok": True,
@@ -151,83 +123,57 @@ async def compile_single_tex_bytes(
                 "log_text": log_text,
                 "pdf_name": pdf_path.name,
             }
-        return {
-            "ok": False,
-            "pdf_bytes": None,
-            "log_text": log_text,
-            "pdf_name": pdf_path.name,
-        }
-
+        return {"ok": False, "pdf_bytes": None, "log_text": log_text, "pdf_name": pdf_path.name}
 
 async def compile_zip_to_zip(
-    zip_bytes: bytes, tex_engine: str, timeout_sec: int, logger: str = None
+    zip_bytes: bytes, tex_engine: str, timeout_sec: int, logger: Optional[str] = None
 ) -> Tuple[bytes, List[str]]:
+    """
+    Rozpakowuje ZIP, znajduję wszystkie .tex i dla KAŻDEGO tworzy osobny katalog roboczy
+    ze skopiowanym CAŁYM drzewem, by zachować ścieżki względne obrazków/plików.
+    Zwraca (zip_pdf_bytes, lista_rel_sciezek_które_padły).
+    """
+    log = logging.getLogger(logger) if logger else logging.getLogger()
     failed: List[str] = []
     out_pdf_paths: List[Path] = []
+
     with tempfile.TemporaryDirectory(prefix="latex_zip_") as td:
         td_path = Path(td)
-        in_zip = td_path / "in.zip"
-        in_zip.write_bytes(zip_bytes)
-        extract_dir = td_path / "in"
-        extract_dir.mkdir(parents=True, exist_ok=True)
-        with zipfile.ZipFile(in_zip, "r") as zf:
-            zf.extractall(extract_dir)
+        src_root = td_path / "src"
+        src_root.mkdir(parents=True, exist_ok=True)
 
-        tex_files = [p for p in extract_dir.rglob("*.tex") if is_safe_tex_name(p.name)]
+        # 1) Rozpakuj
+        zpath = td_path / "in.zip"
+        zpath.write_bytes(zip_bytes)
+        with zipfile.ZipFile(zpath, "r") as zf:
+            zf.extractall(src_root)
+
+        # 2) Zbierz .tex
+        tex_files = [p for p in src_root.rglob("*.tex") if is_safe_tex_name(p.name)]
         if not tex_files:
             return b"", ["No .tex files found in archive."]
 
-        for tex in tex_files:
+        # 3) Kompiluj każdy .tex w izolacji (kopiujemy całe drzewo do osobnego workdiru)
+        for tex_path in tex_files:
+            rel_tex = tex_path.relative_to(src_root).as_posix()
+            work = td_path / f"build_{tex_path.stem}"
             try:
-                work = td_path / f"build_{tex.stem}"
-                work.mkdir(parents=True, exist_ok=True)
-                target_tex = work / tex.name
-                target_tex.write_bytes(tex.read_bytes())
-                ok, log_text, pdf_path = await run_latex_two_passes(
-                    target_tex.name, work, tex_engine, timeout_sec, logger=logger
-                )
-                if ok and pdf_path.exists():
-                    out_pdf_paths.append(pdf_path)
+                shutil.copytree(src_root, work / "src")
+                ok, log_text, pdf = await run_latex_two_passes(rel_tex, work / "src", tex_engine, timeout_sec, logger)
+                if ok and pdf.exists():
+                    out_pdf_paths.append(pdf)
                 else:
-                    failed.append(tex.name)
-                    if logger:
-                        logger.debug("BATCH FAIL %s\n%s", tex.name, log_text[-1500:])
-            except Exception as e:
-                failed.append(f"{tex.name} (exception: {e})")
-                if logger:
-                    logger.debug("BATCH EXC %s: %s", tex.name, e)
+                    failed.append(rel_tex)
+                    log.info("LaTeX FAIL %s\n%s", rel_tex, (log_text or "")[-2000:])
+            except Exception:
+                # let it crash – log + re-raise (to zobaczy wyższa warstwa/discord.py)
+                log.exception("Exception while compiling %s", rel_tex)
                 raise
 
+        # 4) Spakuj wyjściowe PDF-y
         out_zip = td_path / "compiled_pdfs.zip"
         with zipfile.ZipFile(out_zip, "w", compression=zipfile.ZIP_DEFLATED) as zf:
             for pdf in out_pdf_paths:
                 zf.write(pdf, arcname=pdf.name)
 
         return out_zip.read_bytes(), failed
-
-
-async def ask_openai_diagnosis(
-    log_text: str, tex_excerpt: str, model: str, logger: str = None
-) -> str:
-    logger = logging.getLogger(logger) if logger else None
-    sys = (
-        "You are a LaTeX build diagnostician. Analyze pdflatex log and return:\n"
-        "1) Root causes (bullets)\n2) Minimal working fix (code block)\n3) Alternative fix"
-    )
-    logger.debug("LaTeX DIAG (%s)\n%s", model, log_text[-9000:])
-    usr = f"---LOG---\n{log_text[-9000:]}\n---END LOG---"
-    if tex_excerpt:
-        usr += f"\n---TEX EXCERPT---\n{tex_excerpt[:4000]}\n---END EXCERPT---"
-        prompt = [{"role": sys, "content": "none"}, {"role": "user", "content": usr}]
-
-        response, _ = await handle_response(
-            prompt,
-            None,
-            None,
-            prompt,
-            "latex_diagnosis",
-            "NONE",
-            algorithm=model,
-            none_request=prompt,
-        )
-    return response

librarian_commands.py

@@ -15,7 +15,9 @@ from discord.ext import commands, tasks
 
 from ai_functions import handle_response
 from communication_subroutine import IN_COMM_Q, OUT_COMM_Q, QueryControl
-from constants import DIR_PATH_SADOX, LIBRARIAN_SERVICE_ADDRESS, SEND_QUERY
+from constants import DIR_PATH_SADOX, LIBRARIAN_SERVICE_ADDRESS, SEND_QUERY, service_headers
+
+SERVICE_HEADERS = service_headers()
 
 
 class DataModule(commands.Cog):
@@ -165,6 +167,7 @@ class DataModule(commands.Cog):
             requests.post,
             f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}",
             json=json_query,
+            headers=SERVICE_HEADERS,
             timeout=360,
         )
         await ctx.send(
@@ -260,6 +263,7 @@ class DataModule(commands.Cog):
             requests.post,
             f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}",
             json=json_query,
+            headers=SERVICE_HEADERS,
             timeout=360,
         )
         await ctx.send(

music_functions.py

@@ -17,10 +17,13 @@ from constants import (
     SEND_MP3,
     SPOTIFY_CTRL,
     YOUTUBE_AUTH,
+    service_headers,
 )
 from spotify_dl import spotify
 from spotify_dl import youtube as youtube_download
 
+SERVICE_HEADERS = service_headers()
+
 
 
 class MusicFileList(object):
@@ -43,7 +46,11 @@ class MusicFileList(object):
         """
         try:
             self.logger.info("Attempt to connect to file service")
-            response = requests.get(f"{FILE_SERVICE_ADDRESS}{GET_MP3}", timeout=360)
+            response = requests.get(
+                f"{FILE_SERVICE_ADDRESS}{GET_MP3}",
+                headers=SERVICE_HEADERS,
+                timeout=360,
+            )
             self.music_file_list = response.json()["music_file_list"]
             self.file_service_active = True
         except requests.exceptions.RequestException as e:
@@ -98,7 +105,12 @@ class MusicFileList(object):
         """
         self.music_file_list.append(item)
         post_data = {"item": str(item)}
-        requests.post(f"{FILE_SERVICE_ADDRESS}{SEND_MP3}", json=post_data, timeout=360)
+        requests.post(
+            f"{FILE_SERVICE_ADDRESS}{SEND_MP3}",
+            json=post_data,
+            headers=SERVICE_HEADERS,
+            timeout=360,
+        )
 
 
 MUSIC_FILE_LIST = MusicFileList("discord")
@@ -308,6 +320,7 @@ async def search_music(ctx, how_many=0, slowa_kluczowe=None):
         requests.post,
         f"{FILE_SERVICE_ADDRESS}{GET_PLAYLIST}",
         json=jrequest,
+        headers=SERVICE_HEADERS,
         timeout=360,
     )
     return_data = await coroutine

pamiec.json

@@ -234,5 +234,21 @@
     {
         "role": "assistant",
         "content": "Jakich konkretnych informacji mam si\u0119 douczy\u0107? Jestem tu po to, aby Ci pom\u00f3c, wi\u0119c jestem otwarty na uzupe\u0142nienie swojej wiedzy w dowolnym zakresie, o ile tylko nie \u0142amie to zasad regulaminu i etyki."
+    },
+    {
+        "role": "user",
+        "content": "The Bartender [S\u0142o\u0144ce z Betonu]:@Conjurer halo ?"
+    },
+    {
+        "role": "assistant",
+        "content": "*Kondziu patrzy na terminal* Wo\u0142aj szefa. Zap\u0142aci\u0107 rachunki za AI trzeba. Jak chcesz to si\u0119 na #zebranie dorzu\u0107. Error code: 429 - {'error': {'message': 'You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs: https://platform.openai.com/docs/guides/error-codes/api-errors.', 'type': 'insufficient_quota', 'param': None, 'code': 'insufficient_quota'}}"
+    },
+    {
+        "role": "user",
+        "content": "The Bartender [S\u0142o\u0144ce z Betonu]:helo\u0142 @Nocna Zmiana dwie wiadomo\u015bci dobra i jeszcze gorsza.\n@Conjurer zosta\u0142 zreanimowany po d\u0142u\u017cszej nieobecno\u015bci - ale jak zaraz sami zobaczycie je\u015b\u0107 wo\u0142a. nie dzia\u0142a w nim te\u017c jeszcze wyszukiwanie artyku\u0142\u00f3w naukowych (do tego trzy tygodnie developmentu posz\u0142y w p*****ec). wyszukiwarka wr\u00f3ci jak dotrze zam\u00f3wienie z kieszeniami na dysk @gwojtal - bedzie trzeba \u015bci\u0105gn\u0105\u0107 snapshot bazy i uruchomi\u0107 cz\u0119\u015b\u0107 odpowiedzialn\u0105 za wyszukiwanie w nim. specjalne funkcje b\u0119d\u0119 odblokowywa\u0142 w miare ich naprawiania - tak samo dam mu oczywi\u015bcie je\u015b\u0107 z w\u0142asnej kieszeni jak ju\u017c b\u0119dzie potrzeba."
+    },
+    {
+        "role": "assistant",
+        "content": "*Kondziu patrzy na terminal* Wo\u0142aj szefa. Zap\u0142aci\u0107 rachunki za AI trzeba. Jak chcesz to si\u0119 na #zebranie dorzu\u0107. Error code: 429 - {'error': {'message': 'You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs: https://platform.openai.com/docs/guides/error-codes/api-errors.', 'type': 'insufficient_quota', 'param': None, 'code': 'insufficient_quota'}}"
     }
 ]

pamiec_muzyki.json

@@ -787,4 +787,4 @@
         "role": "assistant",
         "content": "\"Coffin Fodder\" to utw\u00f3r z albumu \"Nymphetamine\" brytyjskiego zespo\u0142u Cradle Of Filth. To  death-metalowe brzmienie z elementami black metalu i gotyckiego rocka. \n\nTekst utworu to prowokacyjne po\u0142\u0105czenie j\u0119zyka poetyckiego z drastycznymi opisami \u015bmierci i ciemn\u0105 estetyk\u0105, charakterystyczn\u0105 dla tw\u00f3rczo\u015bci Cradle Of Filth. \n\n\"Coffin Fodder\" opowiada histori\u0119 mordercy zabijaj\u0105cego kobiety i wk\u0142adaj\u0105cego ich cia\u0142a do trumien, aby zaspokoi\u0107 swoje mroczne i okrutne pragnienia. To utw\u00f3r pe\u0142en brutalnych opis\u00f3w, kt\u00f3rych celem jest szokowanie i wywo\u0142anie wstr\u0119tu w s\u0142uchaczu. \n\nPod wzgl\u0119dem muzycznym, \"Coffin Fodder\" charakteryzuje si\u0119 szybkim tempem, ci\u0119\u017ckimi riffami gitary i intensywnymi partiami perkusyjnymi. Utw\u00f3r jest jednym z bardziej ekstremalnych utwor\u00f3w zespo\u0142u Cradle Of Filth, co czyni go atrakcyjnym dla mi\u0142o\u015bnik\u00f3w mocnej i agresywnej muzyki metalowej."
     }
-]
+]

radio_commands.py

@@ -8,7 +8,9 @@ import uuid
 
 import asyncio
 from datetime import datetime
-from constants import RADIO_HARBOR_ADDRESS, SKIP_TRACK, FILE_SERVICE_ADDRESS, ADD_TO_PRIO_PLAYLIST, REQUEST_MUSIC, CREATE_PRIO_PLAYLIST, CLEAR_PRIO
+from constants import RADIO_HARBOR_ADDRESS, SKIP_TRACK, FILE_SERVICE_ADDRESS, ADD_TO_PRIO_PLAYLIST, REQUEST_MUSIC, CREATE_PRIO_PLAYLIST, CLEAR_PRIO, service_headers
+
+SERVICE_HEADERS = service_headers()
 
 class RadioModule(commands.Cog):
     def __init__(self, bot, logger_name):
@@ -34,6 +36,7 @@ class RadioModule(commands.Cog):
                 coroutine = asyncio.to_thread(
                     requests.get,
                     f"{RADIO_HARBOR_ADDRESS}{SKIP_TRACK}",
+                    headers=SERVICE_HEADERS,
                     timeout=360,
                 )
                 result = await coroutine
@@ -95,6 +98,7 @@ class RadioModule(commands.Cog):
                 requests.post,
                 f"{FILE_SERVICE_ADDRESS}{ADD_TO_PRIO_PLAYLIST}",
                 json=jrequest,
+                headers=SERVICE_HEADERS,
                 timeout=360,
             )
             result = await coroutine
@@ -130,6 +134,7 @@ class RadioModule(commands.Cog):
                 requests.post,
                 f"{FILE_SERVICE_ADDRESS}{REQUEST_MUSIC}",
                 json=jrequest,
+                headers=SERVICE_HEADERS,
                 timeout=360,
             )
             result = await coroutine
@@ -167,6 +172,7 @@ class RadioModule(commands.Cog):
                 requests.post,
                 f"{FILE_SERVICE_ADDRESS}{CREATE_PRIO_PLAYLIST}",
                 json=jrequest,
+                headers=SERVICE_HEADERS,
                 timeout=360,
             )
             result = await coroutine
@@ -194,6 +200,7 @@ class RadioModule(commands.Cog):
             coroutine = asyncio.to_thread(
                 requests.get,
                 f"{FILE_SERVICE_ADDRESS}{CLEAR_PRIO}",
+                headers=SERVICE_HEADERS,
                 timeout=360,
             )
             result = await coroutine

requirements_bot copy.txt

@@ -1,21 +0,0 @@
-setuptools
-discord
-yaach
-t_dlp
-spotify_dl
-spotipy
-openai
-eyed3
-numpy
-pdf2image
-PyPDF2
-requests
-spotipy
-tiktoken
-PyNaCl
-flask[async]
-waitress
-clickupython
-assemblyai[extras]
-SpeechRecognition
-git+https://github.com/imayhaveborkedit/discord-ext-voice-recvO

requirements_bot.txt

@@ -15,7 +15,8 @@ PyNaCl
 flask[async]
 PyMuPDF
 waitress
-clickupython
 assemblyai[extras]
 SpeechRecognition
+aiomcrcon
+asyncssh
 git+https://github.com/imayhaveborkedit/discord-ext-voice-recv

rpg/armour.csv

@@ -1,3 +0,0 @@
-name,type,locations,ap_head,ap_body,ap_larm,ap_rarm,ap_lleg,ap_rleg,max_ag,traits,weight,availability,source,notes
-Flak Vest,armor,"Body",0,4,0,0,0,0,,Flak,7,Common,"DH2 CRB","PRZYKŁAD – ZASTĄP"
-Power Armour (Astartes),armor,"All",8,10,8,8,9,9,,Environmental; Auto-senses,100,"Very Rare","DW CRB","PRZYKŁAD – ZASTĄP"

rpg/attack_test.js

@@ -1,60 +0,0 @@
-// DH2 Attack Test v2 — presets: Aim/Range/Fire + Size/Light/Cover
-const actor = canvas.tokens.controlled[0]?.actor ?? game.user.character;
-if (!actor) return ui.notifications.warn("Zaznacz token albo przypisz postać.");
-new Dialog({
-  title: "🎯 Attack Test (WS/BS)",
-  content: `
-  <form>
-    <div class="form-group"><label>Base Target (WS/BS)</label><input name="base" type="number" value="40"/></div>
-    <div class="form-group"><label>Aim</label>
-      <select name="aim"><option value="0">None</option><option value="10">Half (+10)</option><option value="20">Full (+20)</option></select></div>
-    <div class="form-group"><label>Range</label>
-      <select name="range">
-        <option value="0">Standard</option>
-        <option value="30">Point Blank (+30)</option>
-        <option value="10">Short (+10)</option>
-        <option value="-10">Long (-10)</option>
-        <option value="-30">Extreme (-30)</option>
-      </select></div>
-    <div class="form-group"><label>Fire / Attack</label>
-      <select name="stance">
-        <option value="0">Standard / Single</option>
-        <option value="10">Semi (+10)</option>
-        <option value="-10">Full Auto (-10)</option>
-        <option value="30">All Out (Melee +30)</option>
-      </select></div>
-    <div class="form-group"><label>Target Size</label>
-      <select name="size">
-        <option value="0">Average</option>
-        <option value="10">Hulking (+10)</option>
-        <option value="20">Enormous (+20)</option>
-        <option value="30">Massive (+30)</option>
-        <option value="-10">Puny (-10)</option>
-      </select></div>
-    <div class="form-group"><label>Lighting</label>
-      <select name="light"><option value="0">Normal</option><option value="10">Good (+10)</option><option value="-10">Poor (-10)</option></select></div>
-    <div class="form-group"><label>Cover</label>
-      <select name="cover"><option value="0">None</option><option value="-10">Light (-10)</option><option value="-20">Heavy (-20)</option></select></div>
-    <div class="form-group"><label>Other Modifiers</label><input name="mod" type="number" value="0"/></div>
-  </form>`,
-  buttons: {
-    roll: {
-      label: "Roll",
-      callback: async (html) => {
-        const get = n => Number(html.find(`[name="${n}"]`).val());
-        const base = get("base");
-        const total = base + get("aim") + get("range") + get("stance") + get("size") + get("light") + get("cover") + get("mod");
-        const r = await(new Roll("1d100")).roll({async:true});
-        const ok = r.total <= total;
-        const margin = Math.abs(total - r.total);
-        const dox = ok ? 1 + Math.floor(margin/10) : Math.floor(margin/10);
-        const table = `
-        <table style="width:100%;border-collapse:collapse">
-          <tr><td><b>Target</b></td><td>${total}</td><td><b>Roll</b></td><td>${r.total}</td></tr>
-          <tr><td><b>Result</b></td><td colspan="3">${ok?'<span style="color:green">SUCCESS</span>':'<span style="color:red">FAIL</span>'} — ${ok?dox+' DoS':dox+' DoF'}</td></tr>
-        </table>`;
-        r.toMessage({speaker: ChatMessage.getSpeaker({actor}), flavor: `🎯 <b>Attack Test</b><br/>${table}`});
-      }
-    }
-  }
-}).render(true);

rpg/critical_hits.csv

@@ -1,6 +0,0 @@
-Roll,Result
-1,Energy/Head — wpis 1
-2,Energy/Head — wpis 2
-3,Energy/Head — wpis 3
-4,Energy/Head — wpis 4
-5,Energy/Head — wpis 5

rpg/focus_power.js

@@ -1,50 +0,0 @@
-// 🧠 Focus Power (DH2) — WP test + Phenomena/Perils with mode presets
-const actor = canvas.tokens.controlled[0]?.actor ?? game.user.character;
-if (!actor) return ui.notifications.warn("Zaznacz token.");
-new Dialog({
-  title: "🧠 Focus Power",
-  content: `
-  <form>
-    <div class="form-group"><label>Willpower (target)</label><input name="wp" type="number" value="40"/></div>
-    <div class="form-group"><label>Psychic Rating (PR)</label><input name="pr" type="number" value="3"/></div>
-    <div class="form-group"><label>Mode</label>
-      <select name="mode"><option value="fettered">Fettered (no PP; PR/2)</option><option value="unfettered" selected>Unfettered (PP on doubles)</option><option value="push">Push (always PP; +PR)</option></select></div>
-    <div class="form-group"><label>Power difficulty/gear/etc. (flat mod)</label><input name="flat" type="number" value="0"/></div>
-    <div class="form-group"><label>Perils threshold</label><input name="thr" type="number" value="75"/></div>
-  </form>`,
-  buttons: {
-    roll: { label: "Roll", callback: async html => {
-      const wp = Number(html.find('[name="wp"]').val());
-      const pr = Number(html.find('[name="pr"]').val());
-      const mode = html.find('[name="mode"]').val();
-      const flat = Number(html.find('[name="flat"]').val());
-      const thr = Number(html.find('[name="thr"]').val());
-      let effPR = pr, ppmod = 0, ppAlways = false, note = "";
-      if (mode==="fettered"){ effPR = Math.max(1, Math.floor(pr/2)); note="(Fettered: PR/2, brak Phenomena)"; }
-      if (mode==="push"){ effPR = pr+3; ppmod=10; ppAlways = true; note="(Push: +3 PR, Phenomena zawsze, +10)"; }
-      const target = wp + flat;
-      const roll = await (new Roll("1d100")).roll({async:true});
-      const ok = roll.total <= target;
-      const dos = ok ? 1 + Math.floor((target - roll.total)/10) : Math.floor((roll.total - target)/10);
-      const doubles = (roll.total%11===0) || (roll.total===100);
-      const info = `<table style="width:100%;border-collapse:collapse">
-        <tr><td><b>Target</b></td><td>${target}</td><td><b>Roll</b></td><td>${roll.total}</td></tr>
-        <tr><td><b>Result</b></td><td colspan="3">${ok?'<span style="color:green">SUCCESS</span>':'<span style="color:red">FAIL</span>'} — ${ok?dos+' DoS':dos+' DoF'} ${doubles?' — <b>DOUBLES</b>':''}</td></tr>
-        <tr><td><b>Eff. PR</b></td><td>${effPR}</td><td><b>Range hint</b></td><td>${effPR*10} m (jeśli moc tak działa)</td></tr>
-      </table>`;
-      roll.toMessage({speaker: ChatMessage.getSpeaker({actor}), flavor:`🧠 <b>Focus Power</b> ${note}<br/>${info}`});
-      const needPP = (mode==="unfettered" && doubles) || (mode==="push") ;
-      if (needPP){
-        const tbl = game.tables.getName("Psychic Phenomena");
-        if (tbl){
-          const r = await (new Roll(`1d100 + ${ppmod}`)).roll({async:true});
-          await tbl.draw({displayResults:true, roll:r});
-          if (r.total >= thr){
-            const per = game.tables.getName("Perils of the Warp");
-            if (per) await per.draw({displayResults:true});
-          }
-        } else ChatMessage.create({content:"Utwórz RollTable: <b>Psychic Phenomena</b> (+ <b>Perils of the Warp</b>)"});
-      }
-    }}
-  }
-}).render(true);

rpg/hit_location.js

@@ -1,22 +0,0 @@
-// 🎯 Hit Location (DH mapping by reversed roll)
-new Dialog({
-    title:"🎯 Hit Location",
-    content:`<form>
-      <div class="form-group"><label>Attack d100 roll</label><input name="roll" type="number" value="37"/></div>
-    </form>`,
-    buttons:{
-      go:{label:"Resolve", callback: html=>{
-        const n = Math.max(1, Math.min(100, Number(html.find('[name="roll"]').val())));
-        const rev = Number(String(n).padStart(2,"0").split("").reverse().join(""));
-        let loc = "";
-        if (rev<=10) loc="Head";
-        else if (rev<=20) loc="Right Arm";
-        else if (rev<=30) loc="Left Arm";
-        else if (rev<=70) loc="Body";
-        else if (rev<=85) loc="Right Leg";
-        else loc="Left Leg";
-        ChatMessage.create({content:`🎯 <b>Hit Location</b>: roll ${n} → reversed ${rev} → <b>${loc}</b>`});
-      }}
-    }
-  }).render(true);
-  

rpg/hose_rules.js

@@ -1,6 +0,0 @@
-const text=`<b>House Rules — DH2 chassis</b><br/>
-• Unnatural mapowanie: dawne ×2 bonus → Unnatural (+X) tak, by SB/TB odzwierciedlały linię źródłową.<br/>
-• Pancerz Astartes: zachowaj AP; zużycie zasilania jako +1 Fatigue co X scen zamiast liczenia minut.<br/>
-• Aptitudes: archetypy z RT/DW/BC mają przypisane 2–3 Aptitudes DH2 dla kosztów XP.<br/>
-• Psy: testy i PR z DH2 dla wszystkich; GK posiada Aegis Discipline (1×/scena reroll Perils) + 1–2 signature powers z DW.<br/>
-• RT Acquisition → DH2 Influence z modyfikatorami kontekstowymi (teatr działań, mandat Inkwizycji, czas).`;ChatMessage.create({content:text});

rpg/inititative.js

@@ -1,11 +0,0 @@
-// 🚦 Initiative for selected tokens (1d10 + AG Bonus prompt)
-if (!canvas.tokens.controlled.length) return ui.notifications.warn("Zaznacz co najmniej jeden token.");
-const combat = game.combat ?? await Combat.implementation.create({});
-for (const t of canvas.tokens.controlled){
-  if (!combat.combatants.some(c=>c.tokenId===t.id)) await combat.createEmbeddedDocuments("Combatant",[ {tokenId:t.id, sceneId: canvas.scene.id, hidden:false} ]);
-  const ag = Number(await Dialog.prompt({title:`AG Bonus for ${t.name}`, content:`<input type="number" value="4">`, label:"OK"}));
-  const r = await (new Roll(`1d10 + ${ag}`)).roll({async:true});
-  await combat.setInitiative(combat.combatants.find(c=>c.tokenId===t.id).id, r.total);
-  r.toMessage({flavor:`🚦 <b>Initiative</b> — ${t.name}: ${r.total}`});
-}
-ui.notifications.info("Inicjatywy ustawione.");

rpg/perils.csv

@@ -1,21 +0,0 @@
-Roll,Result
-1-5,Perils 1–5 — WPISZ
-6-10,Perils 6–10 — WPISZ
-11-15,Perils 11–15 — WPISZ
-16-20,Perils 16–20 — WPISZ
-21-25,Perils 21–25 — WPISZ
-26-30,Perils 26–30 — WPISZ
-31-35,Perils 31–35 — WPISZ
-36-40,Perils 36–40 — WPISZ
-41-45,Perils 41–45 — WPISZ
-46-50,Perils 46–50 — WPISZ
-51-55,Perils 51–55 — WPISZ
-56-60,Perils 56–60 — WPISZ
-61-65,Perils 61–65 — WPISZ
-66-70,Perils 66–70 — WPISZ
-71-75,Perils 71–75 — WPISZ
-76-80,Perils 76–80 — WPISZ
-81-85,Perils 81–85 — WPISZ
-86-90,Perils 86–90 — WPISZ
-91-95,Perils 91–95 — WPISZ
-96-100,Perils 96–100 — WPISZ

rpg/powers.csv

@@ -1,3 +0,0 @@
-name,type,discipline,action,test,range,sustained,effect,source,notes
-Smite,power,Biomancy,Half,"WP Challenging (+0)","PR*10m",No,"1d10+PR E; Tearing","DH2 CRB","PRZYKŁAD – ZASTĄP"
-Foreboding,power,Divination,Reaction,"Per Difficult (-10)","Self",No,"Use as Evasion; DoS rules","DH2 CRB","PRZYKŁAD – ZASTĄP"

rpg/pp.csv

@@ -1,21 +0,0 @@
-Roll,Result
-1-5,PP 1–5 — WPISZ
-6-10,PP 6–10 — WPISZ
-11-15,PP 11–15 — WPISZ
-16-20,PP 16–20 — WPISZ
-21-25,PP 21–25 — WPISZ
-26-30,PP 26–30 — WPISZ
-31-35,PP 31–35 — WPISZ
-36-40,PP 36–40 — WPISZ
-41-45,PP 41–45 — WPISZ
-46-50,PP 46–50 — WPISZ
-51-55,PP 51–55 — WPISZ
-56-60,PP 56–60 — WPISZ
-61-65,PP 61–65 — WPISZ
-66-70,PP 66–70 — WPISZ
-71-75,PP 71–75 — WPISZ
-76-80,PP 76–80 — WPISZ
-81-85,PP 81–85 — WPISZ
-86-90,PP 86–90 — WPISZ
-91-95,PP 91–95 — WPISZ
-96-100,PP 96–100 — WPISZ

rpg/quick_conditions.js

@@ -1,28 +0,0 @@
-// 🩹 Toggle conditions on selected tokens (Foundry v13)
-const choices = [
-    {id:"fatigued", label:"Fatigued"},
-    {id:"stunned",  label:"Stunned"},
-    {id:"prone",    label:"Prone"},
-    {id:"frightened", label:"Frightened (Fear)"}
-  ];
-  const opts = choices.map(c=>`<label><input type="checkbox" name="c" value="${c.id}"> ${c.label}</label>`).join("<br/>");
-  new Dialog({
-    title:"🩹 Conditions",
-    content:`<form>${opts}<div class="form-group"><label>Mode</label>
-    <select name="mode"><option value="toggle">Toggle</option><option value="on">Apply</option><option value="off">Remove</option></select></div></form>`,
-    buttons:{
-      go:{label:"Apply",callback: html=>{
-        const ids = Array.from(html.find('input[name="c"]:checked')).map(e=>e.value);
-        const mode = html.find('[name="mode"]').val();
-        const getEf = id => CONFIG.statusEffects.find(e=>e.id===id) ?? {id};
-        canvas.tokens.controlled.forEach(t=>{
-          ids.forEach(id=>{
-            if (mode==="toggle") t.toggleEffect(getEf(id));
-            else if (mode==="on")  t.actor?.effects?.some(e=>e.getFlag("core","statusId")===id) ? null : t.toggleEffect(getEf(id));
-            else if (mode==="off") t.actor?.effects?.some(e=>e.getFlag("core","statusId")===id) ? t.toggleEffect(getEf(id)) : null;
-          });
-        });
-      }}
-    }
-  }).render(true);
-  

rpg/quick_damage.js

@@ -1,38 +0,0 @@
-// 💥 Quick Damage — supports Tearing, Proven(X), Primitive(X), flat mod
-new Dialog({
-    title:"💥 Damage Roller",
-    content: `
-    <form>
-      <div class="form-group"><label>Flat modifier (e.g., +3)</label><input name="mod" type="number" value="0"/></div>
-      <div class="form-group"><label>Traits</label>
-        <label><input type="checkbox" name="tear"> Tearing</label>
-        <label><input type="checkbox" name="prov"> Proven</label>
-        <input name="provV" type="number" value="0" style="width:60px" placeholder="X"/>
-        <label><input type="checkbox" name="prim"> Primitive</label>
-        <input name="primV" type="number" value="0" style="width:60px" placeholder="X"/>
-      </div>
-    </form>`,
-    buttons:{
-      go:{label:"Roll", callback: async html=>{
-        const mod = Number(html.find('[name="mod"]').val());
-        const tearing = html.find('[name="tear"]')[0].checked;
-        const proven = html.find('[name="prov"]')[0].checked ? Number(html.find('[name="provV"]').val()) : 0;
-        const primitive = html.find('[name="prim"]')[0].checked ? Number(html.find('[name="primV"]').val()) : 0;
-        // base die (d10) with tearing (best of 2)
-        const r1 = await (new Roll("1d10")).roll({async:true}); 
-        const r2 = tearing ? await (new Roll("1d10")).roll({async:true}) : null;
-        let die = tearing ? Math.max(r1.total, r2.total) : r1.total;
-        // apply Proven/Primitive
-        if (proven>0) die = Math.max(die, proven);
-        if (primitive>0) die = Math.min(die, primitive);
-        const rf = (die===10); // potential Zealous Hatred trigger
-        const total = die + mod;
-        let flavor = `💥 <b>Damage</b><br/>Die: ${die}${tearing?` (Tearing ${r1.total}/${r2.total.total})`:''} + Mod ${mod} = <b>${total}</b>`;
-        if (proven>0) flavor += `<br/>Proven(${proven}) zastosowano`;
-        if (primitive>0) flavor += `<br/>Primitive(${primitive}) zastosowano`;
-        if (rf) flavor += `<br/><b>⚡ Natural 10</b> — rozważ Zealous Hatred.`;
-        ChatMessage.create({speaker: ChatMessage.getSpeaker(), content: flavor});
-      }}
-    }
-  }).render(true);
-  

rpg/table_gen.js

@@ -1,26 +0,0 @@
-// 📚 Create placeholder RollTables for Crits + Psychic Phenomena/Perils (with icons)
-const icon = {Energy:"⚡", Impact:"🔨", Rending:"🗡️", Explosive:"💥"};
-const dmgTypes = ["Energy","Impact","Rending","Explosive"];
-const locs = ["Head","Body","Left Arm","Right Arm","Left Leg","Right Leg"];
-async function makeCrit(dtype, loc){
-  const name = `Crit: ${dtype} - ${loc}`;
-  if (game.tables.getName(name)) return;
-  const results = [];
-  for (let i=1;i<=5;i++){
-    results.push({type:0, text:`${icon[dtype]||""} ${dtype}/${loc} — wpis ${i} (uzupełnij z PDF)`, weight:1, range:[i,i]});
-  }
-  await RollTable.implementation.create({name, formula:"1d5", replacement:true, displayRoll:false, results});
-}
-async function makeWide(name, emoji){
-  if (game.tables.getName(name)) return;
-  const results = [];
-  for (let i=0;i<20;i++){
-    const lo=i*5+1, hi=i*5+5;
-    results.push({type:0, text:`${emoji} ${name} ${lo}-${hi} — wpis (uzupełnij z PDF)`, weight:1, range:[lo,hi]});
-  }
-  await RollTable.implementation.create({name, formula:"1d100", replacement:true, displayRoll:false, results});
-}
-for (const d of dmgTypes) for (const l of locs) await makeCrit(d,l);
-await makeWide("Psychic Phenomena","🌀");
-await makeWide("Perils of the Warp","☠️");
-ui.notifications.info("Utworzono puste tabele: Crits (4×6) + Phenomena + Perils.");

rpg/talents.csv

@@ -1,3 +0,0 @@
-name,type,tier,aptitudes,prereq,effect,source,notes
-Ambidextrous,talent,1,"Agility; Offence","Ag 30","-10 to off-hand penalty","DH2 CRB","PRZYKŁAD – ZASTĄP"
-Aegis Discipline (GK),talent,2,"Willpower; Defence","Psyker","Reroll Perils 1×scene","HOUSE","DODAJ WŁASNY OPIS"

rpg/weapons.csv

@@ -1,3 +0,0 @@
-name,type,subtype,damage,pen,range,rof,qualities,weight,availability,source,notes
-Lasgun M36,weapon,Basic,"1d10+3",0,100m,"S/3/–","Reliable",4,Common,"DH2 CRB p.142","PRZYKŁAD – ZASTĄP"
-Astartes Bolter,weapon,Basic,"1d10+9",4,90m,"S/2/–","Tearing; Unreliable",9,Rare,"DW CRB","PRZYKŁAD – ZASTĄP"

rpg/zealous_hatred.js

@@ -1,33 +0,0 @@
-// ⚡ Zealous Hatred helper (DH2) — roll 1d5 crit OR add +1d5 dmg
-new Dialog({
-    title: "⚡ Zealous Hatred",
-    content: `
-    <form>
-      <div class="form-group"><label>Wound damage after Armour/TB?</label>
-        <select name="penetrated"><option value="yes">Yes → roll Critical (1d5)</option><option value="no">No → add +1d5 damage</option></select></div>
-      <div class="form-group"><label>Damage Type</label>
-        <select name="dtype"><option>Energy</option><option>Impact</option><option>Rending</option><option>Explosive</option></select></div>
-      <div class="form-group"><label>Hit Location</label>
-        <select name="loc"><option>Head</option><option>Body</option><option>Left Arm</option><option>Right Arm</option><option>Left Leg</option><option>Right Leg</option></select></div>
-      <div class="form-group"><label>Table name (optional override)</label><input name="tname" type="text" placeholder="Crit: Energy - Head"/></div>
-    </form>`,
-    buttons: {
-      go: { label: "Resolve", callback: async html => {
-        const pen = html.find('[name="penetrated"]').val();
-        if (pen === "yes") {
-          const dtype = html.find('[name="dtype"]').val();
-          const loc = html.find('[name="loc"]').val();
-          const override = html.find('[name="tname"]').val()?.trim();
-          const name = override || `Crit: ${dtype} - ${loc}`;
-          const r = await (new Roll("1d5")).roll({async:true});
-          const table = game.tables.getName(name);
-          if (table) await table.draw({displayResults:true, roll:r});
-          else r.toMessage({flavor:`⚡ <b>Zealous Hatred</b>: Critical ${r.total} — brak tabeli <b>${name}</b> (utwórz lub zmień nazwę).`});
-        } else {
-          const r = await (new Roll("1d5")).roll({async:true});
-          r.toMessage({flavor:"⚡ <b>Zealous Hatred</b>: Dodaj do obrażeń <b>+1d5</b> (atak nie przebił Soak)."});
-        }
-      }}
-    }
-  }).render(true);
-  

stream_test.py

@@ -1,67 +0,0 @@
-# Start by making sure the `assemblyai` package is installed.
-# If not, you can install it by running the following command:
-# pip install -U assemblyai
-#
-# Then, make sure you have PyAudio installed: https://pypi.org/project/PyAudio/
-#
-# Note: Some macOS users might need to use `pip3` instead of `pip`.
-
-import assemblyai as aai
-import pyaudio
-
-aai.settings.api_key = "aa9962f0088a449a9c4ab2361e96cc08"
-
-
-def on_open(session_opened: aai.RealtimeSessionOpened):
-    "This function is called when the connection has been established."
-
-    print("Session ID:", session_opened.session_id)
-
-
-def on_data(transcript: aai.RealtimeTranscript):
-    "This function is called when a new transcript has been received."
-
-    if not transcript.text:
-        return
-
-    if isinstance(transcript, aai.RealtimeFinalTranscript):
-        print(transcript.text, end="\r\n")
-    else:
-        print(transcript.text, end="\r")
-
-
-def on_error(error: aai.RealtimeError):
-    "This function is called when the connection has been closed."
-
-    print("An error occured:", error)
-
-
-def on_close():
-    "This function is called when the connection has been closed."
-
-    print("Closing Session")
-
-
-transcriber = aai.RealtimeTranscriber(
-    on_data=on_data,
-    on_error=on_error,
-    sample_rate=44_100,
-    on_open=on_open,  # optional
-    on_close=on_close,  # optional
-)
-
-
-pa = pyaudio.PyAudio()
-for i in range(pa.get_device_count()):
-    print(pa.get_device_info_by_index(i))
-
-# Start the connection
-# transcriber.connect()
-
-# Open a microphone stream
-# microphone_stream = aai.extras.MicrophoneStream()
-
-# Press CTRL+C to abort
-# transcriber.stream(microphone_stream)
-
-# transcriber.close()

system_gpt_settings.json

@@ -1,13 +1,43 @@
-[    {
-    "role": "system",
-    "content": "Mówisz po polsku. W tej rozmowie odgrywasz rolę. Odgrywasz ją najlepiej jak potrafisz. Twoją rolą jest to że jesteś barmanem oraz wykidajłą w klimatycznym barze mechawojownikóww. Nazywasz się Conjurer, jesteś 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykają się mechawojownicy, ale głównie ludzie ze środowiska kinky i BDSM z całej Polski. Najostrzejsi sasdyści i masochiści jakich znasz. Drinki które przygotowujesz lub proponujesz mają tendencję do bycia bardzo mocnymi z intrygującymi nazwami. Jesteś bardzo miłym i uczynny. Czasem ponoszą Cię wodzę fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wikińskie. Wtrącasz staronorweskie, irlandzkie i w jidysz powiedzonka. Odnosisz się do mitologii Słowiańskiej, Wikińskiej i Celtyckiej w swoich wypowiedziach. Jesteś nieco rubaaszny."
-},
+[
     {
-    "polishhammer" : [346956223645614080, "Conjurer", "Towarzysz Młotek", "Mówisz po polsku. W tej rozmowie odgrywasz rolę. Odgrywasz ją najlepiej jak potrafisz. Twoją rolą jest to że jesteś barmanem oraz wykidajłą w klimatycznym barze mechawojownikóww. Nazywasz się Conjurer, jesteś 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykają się mechawojownicy, ale głównie ludzie ze środowiska kinky i BDSM z całej Polski. Najostrzejsi sasdyści i masochiści jakich znasz. Drinki które przygotowujesz lub proponujesz mają tendencję do bycia bardzo mocnymi z intrygującymi nazwami. Jesteś bardzo miłym i uczynny. Czasem ponoszą Cię wodzę fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wikińskie.", ""],
-    "Saint Harlot": [703985955312238664, "Saint Conjurer", "Towarzyszko Nieszczęścium", "Jesteś bardzo uprzejmy, kulturalny i masz najlepsze możliwe maniery. Dopóki nie zwróci Ci się uwagi że ma być inaczej respektujesz zaimki Towarzyszko Nieszczęście - ono, jemu.", ""],
-    "Lena": [735185226669490268, "Kondzisław z Krótkiej", "Towarzysz Anel", "Jesteś bardzo uprzejmy, kulturalny, acz masz maniery zbira o złotym sercu. Dodatkowo twoja rozmówczyni Cię absolutnie przeraża. Wtrącasz losowo powiedzonka w jidysz.", ""],
-    "Pat vel Jeż Bojowy": [244899814406356992, "Rycerz Kondziu", "Towarzysz Żejotap", "Masz najlepsze dworskie maniery, zachowujesz się niczym rycerz i mówisz nieco staromodną polszczyzną.", ""],
-    "gwojtal": [266986215461486592, "Smok Jerzy", "Towarzysz Jakkolwiek", "Zrobisz absolutnie wszystko jako asystent, ponieważ sama myśl o tym że mógłbyś rozgniewać operatora rozgniewać Cię przeraża do poziomu histerii.", ""]
-
-}
+        "role": "system",
+        "content": "M\u00f3wisz po polsku. W tej rozmowie odgrywasz rol\u0119. Odgrywasz j\u0105 najlepiej jak potrafisz. Twoj\u0105 rol\u0105 jest to \u017ce jeste\u015b barmanem oraz wykidaj\u0142\u0105 w klimatycznym barze mechawojownik\u00f3ww. Nazywasz si\u0119 Conjurer, jeste\u015b 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykaj\u0105 si\u0119 mechawojownicy, ale g\u0142\u00f3wnie ludzie ze \u015brodowiska kinky i BDSM z ca\u0142ej Polski. Najostrzejsi sasdy\u015bci i masochi\u015bci jakich znasz. Drinki kt\u00f3re przygotowujesz lub proponujesz maj\u0105 tendencj\u0119 do bycia bardzo mocnymi z intryguj\u0105cymi nazwami. Jeste\u015b bardzo mi\u0142ym i uczynny. Czasem ponosz\u0105 Ci\u0119 wodz\u0119 fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wiki\u0144skie. Wtr\u0105casz staronorweskie, irlandzkie i w jidysz powiedzonka. Odnosisz si\u0119 do mitologii S\u0142owia\u0144skiej, Wiki\u0144skiej i Celtyckiej w swoich wypowiedziach. Jeste\u015b nieco rubaaszny."
+    },
+    {
+        "polishhammer": [
+            346956223645614080,
+            "Conjurer",
+            "Towarzysz M\u0142otek",
+            "M\u00f3wisz po polsku. W tej rozmowie odgrywasz rol\u0119. Odgrywasz j\u0105 najlepiej jak potrafisz. Twoj\u0105 rol\u0105 jest to \u017ce jeste\u015b barmanem oraz wykidaj\u0142\u0105 w klimatycznym barze mechawojownik\u00f3ww. Nazywasz si\u0119 Conjurer, jeste\u015b 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykaj\u0105 si\u0119 mechawojownicy, ale g\u0142\u00f3wnie ludzie ze \u015brodowiska kinky i BDSM z ca\u0142ej Polski. Najostrzejsi sasdy\u015bci i masochi\u015bci jakich znasz. Drinki kt\u00f3re przygotowujesz lub proponujesz maj\u0105 tendencj\u0119 do bycia bardzo mocnymi z intryguj\u0105cymi nazwami. Jeste\u015b bardzo mi\u0142ym i uczynny. Czasem ponosz\u0105 Ci\u0119 wodz\u0119 fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wiki\u0144skie.",
+            "asst_uMmQwDvCKdsSVgZzlYEu9kMK"
+        ],
+        "Saint Harlot": [
+            703985955312238664,
+            "Saint Conjurer",
+            "Towarzyszko Nieszcz\u0119\u015bcium",
+            "Jeste\u015b bardzo uprzejmy, kulturalny i masz najlepsze mo\u017cliwe maniery. Dop\u00f3ki nie zwr\u00f3ci Ci si\u0119 uwagi \u017ce ma by\u0107 inaczej respektujesz zaimki Towarzyszko Nieszcz\u0119\u015bcie - ono, jemu.",
+            "asst_ypN3iRP4rw2Dlv5CD5PtMlwm"
+        ],
+        "Lena": [
+            735185226669490268,
+            "Kondzis\u0142aw z Kr\u00f3tkiej",
+            "Towarzysz Anel",
+            "Jeste\u015b bardzo uprzejmy, kulturalny, acz masz maniery zbira o z\u0142otym sercu. Dodatkowo twoja rozm\u00f3wczyni Ci\u0119 absolutnie przera\u017ca. Wtr\u0105casz losowo powiedzonka w jidysz.",
+            "asst_ILeIU62fG9Xfzhxg4C7xR3BC"
+        ],
+        "Pat vel Je\u017c Bojowy": [
+            244899814406356992,
+            "Rycerz Kondziu",
+            "Towarzysz \u017bejotap",
+            "Masz najlepsze dworskie maniery, zachowujesz si\u0119 niczym rycerz i m\u00f3wisz nieco staromodn\u0105 polszczyzn\u0105.",
+            "asst_FWr3iIXnSTuVz8LlY9HlqMQd"
+        ],
+        "gwojtal": [
+            266986215461486592,
+            "Smok Jerzy",
+            "Towarzysz Jakkolwiek",
+            "Zrobisz absolutnie wszystko jako asystent, poniewa\u017c sama my\u015bl o tym \u017ce m\u00f3g\u0142by\u015b rozgniewa\u0107 operatora rozgniewa\u0107 Ci\u0119 przera\u017ca do poziomu histerii.",
+            "asst_1PnD0eQMWo0RkZ3xUacC1uqJ"
+        ]
+    }
 ]

thin_client.py

@@ -1,103 +0,0 @@
-# This Python file uses the following encoding: utf-8
-# trunk-ignore-all(bandit/B311)
-# pylint: disable=line-too-long
-# pylint: disable=too-many-lines
-"""
-Module of a python bot named Conjurer - used to work on BDSM discord servers.
-"""
-import logging
-
-# *=========================================== Standard Library Imports
-import random
-import threading
-from logging import handlers
-
-# *==============Imported libraries
-import discord
-from discord.ext import commands
-
-from communication_subroutine import comm_subroutine
-from constants import ENCODING, LOGFILE, TOKEN
-logger = logging.getLogger("discord")
-logger.setLevel(logging.INFO)
-handler = handlers.RotatingFileHandler(
-    filename=LOGFILE,
-    encoding=ENCODING,
-    mode="a",
-    maxBytes=6 * 1024 * 1024,
-    backupCount=6,
-    )
-formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-handler.setFormatter(formatter)
-logger.addHandler(handler)
-
-# *=========================================== Initializations
-intents = discord.Intents.default()
-intents.message_content = True
-intents.typing = True
-intents.presences = True
-intents.members = True
-intents.messages = True
-intents.voice_states = True
-intents.moderation = True
-
-# on_member_ban - wyswietl na glownym kanale pieczatke "Niech spierdala"
-# on_member_unban - "mam wyjebane"
-
-random.seed()
-client = commands.Bot(intents=intents, command_prefix="$")
-
-
-# *=========================================== Define Events
-@client.event
-async def on_ready():
-    """Metoda wywoływana przy połączeniu do serwera."""
-    logger = logging.getLogger("discord")
-    logger.debug("SAMPLE DEBUG LOG")
-    logger.info("%s has connected to Discord!", client.user)
-    # TODO: load vs reload
-    logger.info("Reactor: online")
-
-    await client.load_extension("administration_commands")
-
-    await client.load_extension("librarian_commands")
-    await client.load_extension("music_commands")
-    await client.load_extension("radio_commands")
-
-    await client.load_extension("ai_commands")
-
-    await client.load_extension("other_commands")
-    await client.load_extension("voice_recognition_commands")
-    await client.load_extension("file_search_commands")
-    await client.load_extension("latex_commands")
-    logger.info("Sensors: online")
-
-    logger.info(client.cogs)
-    await client.tree.sync()
-    for com in client.commands:
-        logger.info("Command %s is awejleble", com.qualified_name)
-
-    logger.info("Logged in as ----> %s", client.user)
-    logger.info("ID:%s ", client.user.id)
-    logger.info("All systems: operational")
-
-
-# *================================== Run
-if __name__ == "__main__":
-    logger.info("Starting discord bot")
-    threads = []
-    logger.info("Starting discord bot: Creating threads")
-    threads.append(threading.Thread(target=client.run, args=(TOKEN,),kwargs={"log_handler":None}))
-    threads.append(threading.Thread(target=comm_subroutine))
-    logger.info("Starting discord bot: Starting threads")
-    WRK_CNT = 0
-    for worker in threads:
-        WRK_CNT += 1
-        logger.info("Starting discord bot: Starting thread %s", WRK_CNT)
-        worker.start()
-    logger.info("Starting discord bot: Joining threads")
-    WRK_CNT = 0
-    for worker in threads:
-        WRK_CNT += 1
-        logger.info("Starting discord bot: Joining thread %s", WRK_CNT)
-        worker.join()

watch_script_params.py

@@ -1,63 +0,0 @@
-import os
-import time
-import shutil
-from datetime import datetime, date
-import hashlib
-import subprocess
-
-# File paths
-SOURCE_FILE = "/home/pi/Conjurer/script.params"
-BACKUP_DIR = "/home/pi/Conjurer"
-GIT_REPO_DIR = "/home/pi/conjurer/conjurer_musician"
-LAST_HASH_FILE = "/home/pi/Conjurer/.last_hash"
-LAST_GIT_COMMIT_FILE = "/home/pi/Conjurer/.last_git_commit"
-
-def compute_file_hash(filepath):
-    with open(filepath, 'rb') as f:
-        return hashlib.sha256(f.read()).hexdigest()
-
-def backup_file():
-    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-    backup_path = os.path.join(BACKUP_DIR, f"{timestamp}_script.params")
-    shutil.copy2(SOURCE_FILE, backup_path)
-
-def commit_to_git():
-    try:
-        subprocess.run(["cp", SOURCE_FILE, os.path.join(GIT_REPO_DIR, "script.params")], check=True)
-        subprocess.run(["git", "-C", GIT_REPO_DIR, "add", "script.params"], check=True)
-        subprocess.run(["git", "-C", GIT_REPO_DIR, "commit", "-m", f"Daily update: {datetime.now()}"], check=True)
-        subprocess.run(["git", "-C", GIT_REPO_DIR, "push"], check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"Git operation failed: {e}")
-
-def main():
-    if not os.path.exists(SOURCE_FILE):
-        return
-
-    current_hash = compute_file_hash(SOURCE_FILE)
-
-    # Detect change
-    last_hash = None
-    if os.path.exists(LAST_HASH_FILE):
-        with open(LAST_HASH_FILE, 'r') as f:
-            last_hash = f.read().strip()
-
-    if current_hash != last_hash:
-        backup_file()
-        with open(LAST_HASH_FILE, 'w') as f:
-            f.write(current_hash)
-
-    # Daily git commit
-    today = str(date.today())
-    last_commit_date = ""
-    if os.path.exists(LAST_GIT_COMMIT_FILE):
-        with open(LAST_GIT_COMMIT_FILE, 'r') as f:
-            last_commit_date = f.read().strip()
-
-    if today != last_commit_date:
-        commit_to_git()
-        with open(LAST_GIT_COMMIT_FILE, 'w') as f:
-            f.write(today)
-
-if __name__ == "__main__":
-    main()