From 59b08cffa468f99c4dd016f4992eb97f6467fbf2 Mon Sep 17 00:00:00 2001
From: Sergey Ivanov <delta_001@bk.ru>
Date: Wed, 19 Nov 2025 10:41:38 +0500
Subject: [PATCH 1/3] Refactor scripting handling and add portainer pipeline

---
 .github/workflows/portainer-deploy.yml        |  89 +++++++++++
 README.md                                     |  10 ++
 .../holyway/botplatform/scripting/Script.java |   7 +-
 .../scripting/ScriptCompilationException.java |  22 +++
 .../scripting/ScriptCompilerImpl.java         |   9 +-
 .../scripting/ScriptContextFactory.java       |  27 ++++
 .../botplatform/scripting/ScriptRegistry.java |  59 ++++++++
 .../processor/ScriptMessageProcessor.java     | 140 ++++++++----------
 .../scripting/ScriptCompilerImplTest.java     |  40 +++++
 .../scripting/ScriptRegistryTest.java         |  56 +++++++
 10 files changed, 374 insertions(+), 85 deletions(-)
 create mode 100644 .github/workflows/portainer-deploy.yml
 create mode 100644 src/main/java/ru/holyway/botplatform/scripting/ScriptCompilationException.java
 create mode 100644 src/main/java/ru/holyway/botplatform/scripting/ScriptContextFactory.java
 create mode 100644 src/main/java/ru/holyway/botplatform/scripting/ScriptRegistry.java
 create mode 100644 src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
 create mode 100644 src/test/java/ru/holyway/botplatform/scripting/ScriptRegistryTest.java

diff --git a/.github/workflows/portainer-deploy.yml b/.github/workflows/portainer-deploy.yml
new file mode 100644
index 0000000..0886ca8
--- /dev/null
+++ b/.github/workflows/portainer-deploy.yml
@@ -0,0 +1,89 @@
+name: Build and Deploy to Portainer
+
+on:
+  push:
+    branches:
+      - main
+      - master
+  workflow_dispatch: {}
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+  TAG: latest
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+          cache: maven
+
+      - name: Build application
+        run: ./mvnw -B package -DskipTests
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ env.TAG }}
+
+      - name: Deploy stack via Portainer API
+        env:
+          PORTAINER_URL: ${{ secrets.PORTAINER_URL }}
+          PORTAINER_USERNAME: ${{ secrets.PORTAINER_USERNAME }}
+          PORTAINER_PASSWORD: ${{ secrets.PORTAINER_PASSWORD }}
+          PORTAINER_STACK_ID: ${{ secrets.PORTAINER_STACK_ID }}
+        run: |
+          python - <<'PY'
+          import json
+          import os
+          import sys
+          from urllib import request
+
+          url = os.environ.get("PORTAINER_URL")
+          username = os.environ.get("PORTAINER_USERNAME")
+          password = os.environ.get("PORTAINER_PASSWORD")
+          stack_id = os.environ.get("PORTAINER_STACK_ID")
+
+          if not all([url, username, password, stack_id]):
+              sys.exit("Portainer secrets are not configured")
+
+          data = json.dumps({"Username": username, "Password": password}).encode()
+          req = request.Request(f"{url}/api/auth", data=data, headers={"Content-Type": "application/json"})
+          with request.urlopen(req) as resp:
+              token = json.loads(resp.read().decode()).get("jwt")
+
+          if not token:
+              sys.exit("Failed to obtain Portainer JWT token")
+
+          deploy_request = request.Request(
+              f"{url}/api/stacks/{stack_id}/deploy",
+              data=json.dumps({"prune": True, "pullImage": True}).encode(),
+              headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
+              method="POST",
+          )
+
+          with request.urlopen(deploy_request) as resp:
+              print(f"Deploy response status: {resp.status}")
+              print(resp.read().decode())
+          PY
diff --git a/README.md b/README.md
index c980c2f..6dd340a 100644
--- a/README.md
+++ b/README.md
@@ -12,3 +12,13 @@ For example you can write script to remove all messages with word `F*ck` in the
 * Some another minor features like random meme generation and notifying all participants in the chat by @all.
 
 I didn't try to write beautiful code so... it looks like a shit :)
+
+## CI/CD
+
+The repository now contains the workflow `.github/workflows/portainer-deploy.yml` that builds the
+application, publishes an image to GitHub Container Registry and triggers a Portainer stack
+redeploy. Configure the following secrets before enabling the workflow:
+
+- `PORTAINER_URL` – base URL of the Portainer instance (for example `https://portainer.example.com`).
+- `PORTAINER_USERNAME` / `PORTAINER_PASSWORD` – credentials with rights to deploy the target stack.
+- `PORTAINER_STACK_ID` – identifier of the stack to redeploy.
diff --git a/src/main/java/ru/holyway/botplatform/scripting/Script.java b/src/main/java/ru/holyway/botplatform/scripting/Script.java
index 40c46cd..eff5651 100644
--- a/src/main/java/ru/holyway/botplatform/scripting/Script.java
+++ b/src/main/java/ru/holyway/botplatform/scripting/Script.java
@@ -1,5 +1,6 @@
 package ru.holyway.botplatform.scripting;
 
+import lombok.extern.slf4j.Slf4j;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Objects;
@@ -9,6 +10,7 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+@Slf4j
 public class Script implements Comparable<Script> {
 
   private final String name;
@@ -40,10 +42,9 @@ public static Predicate<ScriptContext> any() {
   public static Consumer<ScriptContext> sout(Object obj) {
     return scriptContext -> {
       if (obj instanceof Function) {
-        System.out
-            .println(((Function<ScriptContext, String>) obj).apply(scriptContext));
+        log.info(((Function<ScriptContext, String>) obj).apply(scriptContext));
       } else {
-        System.out.println(String.valueOf(obj));
+        log.info(String.valueOf(obj));
       }
     };
   }
diff --git a/src/main/java/ru/holyway/botplatform/scripting/ScriptCompilationException.java b/src/main/java/ru/holyway/botplatform/scripting/ScriptCompilationException.java
new file mode 100644
index 0000000..9cb4389
--- /dev/null
+++ b/src/main/java/ru/holyway/botplatform/scripting/ScriptCompilationException.java
@@ -0,0 +1,22 @@
+package ru.holyway.botplatform.scripting;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Wraps compilation failures with additional context about the script text.
+ */
+public class ScriptCompilationException extends RuntimeException {
+
+  private final String scriptText;
+
+  public ScriptCompilationException(@Nonnull String message, @Nonnull String scriptText,
+                                    @Nonnull Throwable cause) {
+    super(message, cause);
+    this.scriptText = scriptText;
+  }
+
+  @Nonnull
+  public String getScriptText() {
+    return scriptText;
+  }
+}
diff --git a/src/main/java/ru/holyway/botplatform/scripting/ScriptCompilerImpl.java b/src/main/java/ru/holyway/botplatform/scripting/ScriptCompilerImpl.java
index cd2497a..cc348a2 100644
--- a/src/main/java/ru/holyway/botplatform/scripting/ScriptCompilerImpl.java
+++ b/src/main/java/ru/holyway/botplatform/scripting/ScriptCompilerImpl.java
@@ -2,10 +2,12 @@
 
 import groovy.lang.GroovyShell;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 
 import javax.annotation.Nonnull;
 
 @RequiredArgsConstructor
+@Slf4j
 public class ScriptCompilerImpl implements ScriptCompiler {
 
   @Nonnull
@@ -14,6 +16,11 @@ public class ScriptCompilerImpl implements ScriptCompiler {
   @Nonnull
   @Override
   public Script compile(@Nonnull String scriptText) {
-    return (Script) groovyShell.parse("return " + scriptText).run();
+    try {
+      return (Script) groovyShell.parse("return " + scriptText).run();
+    } catch (Exception ex) {
+      log.error("Failed to compile script: {}", scriptText, ex);
+      throw new ScriptCompilationException("Unable to compile script", scriptText, ex);
+    }
   }
 }
diff --git a/src/main/java/ru/holyway/botplatform/scripting/ScriptContextFactory.java b/src/main/java/ru/holyway/botplatform/scripting/ScriptContextFactory.java
new file mode 100644
index 0000000..f2f09d9
--- /dev/null
+++ b/src/main/java/ru/holyway/botplatform/scripting/ScriptContextFactory.java
@@ -0,0 +1,27 @@
+package ru.holyway.botplatform.scripting;
+
+import org.telegram.telegrambots.meta.bots.AbsSender;
+import ru.holyway.botplatform.scripting.entity.MessageScriptEntity;
+import ru.holyway.botplatform.scripting.entity.StaticMessage;
+import ru.holyway.botplatform.telegram.TelegramMessageEntity;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Factory that encapsulates script context creation for different entry points
+ * (inline execution or scheduled trigger).
+ */
+public class ScriptContextFactory {
+
+  @Nonnull
+  public ScriptContext create(@Nonnull TelegramMessageEntity messageEntity, @Nonnull Script script) {
+    MessageScriptEntity message = new MessageScriptEntity(messageEntity);
+    TelegramScriptEntity telegram = new TelegramScriptEntity();
+    return new ScriptContext(message, telegram, script);
+  }
+
+  @Nonnull
+  public ScriptContext create(@Nonnull String chat, @Nonnull AbsSender sender, @Nonnull Script script) {
+    return create(new TelegramMessageEntity(new StaticMessage(chat), null, sender), script);
+  }
+}
diff --git a/src/main/java/ru/holyway/botplatform/scripting/ScriptRegistry.java b/src/main/java/ru/holyway/botplatform/scripting/ScriptRegistry.java
new file mode 100644
index 0000000..907db81
--- /dev/null
+++ b/src/main/java/ru/holyway/botplatform/scripting/ScriptRegistry.java
@@ -0,0 +1,59 @@
+package ru.holyway.botplatform.scripting;
+
+import javax.annotation.Nonnull;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
+
+/**
+ * Central repository for all runtime scripts. Manages sorting and lookup logic in a single place
+ * to avoid duplication inside processors.
+ */
+public class ScriptRegistry {
+
+  private final Map<String, List<Script>> scripts = new ConcurrentHashMap<>();
+
+  public void register(@Nonnull String chatId, @Nonnull Script script) {
+    scripts.computeIfAbsent(chatId, key -> new ArrayList<>());
+    scripts.get(chatId).add(script);
+    scripts.get(chatId).sort(Script::compareTo);
+  }
+
+  @Nonnull
+  public List<Script> getScripts(@Nonnull String chatId) {
+    return scripts.getOrDefault(chatId, new ArrayList<>());
+  }
+
+  public Optional<Script> findByContent(@Nonnull String chatId, @Nonnull String scriptText) {
+    return scripts.getOrDefault(chatId, Collections.emptyList()).stream()
+        .filter(script -> scriptText.equals(script.getStringScript()))
+        .findFirst();
+  }
+
+  public Optional<Script> findByHash(@Nonnull String chatId, int hash) {
+    return scripts.getOrDefault(chatId, Collections.emptyList()).stream()
+        .filter(script -> script.hashCode() == hash)
+        .findFirst();
+  }
+
+  public boolean removeByContent(@Nonnull String chatId, @Nonnull String scriptText) {
+    Optional<Script> script = findByContent(chatId, scriptText);
+    script.ifPresent(Script::cancel);
+    return script.isPresent() && scripts.getOrDefault(chatId, Collections.emptyList()).remove(script.get());
+  }
+
+  public boolean removeByHash(@Nonnull String chatId, int hash) {
+    Optional<Script> script = findByHash(chatId, hash);
+    script.ifPresent(Script::cancel);
+    return script.isPresent() && scripts.getOrDefault(chatId, Collections.emptyList()).remove(script.get());
+  }
+
+  public void clear(@Nonnull String chatId) {
+    scripts.getOrDefault(chatId, Collections.emptyList()).forEach(Script::cancel);
+    scripts.remove(chatId);
+  }
+
+  public void forEach(@Nonnull BiConsumer<String, List<Script>> consumer) {
+    scripts.forEach(consumer);
+  }
+}
diff --git a/src/main/java/ru/holyway/botplatform/telegram/processor/ScriptMessageProcessor.java b/src/main/java/ru/holyway/botplatform/telegram/processor/ScriptMessageProcessor.java
index 83930c6..fd0160b 100644
--- a/src/main/java/ru/holyway/botplatform/telegram/processor/ScriptMessageProcessor.java
+++ b/src/main/java/ru/holyway/botplatform/telegram/processor/ScriptMessageProcessor.java
@@ -1,14 +1,10 @@
 package ru.holyway.botplatform.telegram.processor;
 
 import org.apache.commons.collections.CollectionUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.core.annotation.Order;
 import org.springframework.scheduling.TaskScheduler;
 import org.springframework.stereotype.Component;
-import org.springframework.util.LinkedMultiValueMap;
-import org.springframework.util.MultiValueMap;
 import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
 import org.telegram.telegrambots.meta.api.objects.CallbackQuery;
 import org.telegram.telegrambots.meta.api.objects.Message;
@@ -18,48 +14,51 @@
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 import ru.holyway.botplatform.core.data.DataHelper;
 import ru.holyway.botplatform.scripting.*;
-import ru.holyway.botplatform.scripting.entity.MessageScriptEntity;
 import ru.holyway.botplatform.scripting.entity.StaticMessage;
 import ru.holyway.botplatform.scripting.entity.TimePredicate;
 import ru.holyway.botplatform.telegram.TelegramMessageEntity;
 
 import java.util.*;
 
+import lombok.extern.slf4j.Slf4j;
+
 @Component
 @Order(99)
+@Slf4j
 public class ScriptMessageProcessor implements MessageProcessor, MessagePostLoader {
 
   private final TaskScheduler taskScheduler;
-  private ScriptCompiler scriptCompiler;
-  public DataHelper dataHelper;
-  private MultiValueMap<String, Script> scripts = new LinkedMultiValueMap<>();
-
-  private static final Logger LOGGER = LoggerFactory.getLogger(ScriptMessageProcessor.class);
+  private final ScriptCompiler scriptCompiler;
+  private final DataHelper dataHelper;
+  private final ScriptRegistry scriptRegistry;
+  private final ScriptContextFactory scriptContextFactory;
 
   public ScriptMessageProcessor(ScriptCompiler scriptCompiler, DataHelper dataHelper,
                                 @Qualifier("scriptScheduler") TaskScheduler taskScheduler) {
     this.scriptCompiler = scriptCompiler;
     this.dataHelper = dataHelper;
     this.taskScheduler = taskScheduler;
+    this.scriptRegistry = new ScriptRegistry();
+    this.scriptContextFactory = new ScriptContextFactory();
 
-    for (Map.Entry<String, List<String>> chatScripts : dataHelper.getSettings().getScripts()
-        .entrySet()) {
-      for (String storedScript : chatScripts.getValue()) {
-        try {
-          final Script script = scriptCompiler.compile(storedScript);
-          script.setStringScript(storedScript);
-          scripts.add(chatScripts.getKey(), script);
-        } catch (Exception e) {
-          LOGGER.error("Error during loading script:", e);
-        }
-        scripts.get(chatScripts.getKey()).sort(Script::compareTo);
+    loadStoredScripts();
+  }
+
+  private void loadStoredScripts() {
+    dataHelper.getSettings().getScripts().forEach((chatId, storedScripts) -> storedScripts.forEach(storedScript -> {
+      try {
+        final Script script = scriptCompiler.compile(storedScript);
+        script.setStringScript(storedScript);
+        scriptRegistry.register(chatId, script);
+      } catch (Exception e) {
+        log.error("Error during loading script from storage for chat {}", chatId, e);
       }
-    }
+    }));
   }
 
   @Override
   public boolean isNeedToHandle(TelegramMessageEntity messageEntity) {
-    return CollectionUtils.isNotEmpty(scripts.get(messageEntity.getChatId())) || (
+    return CollectionUtils.isNotEmpty(scriptRegistry.getScripts(messageEntity.getChatId())) || (
         messageEntity.getMessage().hasText() && messageEntity.getMessage().getText()
             .startsWith("script()"));
   }
@@ -79,8 +78,7 @@ public void process(TelegramMessageEntity messageEntity) throws TelegramApiExcep
           scriptString += ".owner(" + messageEntity.getMessage().getFrom().getId() + ")";
           final Script script = scriptCompiler.compile(scriptString);
           script.setStringScript(scriptString);
-          if (scripts.getOrDefault(messageEntity.getChatId(), Collections.emptyList())
-              .contains(script)) {
+          if (scriptRegistry.getScripts(messageEntity.getChatId()).contains(script)) {
             messageEntity.getSender()
                 .execute(SendMessage.builder().text("Скрипт уже существует")
                     .chatId(messageEntity.getChatId())
@@ -88,8 +86,7 @@ public void process(TelegramMessageEntity messageEntity) throws TelegramApiExcep
             continue;
           }
           addTrigger(messageEntity.getSender(), messageEntity.getChatId(), script);
-          scripts.add(messageEntity.getChatId(), script);
-          scripts.get(messageEntity.getChatId()).sort(Script::compareTo);
+          scriptRegistry.register(messageEntity.getChatId(), script);
           dataHelper.getSettings().addScript(messageEntity.getChatId(), scriptString);
           dataHelper.updateSettings();
 
@@ -97,15 +94,16 @@ public void process(TelegramMessageEntity messageEntity) throws TelegramApiExcep
         }
         return;
       } catch (Exception e) {
-        final String message = e.getMessage().substring(0, Math.min(e.getMessage().length(), 1000));
+        final String message = Optional.ofNullable(e.getMessage()).orElse("Unknown error");
+        final String formattedMessage = message.substring(0, Math.min(message.length(), 1000));
         messageEntity.getSender()
-            .execute(SendMessage.builder().text("Ошибка компиляции: \n" + message)
+            .execute(SendMessage.builder().text("Ошибка компиляции: \n" + formattedMessage)
                 .chatId(messageEntity.getChatId()).build());
         throw e;
       }
     }
 
-    for (Script script : scripts.get(messageEntity.getChatId())) {
+    for (Script script : scriptRegistry.getScripts(messageEntity.getChatId())) {
       if (executeScript(messageEntity, script)) {
         return;
       }
@@ -113,9 +111,7 @@ public void process(TelegramMessageEntity messageEntity) throws TelegramApiExcep
   }
 
   private boolean executeScript(TelegramMessageEntity messageEntity, Script script) {
-    MessageScriptEntity message = new MessageScriptEntity(messageEntity);
-    TelegramScriptEntity telegram = new TelegramScriptEntity();
-    ScriptContext ctx = new ScriptContext(message, telegram, script);
+    ScriptContext ctx = scriptContextFactory.create(messageEntity, script);
     final long start = System.currentTimeMillis();
     try {
       if (script.check(ctx)) {
@@ -125,7 +121,7 @@ private boolean executeScript(TelegramMessageEntity messageEntity, Script script
         }
       }
     } catch (Throwable e) {
-      LOGGER.error("Error during execution script:", e);
+      log.error("Error during execution script:", e);
       MetricCollector.getInstance().saveLog(messageEntity.getChatId(), script, e);
     } finally {
       MetricCollector.getInstance().trackCall(messageEntity.getChatId(), Math.toIntExact(System.currentTimeMillis() - start));
@@ -157,7 +153,7 @@ protected Integer sendScriptMenu(TelegramMessageEntity messageEntity, String scr
                 .text(scriptString)
                 .replyMarkup(keyboardMarkup).build()).getMessageId();
       } catch (Throwable e) {
-        LOGGER.warn("Attempt {} to send message and failed", attempts, e);
+        log.warn("Attempt {} to send message and failed", attempts, e);
         attempts++;
         if (attempts == 3) {
           throw e;
@@ -174,7 +170,8 @@ protected Integer sendScriptMenu(TelegramMessageEntity messageEntity, String scr
 
   @Override
   public boolean isRegardingCallback(CallbackQuery callbackQuery) {
-    return CollectionUtils.isNotEmpty(scripts.get(callbackQuery.getMessage().getChatId().toString()));
+    return CollectionUtils.isNotEmpty(
+        scriptRegistry.getScripts(callbackQuery.getMessage().getChatId().toString()));
   }
 
   @Override
@@ -183,7 +180,7 @@ public void processCallBack(CallbackQuery callbackQuery, AbsSender sender)
 
     TelegramMessageEntity messageEntity = new TelegramMessageEntity(callbackQuery.getMessage(), callbackQuery, sender);
 
-    for (Script script : scripts.get(messageEntity.getChatId())) {
+    for (Script script : scriptRegistry.getScripts(messageEntity.getChatId())) {
       if (executeScript(messageEntity, script)) {
         return;
       }
@@ -191,69 +188,50 @@ public void processCallBack(CallbackQuery callbackQuery, AbsSender sender)
   }
 
   public void clearScripts(final String chatId) {
-    scripts.get(chatId).forEach(Script::cancel);
-    scripts.remove(chatId);
+    scriptRegistry.clear(chatId);
     dataHelper.getSettings().getScripts().remove(chatId);
     dataHelper.updateSettings();
   }
 
   public List<Script> getScripts(final String chatId) {
-    return scripts.getOrDefault(chatId, new ArrayList<>());
+    return scriptRegistry.getScripts(chatId);
+  }
+
+  private void removeFromSettings(String chatId, Script script) {
+    Optional.ofNullable(dataHelper.getSettings().getScripts().get(chatId))
+        .ifPresent(list -> list.remove(script.getStringScript()));
+    dataHelper.updateSettings();
   }
 
   public boolean removeScript(final String chatId, final String script) {
-    Optional<Script> s = scripts.get(chatId).stream()
-        .filter(script1 -> script1.getStringScript().equals(script)).findFirst();
-    if (s.isPresent()) {
-      s.get().cancel();
-      scripts.get(chatId).remove(s.get());
-      dataHelper.getSettings().getScripts().get(chatId).remove(script);
-      dataHelper.updateSettings();
-      return true;
-    }
-    return false;
+    Optional<Script> s = scriptRegistry.findByContent(chatId, script);
+    s.ifPresent(foundScript -> {
+      scriptRegistry.removeByContent(chatId, script);
+      removeFromSettings(chatId, foundScript);
+    });
+    return s.isPresent();
   }
 
   public Script getScript(final String chatId, final String script) {
-    Optional<Script> s = scripts.get(chatId).stream()
-        .filter(script1 -> script1.getStringScript().equals(script)).findFirst();
-    if (s.isPresent()) {
-      s.get().cancel();
-      return s.get();
-    }
-    return null;
+    return scriptRegistry.findByContent(chatId, script).orElse(null);
   }
 
   public boolean removeScript(final String chatId, final Integer scriptCode) {
-    Optional<Script> s = scripts.get(chatId).stream()
-        .filter(script -> script.hashCode() == scriptCode).findFirst();
-    if (s.isPresent()) {
-      s.get().cancel();
-      scripts.get(chatId).remove(s.get());
-      dataHelper.getSettings().getScripts().get(chatId).remove(s.get().getStringScript());
-      dataHelper.updateSettings();
-      return true;
-    }
-    return false;
+    Optional<Script> s = scriptRegistry.findByHash(chatId, scriptCode);
+    s.ifPresent(foundScript -> {
+      scriptRegistry.removeByHash(chatId, scriptCode);
+      removeFromSettings(chatId, foundScript);
+    });
+    return s.isPresent();
   }
 
   public Script getScript(final String chatId, final Integer scriptCode) {
-    Optional<Script> s = scripts.get(chatId).stream()
-        .filter(script -> script.hashCode() == scriptCode).findFirst();
-    if (s.isPresent()) {
-      s.get().cancel();
-      return s.get();
-    }
-    return null;
+    return scriptRegistry.findByHash(chatId, scriptCode).orElse(null);
   }
 
   @Override
   public void postRun(AbsSender absSender) {
-    scripts.forEach((chat, chatScripts) -> {
-      chatScripts.forEach(script -> {
-        addTrigger(absSender, chat, script);
-      });
-    });
+    scriptRegistry.forEach((chat, chatScripts) -> chatScripts.forEach(script -> addTrigger(absSender, chat, script)));
   }
 
   private void addTrigger(AbsSender absSender, String chat, Script script) {
@@ -263,14 +241,14 @@ private void addTrigger(AbsSender absSender, String chat, Script script) {
         Message message = new StaticMessage(chat);
         TelegramMessageEntity telegramMessageEntity = new TelegramMessageEntity(message,
             null, absSender);
-        ScriptContext ctx = new ScriptContext(new MessageScriptEntity(telegramMessageEntity), new TelegramScriptEntity(), script);
+        ScriptContext ctx = scriptContextFactory.create(telegramMessageEntity, script);
         final long start = System.currentTimeMillis();
 
         try {
           script.execute(ctx);
         } catch (Throwable e) {
           MetricCollector.getInstance().saveLog(chat, script, e);
-          LOGGER.error("Error occurred during execution script: ", e);
+          log.error("Error occurred during execution script: ", e);
         } finally {
           MetricCollector.getInstance().trackCall(chat, Math.toIntExact(System.currentTimeMillis() - start));
         }
diff --git a/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java b/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
new file mode 100644
index 0000000..e3f7f00
--- /dev/null
+++ b/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
@@ -0,0 +1,40 @@
+package ru.holyway.botplatform.scripting;
+
+import groovy.lang.GroovyShell;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class ScriptCompilerImplTest {
+
+  @Rule
+  public ExpectedException expectedException = ExpectedException.none();
+
+  private final ScriptCompilerImpl compiler = new ScriptCompilerImpl(new GroovyShell());
+
+  @Test
+  public void compileShouldReturnConfiguredScript() {
+    Script script = compiler.compile("ru.holyway.botplatform.scripting.Script.script('test')" +
+        ".when(ru.holyway.botplatform.scripting.Script.any())" +
+        ".then(ru.holyway.botplatform.scripting.Script.nothing())");
+
+    assertNotNull(script);
+    assertEquals("test", script.getName());
+    assertNotNull(script.getPredicates());
+    assertNotNull(script);
+  }
+
+  @Test
+  public void compileShouldWrapGroovyErrors() {
+    expectedException.expect(ScriptCompilationException.class);
+    expectedException.expectMessage(is("Unable to compile script"));
+    expectedException.expectMessage(containsString("badMethod"));
+
+    compiler.compile("badMethod(");
+  }
+}
diff --git a/src/test/java/ru/holyway/botplatform/scripting/ScriptRegistryTest.java b/src/test/java/ru/holyway/botplatform/scripting/ScriptRegistryTest.java
new file mode 100644
index 0000000..f03e1ed
--- /dev/null
+++ b/src/test/java/ru/holyway/botplatform/scripting/ScriptRegistryTest.java
@@ -0,0 +1,56 @@
+package ru.holyway.botplatform.scripting;
+
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.empty;
+import static org.junit.Assert.*;
+
+public class ScriptRegistryTest {
+
+  @Test
+  public void registerShouldKeepScriptsSorted() {
+    ScriptRegistry registry = new ScriptRegistry();
+    Script slow = Script.script("slow").order(10);
+    slow.setStringScript("slow-script");
+    Script fast = Script.script("fast").order(1);
+    fast.setStringScript("fast-script");
+
+    registry.register("chat", slow);
+    registry.register("chat", fast);
+
+    List<Script> scripts = registry.getScripts("chat");
+
+    assertThat(scripts, contains(fast, slow));
+  }
+
+  @Test
+  public void removeByContentShouldDropScriptAndTriggerCancellation() {
+    ScriptRegistry registry = new ScriptRegistry();
+    Script script = Script.script("to-remove");
+    script.setStringScript("body");
+
+    registry.register("chat", script);
+
+    assertTrue(registry.removeByContent("chat", "body"));
+    assertThat(registry.getScripts("chat"), empty());
+  }
+
+  @Test
+  public void removeByHashShouldWorkForMultipleScripts() {
+    ScriptRegistry registry = new ScriptRegistry();
+    Script first = Script.script("first");
+    first.setStringScript("first-body");
+    Script second = Script.script("second");
+    second.setStringScript("second-body");
+
+    registry.register("chat", first);
+    registry.register("chat", second);
+
+    assertTrue(registry.removeByHash("chat", second.hashCode()));
+    assertEquals(1, registry.getScripts("chat").size());
+    assertEquals(first, registry.getScripts("chat").get(0));
+  }
+}

From c8d150734ba5436a2a7dc3dccf07b4d12cb06f43 Mon Sep 17 00:00:00 2001
From: Sergey Ivanov <delta_001@bk.ru>
Date: Tue, 2 Dec 2025 19:13:24 +0500
Subject: [PATCH 2/3] Fix ScriptCompiler test expectations

---
 .../holyway/botplatform/scripting/ScriptCompilerImplTest.java  | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java b/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
index e3f7f00..c9918aa 100644
--- a/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
+++ b/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
@@ -6,6 +6,7 @@
 import org.junit.rules.ExpectedException;
 
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.hasProperty;
 import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
@@ -33,7 +34,7 @@ public void compileShouldReturnConfiguredScript() {
   public void compileShouldWrapGroovyErrors() {
     expectedException.expect(ScriptCompilationException.class);
     expectedException.expectMessage(is("Unable to compile script"));
-    expectedException.expectMessage(containsString("badMethod"));
+    expectedException.expectCause(hasProperty("message", containsString("badMethod")));
 
     compiler.compile("badMethod(");
   }

From 451a78d93fea730cb63cbb93cf9d365eba86b60b Mon Sep 17 00:00:00 2001
From: Sergey Ivanov <delta_001@bk.ru>
Date: Wed, 3 Dec 2025 09:53:14 +0500
Subject: [PATCH 3/3] Refine script compiler error wrap test

---
 .../scripting/ScriptCompilerImplTest.java     | 22 +++++++++----------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java b/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
index c9918aa..2b6f09a 100644
--- a/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
+++ b/src/test/java/ru/holyway/botplatform/scripting/ScriptCompilerImplTest.java
@@ -1,21 +1,16 @@
 package ru.holyway.botplatform.scripting;
 
 import groovy.lang.GroovyShell;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.hasProperty;
-import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
 
 public class ScriptCompilerImplTest {
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
   private final ScriptCompilerImpl compiler = new ScriptCompilerImpl(new GroovyShell());
 
   @Test
@@ -32,10 +27,13 @@ public void compileShouldReturnConfiguredScript() {
 
   @Test
   public void compileShouldWrapGroovyErrors() {
-    expectedException.expect(ScriptCompilationException.class);
-    expectedException.expectMessage(is("Unable to compile script"));
-    expectedException.expectCause(hasProperty("message", containsString("badMethod")));
-
-    compiler.compile("badMethod(");
+    try {
+      compiler.compile("badMethod(");
+      fail("Script compilation failure should be wrapped");
+    } catch (ScriptCompilationException ex) {
+      assertEquals("Unable to compile script", ex.getMessage());
+      assertNotNull(ex.getCause());
+      assertThat(ex.getCause().getMessage(), containsString("badMethod"));
+    }
   }
 }