From d39d2c81440a954cfa5e9b89dfef3a32f4608687 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 10 May 2025 03:25:53 +0300
Subject: [PATCH 001/131] cargo add quickjs-rusty

---
 Cargo.lock | 181 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 Cargo.toml |   1 +
 2 files changed, 182 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index d244f23..561ed82 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -60,6 +60,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+
 [[package]]
 name = "aquamarine"
 version = "0.6.0"
@@ -133,6 +139,26 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "bindgen"
+version = "0.71.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+dependencies = [
+ "bitflags 2.9.0",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.10.5",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 2.0.100",
+]
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -220,9 +246,20 @@ version = "1.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fcb57c740ae1daf453ae85f16e37396f672b039e00d9d866e07ddb24e328e3a"
 dependencies = [
+ "jobserver",
+ "libc",
  "shlex",
 ]
 
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -265,6 +302,17 @@ dependencies = [
  "phf_codegen",
 ]
 
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
 [[package]]
 name = "concurrent-queue"
 version = "2.5.0"
@@ -309,6 +357,15 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "copy_dir"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "543d1dd138ef086e2ff05e3a48cf9da045da2033d16f8538fd76b86cd49b2ca3"
+dependencies = [
+ "walkdir",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -840,6 +897,12 @@ version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
 
+[[package]]
+name = "glob"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+
 [[package]]
 name = "gongbotrs"
 version = "0.1.0"
@@ -856,6 +919,7 @@ dependencies = [
  "log",
  "mongodb",
  "pretty_env_logger",
+ "quickjs-rusty",
  "serde",
  "teloxide",
  "thiserror 2.0.12",
@@ -1352,6 +1416,16 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
+[[package]]
+name = "jobserver"
+version = "0.1.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
+dependencies = [
+ "getrandom 0.3.2",
+ "libc",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.77"
@@ -1368,6 +1442,27 @@ version = "0.2.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
 
+[[package]]
+name = "libloading"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
+dependencies = [
+ "cfg-if",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "libquickjs-ng-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c98c1ad542ec61348faba7ce5386fef9060e35fbeea19dda64ce41862084e0a"
+dependencies = [
+ "bindgen",
+ "cc",
+ "copy_dir",
+]
+
 [[package]]
 name = "libsqlite3-sys"
 version = "0.30.1"
@@ -1502,6 +1597,12 @@ dependencies = [
  "unicase",
 ]
 
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.5"
@@ -1600,12 +1701,41 @@ dependencies = [
  "tempfile",
 ]
 
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
 
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1828,6 +1958,16 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "prettyplease"
+version = "0.2.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.100",
+]
+
 [[package]]
 name = "proc-macro-error-attr2"
 version = "2.0.0"
@@ -1858,6 +1998,22 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "quickjs-rusty"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3b4d659d1bc37e9112a14ad9a7727d182b0fb12216eb6684bdbada3e9991a22"
+dependencies = [
+ "anyhow",
+ "chrono",
+ "libquickjs-ng-sys",
+ "log",
+ "num-bigint",
+ "num-traits",
+ "serde",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.40"
@@ -2067,6 +2223,12 @@ version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -2157,6 +2319,15 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "schannel"
 version = "0.1.27"
@@ -3059,6 +3230,16 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "want"
 version = "0.3.1"
diff --git a/Cargo.toml b/Cargo.toml
index e8b707a..ffa5767 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,6 +18,7 @@ itertools = "0.14.0"
 log = "0.4.27"
 mongodb = "3.2.3"
 pretty_env_logger = "0.5.0"
+quickjs-rusty = "0.9.0"
 serde = { version = "1.0.219", features = ["derive", "serde_derive"] }
 teloxide = { version = "0.14.0", features = ["macros", "postgres-storage-nativetls"] }
 thiserror = "2.0.12"

From 08c1b67f021940045c7701471e9cfeb8d2aa7541 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 10 May 2025 03:27:35 +0300
Subject: [PATCH 002/131] create botscript runner

---
 src/botscript.rs | 96 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/main.rs      |  1 +
 2 files changed, 97 insertions(+)
 create mode 100644 src/botscript.rs

diff --git a/src/botscript.rs b/src/botscript.rs
new file mode 100644
index 0000000..8724e27
--- /dev/null
+++ b/src/botscript.rs
@@ -0,0 +1,96 @@
+use quickjs_rusty::Context;
+use quickjs_rusty::ContextError;
+use quickjs_rusty::ExecutionError;
+use quickjs_rusty::OwnedJsValue as JsValue;
+
+#[derive(thiserror::Error, Debug)]
+pub enum ScriptError {
+    #[error("error context: {0:?}")]
+    ContextError(#[from] ContextError),
+    #[error("error running: {0:?}")]
+    ExecutionError(#[from] ExecutionError),
+}
+
+pub type ScriptResult<T> = Result<T, ScriptError>;
+
+// TODO: remove this function since it is suitable only for early development
+#[allow(clippy::print_stdout)]
+fn print(s: String) {
+    println!("{s}");
+}
+
+pub struct Runner {
+    context: Context,
+}
+
+impl Runner {
+    pub fn init() -> ScriptResult<Self> {
+        let context = Context::new(None)?;
+
+        context.add_callback("print", |a: String| {
+            print(a);
+
+            None::<bool>
+        })?;
+
+        Ok(Runner { context })
+    }
+
+    pub fn run_script(&self, content: &str) -> ScriptResult<JsValue> {
+        let ctx = &self.context;
+
+        let val = ctx.eval(content, false)?;
+
+        Ok(val)
+    }
+}
+
+#[cfg(test)]
+// allowing this since it is better for debugging tests)
+#[allow(clippy::unwrap_used)]
+#[allow(clippy::print_stdout)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_run_script_valid() {
+        let runner = Runner::init().unwrap();
+        let val = runner.run_script(r#"print"#).unwrap();
+        println!("Val: {:?}", val);
+        let val = runner.run_script(r#"print('Hello from JS!');"#).unwrap();
+        println!("Val: {:?}", val);
+        assert!(val.is_null());
+        let val = runner.run_script(r#"const a = 1+2; a"#).unwrap();
+        println!("Val: {:?}", val);
+        assert_eq!(val.to_int(), Ok(3));
+        let val = runner.run_script(r#"a + 39"#).unwrap();
+        println!("Val: {:?}", val);
+        assert_eq!(val.to_int(), Ok(42));
+    }
+
+    #[test]
+    fn test_run_script_file_main() {
+        let runner = Runner::init().unwrap();
+        let val = runner.run_script(include_str!("../mainbot.js")).unwrap();
+        println!("config: {:?}", val);
+        let val = runner.run_script("start_buttons()").unwrap();
+        println!("Val: {:?}", val.to_string());
+    }
+
+    #[test]
+    fn test_run_script_invalid() {
+        let runner = Runner::init().unwrap();
+        let result = runner.run_script(r#"invalid_script();"#);
+
+        assert!(result.is_err());
+        let errstr =
+            if let Err(ScriptError::ExecutionError(ExecutionError::Exception(errstr))) = result {
+                errstr.to_string().unwrap()
+            } else {
+                panic!("test returned wrong error!, {result:?}");
+            };
+        if errstr != "ReferenceError: invalid_script is not defined" {
+            panic!("test returned an error, but the wrong one, {errstr}")
+        }
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index a5fd667..1e47d0b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,5 @@
 pub mod admin;
+pub mod botscript;
 pub mod db;
 pub mod mongodb_storage;
 pub mod utils;

From 0c927448d26a0a77bf869afbe050287881d92976 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 10 May 2025 03:28:00 +0300
Subject: [PATCH 003/131] create mainbot.js where main bot's logic will be
 contained

---
 mainbot.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 mainbot.js

diff --git a/mainbot.js b/mainbot.js
new file mode 100644
index 0000000..5bc56b3
--- /dev/null
+++ b/mainbot.js
@@ -0,0 +1,35 @@
+// db - is set globally
+
+const dialog = {
+    start: {
+        buttons: start_buttons
+    }
+}
+
+const fmt = (number) => number.toString().padStart(2, '0');
+
+const formatDate = (date) => {
+    const [h, m, d, M, y] = [
+        date.getHours(),
+        date.getMinutes(),
+        date.getDate(),
+        date.getMonth(),
+        date.getFullYear()
+    ];
+    return `${fmt(h)}:${fmt(m)} ${fmt(d)}-${fmt(M + 1)}-${y}`
+};
+
+function start_buttons() {
+    const now = new Date();
+    const dateFormated = formatDate(now);
+    print(console)
+
+    // return 1
+    return dateFormated
+}
+
+const config = {
+    version: 1.0
+}
+
+{config, dialog}

From 9d5bf86289567e44b7c80492aeac403aad3a223f Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:05:10 +0300
Subject: [PATCH 004/131] create recursive_format function just for tests

---
 src/botscript.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 8724e27..980a2ea 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -77,6 +77,22 @@ mod tests {
         println!("Val: {:?}", val.to_string());
     }
 
+    fn recursive_format(o: OwnedJsObject) -> String {
+        let props: Vec<_> = o.properties_iter().unwrap().map(|x| x.unwrap()).collect();
+        let sp: Vec<String> = props
+            .into_iter()
+            .map(|v| {
+                if v.is_object() {
+                    recursive_format(v.try_into_object().unwrap())
+                } else {
+                    format!("{:?}", v)
+                }
+            })
+            .collect();
+
+        format!("{:?}", sp)
+    }
+
     #[test]
     fn test_run_script_invalid() {
         let runner = Runner::init().unwrap();

From bf032e6ce403081282a968d5baae7397469d9aea Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:07:40 +0300
Subject: [PATCH 005/131] create test for deserealization of mainbot.js

---
 src/botscript.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 980a2ea..89bb9ca 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -77,6 +77,16 @@ mod tests {
         println!("Val: {:?}", val.to_string());
     }
 
+    #[test]
+    fn test_deserialization_main() {
+        let runner = Runner::init().unwrap();
+        let val = runner.run_script(include_str!("../mainbot.js")).unwrap();
+        let s: RunnerConfig = from_js(unsafe { runner.context.context_raw() }, &val).unwrap();
+        println!("deser: {:#?}", s);
+        let o = val.try_into_object().unwrap();
+        println!("o: {:?}", recursive_format(o));
+    }
+
     fn recursive_format(o: OwnedJsObject) -> String {
         let props: Vec<_> = o.properties_iter().unwrap().map(|x| x.unwrap()).collect();
         let sp: Vec<String> = props

From 96996fd33dff4dda7f0cdde9f461c13e2cf90659 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:08:34 +0300
Subject: [PATCH 006/131] update mainbot.js with new specification

---
 mainbot.js | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/mainbot.js b/mainbot.js
index 5bc56b3..162f31b 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -2,7 +2,7 @@
 
 const dialog = {
     start: {
-        buttons: start_buttons
+        buttons: "start_buttons"
     }
 }
 
@@ -22,14 +22,15 @@ const formatDate = (date) => {
 function start_buttons() {
     const now = new Date();
     const dateFormated = formatDate(now);
-    print(console)
 
     // return 1
     return dateFormated
 }
 
 const config = {
-    version: 1.0
+    version: 1.1
 }
 
-{config, dialog}
+// {config, dialog}
+const c = {config: config, dialog: dialog}
+c

From a6206d3d6fb3f7bbf12aceb883ce6308dea0cbd9 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:09:34 +0300
Subject: [PATCH 007/131] use quickjs_rusty's from_js in tests

---
 src/botscript.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 89bb9ca..966565c 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -50,6 +50,8 @@ impl Runner {
 #[allow(clippy::unwrap_used)]
 #[allow(clippy::print_stdout)]
 mod tests {
+    use quickjs_rusty::{serde::from_js, OwnedJsObject};
+
     use super::*;
 
     #[test]

From e7d43adc40551a8f6e5a92b643886daf61afbc80 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:10:03 +0300
Subject: [PATCH 008/131] create structs for bot's configuration definition

---
 src/botscript.rs | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 966565c..3868b91 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,7 +1,11 @@
+use std::collections::HashMap;
+
 use quickjs_rusty::Context;
 use quickjs_rusty::ContextError;
 use quickjs_rusty::ExecutionError;
 use quickjs_rusty::OwnedJsValue as JsValue;
+use serde::Deserialize;
+use serde::Serialize;
 
 #[derive(thiserror::Error, Debug)]
 pub enum ScriptError {
@@ -13,12 +17,39 @@ pub enum ScriptError {
 
 pub type ScriptResult<T> = Result<T, ScriptError>;
 
+pub type BotFunction = String; // temporal workaround
+
 // TODO: remove this function since it is suitable only for early development
 #[allow(clippy::print_stdout)]
 fn print(s: String) {
     println!("{s}");
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct BotConfig {
+    version: f64,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Button {
+    name: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct BotMessage {
+    // buttons: Vec<Button>
+    buttons: BotFunction,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct BotDialog(HashMap<String, BotMessage>);
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RunnerConfig {
+    config: BotConfig,
+    dialog: BotDialog,
+}
+
 pub struct Runner {
     context: Context,
 }

From a643a707edd9c5f63f0fb44eb96ae66f12185104 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:13:17 +0300
Subject: [PATCH 009/131] new specification of bot commands definition

---
 mainbot.js | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/mainbot.js b/mainbot.js
index 162f31b..b064a25 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -1,9 +1,11 @@
 // db - is set globally
 
 const dialog = {
-    start: {
-        buttons: "start_buttons"
-    }
+    commands: {
+        start: {
+            buttons: "start_buttons"
+        },
+    },
 }
 
 const fmt = (number) => number.toString().padStart(2, '0');

From 48cbd4c7d0d2bfda2bbbc5c73038c3767132d1f2 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:14:02 +0300
Subject: [PATCH 010/131] fix missing commas in mainbot.js

---
 mainbot.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mainbot.js b/mainbot.js
index b064a25..c72a6b2 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -3,7 +3,7 @@
 const dialog = {
     commands: {
         start: {
-            buttons: "start_buttons"
+            buttons: "start_buttons",
         },
     },
 }
@@ -30,7 +30,7 @@ function start_buttons() {
 }
 
 const config = {
-    version: 1.1
+    version: 1.1,
 }
 
 // {config, dialog}

From 05b298e61ce450dfff84085e3890ee128bbd56ea Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:30:25 +0300
Subject: [PATCH 011/131] add more command example to mainbot.js

---
 mainbot.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mainbot.js b/mainbot.js
index c72a6b2..c01ec3a 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -4,6 +4,10 @@ const dialog = {
     commands: {
         start: {
             buttons: "start_buttons",
+            state: "start"
+        },
+        cancel: {
+            state: "none"
         },
     },
 }

From 8e9d5b4f1de62290c16f071b2758e881262584d7 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 16:30:46 +0300
Subject: [PATCH 012/131] add stateful_msg_handlers example to mainbot.js

---
 mainbot.js | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/mainbot.js b/mainbot.js
index c01ec3a..2c56953 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -10,6 +10,15 @@ const dialog = {
             state: "none"
         },
     },
+    stateful_msg_handlers: {
+        start: {}, // everything is by default, so just send message `start`
+        enter_name: {
+            handler: "enter_name", // name of the handler function. This field has a
+                                   // side effect: when is set, no automatic sending
+                                   // of message, should be sent manually in handler
+            state: "none"
+        },
+    }
 }
 
 const fmt = (number) => number.toString().padStart(2, '0');

From 6299f6d815aef6ad01c2dcbd8d4da6db45e188a2 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 22:18:37 +0300
Subject: [PATCH 013/131] add comment about default value of buttons in
 mainbot.js

---
 mainbot.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mainbot.js b/mainbot.js
index 2c56953..20ffbfd 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -3,7 +3,7 @@
 const dialog = {
     commands: {
         start: {
-            buttons: "start_buttons",
+            buttons: "start_buttons", // default is `null`
             state: "start"
         },
         cancel: {

From 3d6bf15806f31f678f09e7d668a3134585b63723 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 22:19:09 +0300
Subject: [PATCH 014/131] add somecomplicatedcmd as an example in mainbot.js

---
 mainbot.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mainbot.js b/mainbot.js
index 20ffbfd..1abc2db 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -9,6 +9,7 @@ const dialog = {
         cancel: {
             state: "none"
         },
+        somecomplicatedcmd: {}
     },
     stateful_msg_handlers: {
         start: {}, // everything is by default, so just send message `start`

From 7dbad400cc78160d46f68ad9bc3d0b76974f57a5 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 18 May 2025 22:19:27 +0300
Subject: [PATCH 015/131] mainbot.js: fix missing comma

---
 mainbot.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mainbot.js b/mainbot.js
index 1abc2db..973055f 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -19,7 +19,7 @@ const dialog = {
                                    // of message, should be sent manually in handler
             state: "none"
         },
-    }
+    },
 }
 
 const fmt = (number) => number.toString().padStart(2, '0');

From c8c67b54e3cfafb3955b41188a19a06db0fb59b3 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 19 May 2025 23:54:08 +0500
Subject: [PATCH 016/131] make botFunction a struct

---
 src/botscript.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 3868b91..77edc28 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -17,7 +17,8 @@ pub enum ScriptError {
 
 pub type ScriptResult<T> = Result<T, ScriptError>;
 
-pub type BotFunction = String; // temporal workaround
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct BotFunction(String); // temporal workaround
 
 // TODO: remove this function since it is suitable only for early development
 #[allow(clippy::print_stdout)]

From c2e02efc479c3653a9c0a6bd415925f612064d4a Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 19 May 2025 23:54:39 +0500
Subject: [PATCH 017/131] create call_context method for BotFunction

---
 src/botscript.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 77edc28..4f6430b 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -20,6 +20,13 @@ pub type ScriptResult<T> = Result<T, ScriptError>;
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BotFunction(String); // temporal workaround
 
+impl BotFunction {
+    pub fn call_context(&self, runner: &Runner) -> ScriptResult<JsValue> {
+        let func_name = &self.0;
+
+        runner.run_script(&format!("{func_name}()"))
+    }
+}
 // TODO: remove this function since it is suitable only for early development
 #[allow(clippy::print_stdout)]
 fn print(s: String) {

From eb63743714115b560366289c2b47b9359e1ec086 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 19 May 2025 23:55:44 +0500
Subject: [PATCH 018/131] create js_into for JsValue

reason: wil be way less boilerplate for deserialization of JsValue to defined structs
---
 src/botscript.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 4f6430b..c871ab2 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -27,6 +27,19 @@ impl BotFunction {
         runner.run_script(&format!("{func_name}()"))
     }
 }
+
+pub trait DeserializeJS {
+    fn js_into<'a, T: Deserialize<'a>>(&'a self) -> ScriptResult<T>;
+}
+
+impl DeserializeJS for JsValue {
+    fn js_into<'a, T: Deserialize<'a>>(&'a self) -> ScriptResult<T> {
+        let rc = from_js(self.context(), &self)?;
+
+        Ok(rc)
+    }
+}
+
 // TODO: remove this function since it is suitable only for early development
 #[allow(clippy::print_stdout)]
 fn print(s: String) {

From 3f8f25fff9a9d9de36b4e4fe5f2f048762fd6992 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 19 May 2025 23:57:22 +0500
Subject: [PATCH 019/131] create SerdeError for ScriptError

reason: to handle errors from call of from_js
---
 src/botscript.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index c871ab2..8184e76 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -13,6 +13,8 @@ pub enum ScriptError {
     ContextError(#[from] ContextError),
     #[error("error running: {0:?}")]
     ExecutionError(#[from] ExecutionError),
+    #[error("error from anyhow: {0:?}")]
+    SerdeError(#[from] quickjs_rusty::serde::Error),
 }
 
 pub type ScriptResult<T> = Result<T, ScriptError>;

From cddf5986badc57a674f0236458ac60447a1faf27 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 19 May 2025 23:58:53 +0500
Subject: [PATCH 020/131] use from_js

---
 src/botscript.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 8184e76..9b98352 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 
+use quickjs_rusty::serde::from_js;
 use quickjs_rusty::Context;
 use quickjs_rusty::ContextError;
 use quickjs_rusty::ExecutionError;

From 22ab941ed89e32136185ce8bb9a9e6cb5fa531c8 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 00:33:51 +0500
Subject: [PATCH 021/131] create buttons definition example in mainbot.js

---
 mainbot.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/mainbot.js b/mainbot.js
index 973055f..326b949 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -11,6 +11,9 @@ const dialog = {
         },
         somecomplicatedcmd: {}
     },
+    buttons: {
+        more_info: {},
+    },
     stateful_msg_handlers: {
         start: {}, // everything is by default, so just send message `start`
         enter_name: {

From f6b18af5dd4effd4574dac998f57147524ed54a8 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 00:38:29 +0500
Subject: [PATCH 022/131] derive clone on BoMessage

---
 src/botscript.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 9b98352..fa8e851 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -59,7 +59,7 @@ pub struct Button {
     name: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BotMessage {
     // buttons: Vec<Button>
     buttons: BotFunction,

From 135139514b53b8b6fa3e616b1f7194f8f6cc4489 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 00:39:15 +0500
Subject: [PATCH 023/131] update btoscript struct definitions

---
 src/botscript.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index fa8e851..11f55eb 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -62,16 +62,22 @@ pub struct Button {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BotMessage {
     // buttons: Vec<Button>
-    buttons: BotFunction,
+    buttons: Option<BotFunction>,
+    state: Option<String>,
+
+    handler: Option<BotFunction>,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct BotDialog(HashMap<String, BotMessage>);
+pub struct BotDialog {
+    pub commands: HashMap<String, BotMessage>,
+    stateful_msg_handlers: HashMap<String, BotMessage>,
+}
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct RunnerConfig {
     config: BotConfig,
-    dialog: BotDialog,
+    pub dialog: BotDialog,
 }
 
 pub struct Runner {

From 534a0e609056e29e1a6821dfa18945f4ae05fcf3 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 00:39:39 +0500
Subject: [PATCH 024/131] create init_config method for Runner

---
 src/botscript.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 11f55eb..d54712c 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -104,6 +104,15 @@ impl Runner {
 
         Ok(val)
     }
+
+    pub fn init_config(&self, content: &str) -> ScriptResult<RunnerConfig> {
+        let val = self.run_script(content)?;
+
+        // let rc: RunnerConfig = from_js(unsafe { self.context.context_raw() }, &val)?;
+        let rc: RunnerConfig = val.js_into()?;
+
+        Ok(rc)
+    }
 }
 
 #[cfg(test)]

From 5c8cadf7a0db4664394f60344af52521e9442a6f Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 00:40:25 +0500
Subject: [PATCH 025/131] create test for deserealization of result of js
 function

---
 src/botscript.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index d54712c..51375fc 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -159,6 +159,22 @@ mod tests {
         println!("o: {:?}", recursive_format(o));
     }
 
+    #[test]
+    fn test_func_deserialization_main() {
+        let runner = Runner::init().unwrap();
+        let _ = runner
+            .run_script("function cancel_buttons() {return 'cancelation'}")
+            .unwrap();
+
+        let f = BotFunction("cancel_buttons".to_string());
+        let res = f.call_context(&runner).unwrap();
+
+        println!("RES: {res:?}");
+        let sres: String = res.js_into().unwrap();
+        println!("Deserialized RES: {:?}", sres);
+        assert_eq!(sres, "cancelation");
+    }
+
     fn recursive_format(o: OwnedJsObject) -> String {
         let props: Vec<_> = o.properties_iter().unwrap().map(|x| x.unwrap()).collect();
         let sp: Vec<String> = props

From 3d9a1c31b463bbc1dd0ec3e88bccdc3563262fbc Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 00:42:32 +0500
Subject: [PATCH 026/131] use RunnerConfig in BotController

---
 src/main.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index 1e47d0b..1bd8ada 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,6 +4,7 @@ pub mod db;
 pub mod mongodb_storage;
 pub mod utils;
 
+use botscript::{Runner, RunnerConfig};
 use db::application::Application;
 use db::callback_info::CallbackInfo;
 use db::message_forward::MessageForward;
@@ -98,6 +99,7 @@ type CallbackStore = CallbackInfo<Callback>;
 pub struct BotController {
     pub bot: Bot,
     pub db: DB,
+    pub rc: RunnerConfig,
 }
 
 impl BotController {
@@ -105,7 +107,9 @@ impl BotController {
         let bot = Bot::new(&config.bot_token);
         let db = DB::init(&config.db_url).await?;
 
-        Ok(Self { bot, db })
+        let rc = Runner::init()?.init_config(include_str!("../mainbot.js"))?;
+
+        Ok(Self { bot, db, rc })
     }
 }
 

From 29cd73e98fe1a0bb17f35092e4f2ec0478ccf776 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 00:44:08 +0500
Subject: [PATCH 027/131] create basic handler to answer BotMessage

---
 src/main.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index 1bd8ada..6191c95 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,7 +4,7 @@ pub mod db;
 pub mod mongodb_storage;
 pub mod utils;
 
-use botscript::{Runner, RunnerConfig};
+use botscript::{BotMessage, Runner, RunnerConfig};
 use db::application::Application;
 use db::callback_info::CallbackInfo;
 use db::message_forward::MessageForward;
@@ -228,6 +228,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     Ok(())
 }
+
+async fn botscript_command_handler(bot: Bot, bm: BotMessage) -> BotResult<()> {
+    info!("Eval BM: {:?}", bm);
+
+    Ok(())
+}
+
 async fn user_reply_to_support(bot: Bot, mut db: DB, msg: Message) -> BotResult<()> {
     let (source_chat_id, source_message_id) = (msg.chat.id.0, msg.id.0);
     let text = match msg.html_text() {

From 0e10cdbdf03f6d7e220ced8824b103002743cf3c Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 01:06:16 +0500
Subject: [PATCH 028/131] create command module

defines BotCommand struct
---
 src/commands.rs | 99 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/main.rs     |  1 +
 2 files changed, 100 insertions(+)
 create mode 100644 src/commands.rs

diff --git a/src/commands.rs b/src/commands.rs
new file mode 100644
index 0000000..d6bcdb6
--- /dev/null
+++ b/src/commands.rs
@@ -0,0 +1,99 @@
+use std::str::FromStr;
+
+use teloxide::utils::command::ParseError;
+
+#[derive(thiserror::Error, Debug)]
+pub enum CommandError {
+    #[error("parse error: {0:?}")]
+    ParseError(#[from] ParseError),
+    #[error("failed to validate command: {0:?}")]
+    ValidationError(String),
+}
+
+pub struct BotCommand {
+    command: String,
+    args: Option<String>,
+}
+
+impl FromStr for BotCommand {
+    type Err = CommandError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (command, args) = s.split_once(" ").map_or((s, None), |s| (s.0, Some(s.1)));
+
+        match command.strip_prefix("/") {
+            Some(command) => Ok(Self {
+                command: command.to_string(),
+                args: args.map(str::to_string),
+            }),
+            None => Err(CommandError::ParseError(ParseError::IncorrectFormat(
+                "Not a command".into(),
+            ))),
+        }
+    }
+}
+
+impl BotCommand {
+    pub fn from_validate(s: &str, cmds: &[&str]) -> Result<Self, CommandError> {
+        let bc = Self::from_str(s)?;
+
+        if !cmds.contains(&bc.command.as_str()) {
+            return Err(CommandError::ValidationError(format!(
+                "invalid command {}",
+                bc.command
+            )));
+        };
+
+        Ok(bc)
+    }
+
+    pub fn command(&self) -> &str {
+        &self.command
+    }
+
+    pub fn args(&self) -> Option<&str> {
+        self.args.as_deref()
+    }
+
+    pub fn args_list(&self) -> Vec<&str> {
+        let args = match self.args {
+            Some(ref args) => args.as_str(),
+            None => "",
+        };
+
+        args.split_whitespace().collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_botcommand_from_str_simple() {
+        let cmdstr = "/start";
+
+        let bc = BotCommand::from_str(cmdstr).unwrap();
+        assert_eq!(bc.command(), "start");
+        assert_eq!(bc.args(), None);
+    }
+
+    #[test]
+    fn test_botcommand_from_str_with_args() {
+        let cmdstr = "/some_long_cmd arg1 arg2";
+
+        let bc = BotCommand::from_str(cmdstr).unwrap();
+        assert_eq!(bc.command(), "some_long_cmd");
+        assert_eq!(bc.args(), Some("arg1 arg2"));
+    }
+
+    #[test]
+    fn test_botcommand_arg_list() {
+        let cmdstr = "/some_long_cmd arg1 arg2";
+
+        let bc = BotCommand::from_str(cmdstr).unwrap();
+        assert_eq!(bc.command(), "some_long_cmd");
+        assert_eq!(bc.args(), Some("arg1 arg2"));
+        assert_eq!(bc.args_list(), vec!["arg1", "arg2"]);
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 6191c95..d42103c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,6 @@
 pub mod admin;
 pub mod botscript;
+pub mod commands;
 pub mod db;
 pub mod mongodb_storage;
 pub mod utils;

From e0c00d68f924bab2512e7b44cdda9fbedb852386 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 01:16:52 +0500
Subject: [PATCH 029/131] derive Clone on BotCommand

reason: everything passed in teloxide's filter_map asks Clone (or Copy) implementation
---
 src/commands.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/commands.rs b/src/commands.rs
index d6bcdb6..5e8f7ca 100644
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -10,6 +10,7 @@ pub enum CommandError {
     ValidationError(String),
 }
 
+#[derive(Clone)]
 pub struct BotCommand {
     command: String,
     args: Option<String>,

From 2ccfc19a6c8b5529375a24bf4f5ff3b3792abbaf Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 02:47:00 +0500
Subject: [PATCH 030/131] create filter to handle botscript-defined commands

---
 src/main.rs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index d42103c..4a81130 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,11 +6,15 @@ pub mod mongodb_storage;
 pub mod utils;
 
 use botscript::{BotMessage, Runner, RunnerConfig};
+use commands::BotCommand;
 use db::application::Application;
 use db::callback_info::CallbackInfo;
 use db::message_forward::MessageForward;
 use itertools::Itertools;
 use log::{error, info, warn};
+use std::collections::HashMap;
+use std::str::FromStr;
+use std::sync::RwLock;
 use std::time::Duration;
 use teloxide::sugar::request::RequestReplyExt;
 use utils::create_callback_button;
@@ -158,11 +162,25 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
     //
+    let cmdmap: std::sync::Arc<RwLock<HashMap<_, _>>> =
+        std::sync::Arc::new(RwLock::new(bc.rc.dialog.commands));
 
     let handler = dptree::entry()
         .inspect(|u: Update| {
             info!("{u:#?}"); // Print the update to the console with inspect
         })
+        .branch(
+            Update::filter_message()
+                .filter_map(|m: Message| m.text().and_then(|t| BotCommand::from_str(t).ok()))
+                .filter_map(move |bc: BotCommand| {
+                    let rc = std::sync::Arc::clone(&cmdmap);
+
+                    let cmdmap = rc.read().expect("RwLock lock on commands map failed");
+
+                    cmdmap.get(bc.command()).cloned()
+                })
+                .endpoint(botscript_command_handler),
+        )
         .branch(
             Update::filter_callback_query()
                 .filter_async(async |q: CallbackQuery, mut db: DB| {

From 40eec7d38d64c099c4668244696a2f09787b746a Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 04:36:19 +0500
Subject: [PATCH 031/131] fix js_into: self is already a reference

---
 src/botscript.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 51375fc..c3991b4 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -37,7 +37,7 @@ pub trait DeserializeJS {
 
 impl DeserializeJS for JsValue {
     fn js_into<'a, T: Deserialize<'a>>(&'a self) -> ScriptResult<T> {
-        let rc = from_js(self.context(), &self)?;
+        let rc = from_js(self.context(), self)?;
 
         Ok(rc)
     }

From 0a60b0469f241ec1e3e0537937f1bd55d3aa32be Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 08:29:40 +0500
Subject: [PATCH 032/131] create DeserializerJS::inject_templates

---
 src/botscript.rs | 74 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index c3991b4..349b919 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,10 +1,14 @@
 use std::collections::HashMap;
 
+use itertools::Itertools;
 use quickjs_rusty::serde::from_js;
+use quickjs_rusty::utils::create_null;
 use quickjs_rusty::Context;
 use quickjs_rusty::ContextError;
 use quickjs_rusty::ExecutionError;
+use quickjs_rusty::JsFunction;
 use quickjs_rusty::OwnedJsValue as JsValue;
+use quickjs_rusty::ValueError;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -16,6 +20,8 @@ pub enum ScriptError {
     ExecutionError(#[from] ExecutionError),
     #[error("error from anyhow: {0:?}")]
     SerdeError(#[from] quickjs_rusty::serde::Error),
+    #[error("error value: {0:?}")]
+    ValueError(#[from] ValueError),
 }
 
 pub type ScriptResult<T> = Result<T, ScriptError>;
@@ -43,6 +49,74 @@ impl DeserializeJS for JsValue {
     }
 }
 
+#[derive(Default)]
+pub struct DeserializerJS {
+    fn_map: HashMap<String, JsFunction>,
+}
+
+impl DeserializerJS {
+    pub fn new() -> Self {
+        Self {
+            fn_map: HashMap::new(),
+        }
+    }
+
+    pub fn deserialize_js<'a, T: Deserialize<'a>>(value: &'a JsValue) -> ScriptResult<T> {
+        let mut s = Self::new();
+
+        s.inject_templates(value, "".to_string())?;
+
+        let res = value.js_into()?;
+
+        // val.map_functions(s.fn_map);
+
+        Ok(res)
+    }
+
+    pub fn inject_templates(
+        &mut self,
+        value: &JsValue,
+        path: String,
+    ) -> ScriptResult<Option<String>> {
+        if let Ok(f) = value.clone().try_into_function() {
+            self.fn_map.insert(path.clone(), f);
+            return Ok(Some(path));
+        } else if let Ok(o) = value.clone().try_into_object() {
+            let path = if path.is_empty() { path } else { path + "." }; // trying to avoid . in the start
+                                                                        // of stringified path
+            let res = o
+                .properties_iter()?
+                .chunks(2)
+                .into_iter()
+                // since chunks(2) is used and properties iterator over object
+                // always has even elements, unwrap will not fail
+                .map(
+                    #[allow(clippy::unwrap_used)]
+                    |mut chunk| (chunk.next().unwrap(), chunk.next().unwrap()),
+                )
+                .map(|(k, p)| k.and_then(|k| p.map(|p| (k, p))))
+                .filter_map(|m| m.ok())
+                .try_for_each(|(k, p)| {
+                    let k = match k.to_string() {
+                        Ok(k) => k,
+                        Err(err) => return Err(ScriptError::ValueError(err)),
+                    };
+                    let res = match self.inject_templates(&p, path.clone() + &k)? {
+                        Some(_) => o.set_property(&k, JsValue::new(o.context(), create_null())),
+                        None => Ok(()),
+                    };
+                    match res {
+                        Ok(res) => Ok(res),
+                        Err(err) => Err(ScriptError::ExecutionError(err)),
+                    }
+                });
+            res?;
+        };
+
+        Ok(None)
+    }
+}
+
 // TODO: remove this function since it is suitable only for early development
 #[allow(clippy::print_stdout)]
 fn print(s: String) {

From ea007127ff061ad9a23f46c0e16d3d9bd8b7c6bc Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 08:32:09 +0500
Subject: [PATCH 033/131] test for DeserializerJS::deserialize_js

---
 src/botscript.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 349b919..7f34184 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -219,6 +219,8 @@ mod tests {
         let runner = Runner::init().unwrap();
         let val = runner.run_script(include_str!("../mainbot.js")).unwrap();
         println!("config: {:?}", val);
+        let d: RunnerConfig = DeserializerJS::deserialize_js(&val).unwrap();
+        println!("desr rc: {:?}", d);
         let val = runner.run_script("start_buttons()").unwrap();
         println!("Val: {:?}", val.to_string());
     }

From 55d53bd140445fc890705259a5375dcb5f15b440 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 08:32:28 +0500
Subject: [PATCH 034/131] create keyboard struct definition with resolvement
 trait

---
 src/botscript.rs | 92 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 91 insertions(+), 1 deletion(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 7f34184..ad9bde0 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -128,7 +128,97 @@ pub struct BotConfig {
     version: f64,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+pub trait ResolveValue {
+    type Value;
+
+    fn resolve(self, runner: &Runner) -> ScriptResult<Self::Value>;
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum KeyboardDefinition {
+    Rows(Vec<RowDefinition>),
+    Function(BotFunction),
+}
+
+impl ResolveValue for KeyboardDefinition {
+    type Value = Vec<<RowDefinition as ResolveValue>::Value>;
+
+    fn resolve(self, runner: &Runner) -> ScriptResult<Self::Value> {
+        match self {
+            KeyboardDefinition::Rows(rows) => rows.into_iter().map(|r| r.resolve(runner)).collect(),
+            KeyboardDefinition::Function(f) => {
+                Self::resolve(f.call_context(runner)?.js_into()?, runner)
+            }
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum RowDefinition {
+    Buttons(Vec<ButtonDefinition>),
+    Function(BotFunction),
+}
+
+impl ResolveValue for RowDefinition {
+    type Value = Vec<<ButtonDefinition as ResolveValue>::Value>;
+
+    fn resolve(self, runner: &Runner) -> ScriptResult<Self::Value> {
+        match self {
+            RowDefinition::Buttons(buttons) => {
+                buttons.into_iter().map(|b| b.resolve(runner)).collect()
+            }
+            RowDefinition::Function(f) => Self::resolve(f.call_context(runner)?.js_into()?, runner),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum ButtonDefinition {
+    Button(ButtonRaw),
+    ButtonLiteral(String),
+    Function(BotFunction),
+}
+
+impl ResolveValue for ButtonDefinition {
+    type Value = ButtonRaw;
+
+    fn resolve(self, runner: &Runner) -> ScriptResult<Self::Value> {
+        match self {
+            ButtonDefinition::Button(button) => Ok(button),
+            ButtonDefinition::ButtonLiteral(l) => Ok(ButtonRaw::from_literal(l)),
+            ButtonDefinition::Function(f) => {
+                Self::resolve(f.call_context(runner)?.js_into()?, runner)
+            }
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ButtonRaw {
+    name: ButtonName,
+    literal: Option<String>,
+    callback_name: String,
+}
+
+impl ButtonRaw {
+    pub fn from_literal(literal: String) -> Self {
+        ButtonRaw {
+            name: ButtonName::Literal {
+                literal: literal.clone(),
+            },
+            literal: Some(literal.clone()),
+            callback_name: literal,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum ButtonName {
+    Value { name: String },
+    Literal { literal: String },
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Button {
     name: String,
 }

From a2e1354beeaa91c5968624d6ce9ad9dc11d43c13 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 08:47:23 +0500
Subject: [PATCH 035/131] fix missing #[serde(untagged)] on keyboard layout
 structs

---
 src/botscript.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index ad9bde0..803a1d4 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -135,6 +135,7 @@ pub trait ResolveValue {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
 pub enum KeyboardDefinition {
     Rows(Vec<RowDefinition>),
     Function(BotFunction),
@@ -154,6 +155,7 @@ impl ResolveValue for KeyboardDefinition {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
 pub enum RowDefinition {
     Buttons(Vec<ButtonDefinition>),
     Function(BotFunction),
@@ -173,6 +175,7 @@ impl ResolveValue for RowDefinition {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
 pub enum ButtonDefinition {
     Button(ButtonRaw),
     ButtonLiteral(String),
@@ -213,6 +216,7 @@ impl ButtonRaw {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
 pub enum ButtonName {
     Value { name: String },
     Literal { literal: String },

From bd800e88ebb6d98088ab26b96b517d9dd7d6f15f Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 08:48:34 +0500
Subject: [PATCH 036/131] create predefined buttons layout example in
 mainbot.js

---
 mainbot.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/mainbot.js b/mainbot.js
index 326b949..f53e3be 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -7,6 +7,9 @@ const dialog = {
             state: "start"
         },
         cancel: {
+            buttons: [
+                [{name: {name: "Def"}, callback_name: "defcall"}]
+            ],
             state: "none"
         },
         somecomplicatedcmd: {}

From 2c5802eaeb47bb863744b07c2c7b913140ec50c9 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 08:49:23 +0500
Subject: [PATCH 037/131] delete unnecessary literal field in ButtonRaw

---
 src/botscript.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 803a1d4..81e9c87 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -199,7 +199,6 @@ impl ResolveValue for ButtonDefinition {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ButtonRaw {
     name: ButtonName,
-    literal: Option<String>,
     callback_name: String,
 }
 
@@ -209,7 +208,6 @@ impl ButtonRaw {
             name: ButtonName::Literal {
                 literal: literal.clone(),
             },
-            literal: Some(literal.clone()),
             callback_name: literal,
         }
     }

From d1b25b52c11bc744b8c1b392a3340e496faabff7 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 08:49:52 +0500
Subject: [PATCH 038/131] fix: use KeyboardDefinition in BotMessage

---
 src/botscript.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 81e9c87..6616e60 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -228,7 +228,7 @@ pub struct Button {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BotMessage {
     // buttons: Vec<Button>
-    buttons: Option<BotFunction>,
+    buttons: Option<KeyboardDefinition>,
     state: Option<String>,
 
     handler: Option<BotFunction>,

From 2a4ed51824f6fc29d00c42320748c382e25cc780 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 20 May 2025 08:52:53 +0500
Subject: [PATCH 039/131] limit CD workflow to triger only on main branch push

---
 .gitea/workflows/cd.yaml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.gitea/workflows/cd.yaml b/.gitea/workflows/cd.yaml
index 035b78f..cd6fb6d 100644
--- a/.gitea/workflows/cd.yaml
+++ b/.gitea/workflows/cd.yaml
@@ -1,5 +1,8 @@
 name: Build && Deploy
-on: [push]
+on:
+  push:
+    branches:
+      - main
 
 jobs:
   build:

From d5f39e4e60a793f375d4cc092e77836a36cfdf79 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:11:05 +0500
Subject: [PATCH 040/131] create Parcelable trait with default implementations

---
 src/utils.rs            |   2 +
 src/utils/parcelable.rs | 110 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 112 insertions(+)
 create mode 100644 src/utils/parcelable.rs

diff --git a/src/utils.rs b/src/utils.rs
index 53f66e7..04ff503 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,3 +1,5 @@
+pub mod parcelable;
+
 use serde::{Deserialize, Serialize};
 use teloxide::types::InlineKeyboardButton;
 
diff --git a/src/utils/parcelable.rs b/src/utils/parcelable.rs
new file mode 100644
index 0000000..8e5c396
--- /dev/null
+++ b/src/utils/parcelable.rs
@@ -0,0 +1,110 @@
+use std::collections::HashMap;
+
+pub enum ParcelType<'a, F> {
+    Function(&'a mut F),
+    Parcelable(&'a mut dyn Parcelable<F>),
+    Other(()),
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum ParcelableError {
+    #[error("error to get field: {0:?}")]
+    FieldError(String),
+    #[error("error when addressing nested element: {0:?}")]
+    NestError(String),
+    #[error("error to resolve Parcelable: {0:?}")]
+    ResolveError(String),
+}
+
+pub type ParcelableResult<T> = Result<T, ParcelableError>;
+
+pub trait Parcelable<F> {
+    fn get_field(&mut self, name: &str) -> ParcelableResult<ParcelType<F>>;
+
+    fn resolve(&mut self) -> ParcelableResult<ParcelType<F>>
+    where
+        Self: Sized + 'static,
+    {
+        let root = ParcelableResult::Ok(ParcelType::Parcelable(self));
+        root
+    }
+
+    /// Get nested field by name, which is fields joined by dot
+    /// for example: passing name "field1.somefield" will be the same
+    /// as using `struct.field1.somefield`, by dynamically
+    fn get_nested(&mut self, name: &str) -> ParcelableResult<ParcelType<F>>
+    where
+        Self: Sized + 'static,
+    {
+        let root = ParcelableResult::Ok(ParcelType::Parcelable(self));
+        name.split('.')
+            .fold(root, |s: ParcelableResult<ParcelType<F>>, field| match s? {
+                ParcelType::Parcelable(p) => p.get_field(field),
+                _ => Err(ParcelableError::NestError(format!(
+                    "Failed to get field {field}. End of nestment"
+                ))),
+            })
+    }
+}
+
+impl<F> Parcelable<F> for String {
+    fn get_field(&mut self, _name: &str) -> ParcelableResult<ParcelType<F>> {
+        todo!()
+    }
+
+    fn resolve(&mut self) -> ParcelableResult<ParcelType<F>>
+    where
+        Self: Sized + 'static,
+    {
+        Ok(ParcelType::Other(()))
+    }
+}
+
+impl<F, T: Parcelable<F>> Parcelable<F> for Option<T> {
+    fn get_field(&mut self, name: &str) -> ParcelableResult<ParcelType<F>> {
+        Err(ParcelableError::FieldError(format!(
+            "tried to get field {name}, but calls of get_field are not allowed on Option"
+        )))
+    }
+
+    fn resolve(&mut self) -> crate::utils::parcelable::ParcelableResult<ParcelType<F>>
+    where
+        Self: Sized + 'static,
+    {
+        match self {
+            Some(v) => Ok(v.resolve()?),
+            None => Err(ParcelableError::ResolveError("Option was None".to_string())),
+        }
+    }
+}
+
+impl<F, V: Parcelable<F> + 'static> Parcelable<F> for HashMap<String, V> {
+    fn get_field(&mut self, name: &str) -> ParcelableResult<ParcelType<F>> {
+        match self.get_mut(name) {
+            Some(v) => Ok(Parcelable::resolve(v)?),
+            None => Err(ParcelableError::FieldError(format!(
+                "tried to get value by key {name}, but this key does not exists"
+            ))),
+        }
+    }
+}
+
+impl<F, T: Parcelable<F> + 'static> Parcelable<F> for Vec<T> {
+    fn get_field(&mut self, name: &str) -> ParcelableResult<ParcelType<F>> {
+        let index: usize = match name.parse() {
+            Ok(index) => index,
+            Err(err) => {
+                return Err(ParcelableError::FieldError(format!(
+                    "Failed to parse field name `{name}` as an array index, err: {err}"
+                )))
+            }
+        };
+        let veclen = self.len();
+        let value = match self.get_mut(index) {
+            Some(value) => value,
+            None => return Err(ParcelableError::FieldError(format!("Failed to get vec element with index {index}, probably out of bound (vec len: {veclen})"))),
+        };
+
+        Parcelable::resolve(value)
+    }
+}

From 684895a5542b9534f736dc425a1be2ef95a0f4d8 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:19:39 +0500
Subject: [PATCH 041/131] change BotFunction implementation to be compatible
 with js function injection

---
 src/botscript.rs | 52 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 50 insertions(+), 2 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 6616e60..b49a33e 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -27,14 +27,62 @@ pub enum ScriptError {
 pub type ScriptResult<T> = Result<T, ScriptError>;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct BotFunction(String); // temporal workaround
+pub struct BotFunction {
+    func: FunctionMarker,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum FunctionMarker {
+    /// serde is not able to (de)serialize this, so ignore it and fill
+    /// in runtime with injection in DeserializeJS
+    #[serde(skip)]
+    Function(JsFunction),
+    StrTemplate(String),
+}
+
+impl FunctionMarker {
+    pub fn as_str_template(&self) -> Option<&String> {
+        if let Self::StrTemplate(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+
+    pub fn as_function(&self) -> Option<&JsFunction> {
+        if let Self::Function(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+
+    pub fn set_js_function(&mut self, f: JsFunction) {
+        *self = Self::Function(f)
+    }
+}
 
 impl BotFunction {
+    pub fn by_name(name: String) -> Self {
+        Self {
+            func: FunctionMarker::StrTemplate(name),
+        }
+    }
+
     pub fn call_context(&self, runner: &Runner) -> ScriptResult<JsValue> {
-        let func_name = &self.0;
+        let func_name: &str = self
+            .func
+            .as_str_template()
+            .map(|o| o.as_str())
+            .unwrap_or("");
 
         runner.run_script(&format!("{func_name}()"))
     }
+
+    pub fn set_js_function(&mut self, f: JsFunction) {
+        self.func.set_js_function(f);
+    }
 }
 
 pub trait DeserializeJS {

From 1aed17fa30f0856eeb3b558691b9332ccf51ad70 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:21:36 +0500
Subject: [PATCH 042/131] specify ResolveValue in recursive resolve call

---
 src/botscript.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index b49a33e..540cb77 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -196,7 +196,7 @@ impl ResolveValue for KeyboardDefinition {
         match self {
             KeyboardDefinition::Rows(rows) => rows.into_iter().map(|r| r.resolve(runner)).collect(),
             KeyboardDefinition::Function(f) => {
-                Self::resolve(f.call_context(runner)?.js_into()?, runner)
+                <Self as ResolveValue>::resolve(f.call_context(runner)?.js_into()?, runner)
             }
         }
     }
@@ -217,7 +217,9 @@ impl ResolveValue for RowDefinition {
             RowDefinition::Buttons(buttons) => {
                 buttons.into_iter().map(|b| b.resolve(runner)).collect()
             }
-            RowDefinition::Function(f) => Self::resolve(f.call_context(runner)?.js_into()?, runner),
+            RowDefinition::Function(f) => {
+                <Self as ResolveValue>::resolve(f.call_context(runner)?.js_into()?, runner)
+            }
         }
     }
 }
@@ -238,7 +240,7 @@ impl ResolveValue for ButtonDefinition {
             ButtonDefinition::Button(button) => Ok(button),
             ButtonDefinition::ButtonLiteral(l) => Ok(ButtonRaw::from_literal(l)),
             ButtonDefinition::Function(f) => {
-                Self::resolve(f.call_context(runner)?.js_into()?, runner)
+                <Self as ResolveValue>::resolve(f.call_context(runner)?.js_into()?, runner)
             }
         }
     }

From ad585871606d5cffad221d58b724a91d233ed982 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:24:16 +0500
Subject: [PATCH 043/131] fix test: use BotFunction's method by_name

---
 src/botscript.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 540cb77..66bd0bf 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -384,7 +384,7 @@ mod tests {
             .run_script("function cancel_buttons() {return 'cancelation'}")
             .unwrap();
 
-        let f = BotFunction("cancel_buttons".to_string());
+        let f = BotFunction::by_name("cancel_buttons".to_string());
         let res = f.call_context(&runner).unwrap();
 
         println!("RES: {res:?}");

From b76392d597a68b3f0e24eff2642015ebe67944fa Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:26:09 +0500
Subject: [PATCH 044/131] impl Parcelable for all RunnerConfig types

---
 src/botscript.rs | 107 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 66bd0bf..ac4aae7 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 
+use crate::utils::parcelable::{ParcelType, Parcelable, ParcelableError, ParcelableResult};
 use itertools::Itertools;
 use quickjs_rusty::serde::from_js;
 use quickjs_rusty::utils::create_null;
@@ -63,6 +64,22 @@ impl FunctionMarker {
     }
 }
 
+impl Parcelable<Self> for BotFunction {
+    fn get_field(
+        &mut self,
+        _name: &str,
+    ) -> crate::utils::parcelable::ParcelableResult<ParcelType<Self>> {
+        todo!()
+    }
+
+    fn resolve(&mut self) -> ParcelableResult<ParcelType<Self>>
+    where
+        Self: Sized + 'static,
+    {
+        Ok(ParcelType::Function(self))
+    }
+}
+
 impl BotFunction {
     pub fn by_name(name: String) -> Self {
         Self {
@@ -189,6 +206,21 @@ pub enum KeyboardDefinition {
     Function(BotFunction),
 }
 
+impl Parcelable<BotFunction> for KeyboardDefinition {
+    fn get_field(&mut self, _name: &str) -> ParcelableResult<ParcelType<BotFunction>> {
+        todo!()
+    }
+    fn resolve(&mut self) -> ParcelableResult<ParcelType<BotFunction>>
+    where
+        Self: Sized + 'static,
+    {
+        match self {
+            KeyboardDefinition::Rows(rows) => Ok(rows.resolve()?),
+            KeyboardDefinition::Function(f) => Ok(f.resolve()?),
+        }
+    }
+}
+
 impl ResolveValue for KeyboardDefinition {
     type Value = Vec<<RowDefinition as ResolveValue>::Value>;
 
@@ -209,6 +241,21 @@ pub enum RowDefinition {
     Function(BotFunction),
 }
 
+impl Parcelable<BotFunction> for RowDefinition {
+    fn get_field(&mut self, _name: &str) -> ParcelableResult<ParcelType<BotFunction>> {
+        todo!()
+    }
+    fn resolve(&mut self) -> ParcelableResult<ParcelType<BotFunction>>
+    where
+        Self: Sized + 'static,
+    {
+        match self {
+            Self::Buttons(buttons) => Ok(buttons.resolve()?),
+            Self::Function(f) => Ok(f.resolve()?),
+        }
+    }
+}
+
 impl ResolveValue for RowDefinition {
     type Value = Vec<<ButtonDefinition as ResolveValue>::Value>;
 
@@ -246,12 +293,34 @@ impl ResolveValue for ButtonDefinition {
     }
 }
 
+impl Parcelable<BotFunction> for ButtonDefinition {
+    fn get_field(&mut self, _name: &str) -> ParcelableResult<ParcelType<BotFunction>> {
+        todo!()
+    }
+    fn resolve(&mut self) -> ParcelableResult<ParcelType<BotFunction>>
+    where
+        Self: Sized + 'static,
+    {
+        match self {
+            Self::Button(braw) => Ok(braw.resolve()?),
+            Self::ButtonLiteral(s) => Ok(s.resolve()?),
+            Self::Function(f) => Ok(f.resolve()?),
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ButtonRaw {
     name: ButtonName,
     callback_name: String,
 }
 
+impl<F> Parcelable<F> for ButtonRaw {
+    fn get_field(&mut self, _name: &str) -> ParcelableResult<ParcelType<F>> {
+        todo!()
+    }
+}
+
 impl ButtonRaw {
     pub fn from_literal(literal: String) -> Self {
         ButtonRaw {
@@ -284,18 +353,56 @@ pub struct BotMessage {
     handler: Option<BotFunction>,
 }
 
+impl Parcelable<BotFunction> for BotMessage {
+    fn get_field(&mut self, name: &str) -> ParcelableResult<ParcelType<BotFunction>> {
+        match name {
+            "buttons" => Ok(self.buttons.resolve()?),
+            "state" => Ok(self.state.resolve()?),
+            "handler" => Ok(self.handler.resolve()?),
+            field => Err(ParcelableError::FieldError(format!(
+                "tried to get field {field}, but this field does not exists or private"
+            ))),
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct BotDialog {
     pub commands: HashMap<String, BotMessage>,
     stateful_msg_handlers: HashMap<String, BotMessage>,
 }
 
+impl Parcelable<BotFunction> for BotDialog {
+    fn get_field(&mut self, name: &str) -> Result<ParcelType<BotFunction>, ParcelableError> {
+        match name {
+            "commands" => Ok(ParcelType::Parcelable(&mut self.commands)),
+            "stateful_msg_handlersommands" => {
+                Ok(ParcelType::Parcelable(&mut self.stateful_msg_handlers))
+            }
+            field => Err(ParcelableError::FieldError(format!(
+                "tried to get field {field}, but this field does not exists or private"
+            ))),
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct RunnerConfig {
     config: BotConfig,
     pub dialog: BotDialog,
 }
 
+impl Parcelable<BotFunction> for RunnerConfig {
+    fn get_field(&mut self, name: &str) -> Result<ParcelType<BotFunction>, ParcelableError> {
+        match name {
+            "dialog" => Ok(ParcelType::Parcelable(&mut self.dialog)),
+            field => Err(ParcelableError::FieldError(format!(
+                "tried to get field {field}, but this field does not exists or private"
+            ))),
+        }
+    }
+}
+
 pub struct Runner {
     context: Context,
 }

From 6ea26c0618b7e0dff0339f0d6e50882e3f096099 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:27:27 +0500
Subject: [PATCH 045/131] change injectable template in DeserializeJS to
 correct one

---
 src/botscript.rs | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index ac4aae7..03941ec 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -3,7 +3,8 @@ use std::collections::HashMap;
 use crate::utils::parcelable::{ParcelType, Parcelable, ParcelableError, ParcelableResult};
 use itertools::Itertools;
 use quickjs_rusty::serde::from_js;
-use quickjs_rusty::utils::create_null;
+use quickjs_rusty::utils::create_empty_object;
+use quickjs_rusty::utils::create_string;
 use quickjs_rusty::Context;
 use quickjs_rusty::ContextError;
 use quickjs_rusty::ExecutionError;
@@ -167,7 +168,24 @@ impl DeserializerJS {
                         Err(err) => return Err(ScriptError::ValueError(err)),
                     };
                     let res = match self.inject_templates(&p, path.clone() + &k)? {
-                        Some(_) => o.set_property(&k, JsValue::new(o.context(), create_null())),
+                        Some(_) => {
+                            let fo = JsValue::new(
+                                o.context(),
+                                create_empty_object(o.context()).expect("couldn't create object"),
+                            )
+                            .try_into_object()
+                            .expect("the object created was not an object :/");
+                            fo.set_property(
+                                "func",
+                                JsValue::new(
+                                    o.context(),
+                                    create_string(o.context(), "somefunc")
+                                        .expect("couldn't create string"),
+                                ),
+                            )
+                            .expect("wasn't able to set property on object :/");
+                            o.set_property(&k, fo.into_value())
+                        }
                         None => Ok(()),
                     };
                     match res {

From 6fa398401d3d4e5d35d277122afd9c4e6e3d74cf Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:28:24 +0500
Subject: [PATCH 046/131] restore functions in deserialize_js

---
 src/botscript.rs | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 03941ec..00c5dbf 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -127,14 +127,28 @@ impl DeserializerJS {
         }
     }
 
-    pub fn deserialize_js<'a, T: Deserialize<'a>>(value: &'a JsValue) -> ScriptResult<T> {
+    pub fn deserialize_js<'a, T: Deserialize<'a> + Parcelable<BotFunction> + 'static>(
+        value: &'a JsValue,
+    ) -> ScriptResult<T> {
         let mut s = Self::new();
 
         s.inject_templates(value, "".to_string())?;
 
-        let res = value.js_into()?;
+        let mut res = value.js_into()?;
 
-        // val.map_functions(s.fn_map);
+        for (k, jsf) in s.fn_map {
+            let item: ParcelType<'_, BotFunction> =
+                match Parcelable::<BotFunction>::get_nested(&mut res, &k) {
+                    Ok(item) => item,
+                    Err(err) => {
+                        log::error!("Failed to inject original functions to structs, error: {err}");
+                        continue;
+                    }
+                };
+            if let ParcelType::Function(f) = item {
+                f.set_js_function(jsf);
+            }
+        }
 
         Ok(res)
     }

From a4e8ea0390a3175326c9cd65676a04736dda2c5e Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:28:56 +0500
Subject: [PATCH 047/131] mainbot.js: use function in `buttons` field instead
 of function name

---
 mainbot.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mainbot.js b/mainbot.js
index f53e3be..7e1fb9c 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -3,7 +3,7 @@
 const dialog = {
     commands: {
         start: {
-            buttons: "start_buttons", // default is `null`
+            buttons: start_buttons, // default is `null`
             state: "start"
         },
         cancel: {

From f5a894fe37afb74f0a1f52e7fceaa99e1fe0bb0b Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:31:43 +0500
Subject: [PATCH 048/131] mainbot.js: change comment style for handler example

---
 mainbot.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/mainbot.js b/mainbot.js
index 7e1fb9c..5c30f75 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -20,9 +20,10 @@ const dialog = {
     stateful_msg_handlers: {
         start: {}, // everything is by default, so just send message `start`
         enter_name: {
-            handler: "enter_name", // name of the handler function. This field has a
-                                   // side effect: when is set, no automatic sending
-                                   // of message, should be sent manually in handler
+            // name of the handler function. This field has a side effect:
+            // when is set, no automatic sending of message, should be sent
+            // manually in handler
+            handler: "enter_name",
             state: "none"
         },
     },

From a15cdeadf9f3655b6090567399402eb68ce7f0e9 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:32:45 +0500
Subject: [PATCH 049/131] mainbot.js: create example function enter_name

---
 mainbot.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/mainbot.js b/mainbot.js
index 5c30f75..7762b7b 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -29,6 +29,8 @@ const dialog = {
     },
 }
 
+function enter_name() {}
+
 const fmt = (number) => number.toString().padStart(2, '0');
 
 const formatDate = (date) => {

From 940a832561cb8cce7c3fa6586a93286615571751 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:33:03 +0500
Subject: [PATCH 050/131] mainbot.js: use function in handler instead of string
 function name

---
 mainbot.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mainbot.js b/mainbot.js
index 7762b7b..91a5450 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -23,7 +23,7 @@ const dialog = {
             // name of the handler function. This field has a side effect:
             // when is set, no automatic sending of message, should be sent
             // manually in handler
-            handler: "enter_name",
+            handler: enter_name,
             state: "none"
         },
     },

From 970ce07280c8ced011edb79713fb46e9789c163c Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:41:04 +0500
Subject: [PATCH 051/131] fix name of stateful_msg_handlers in Parcelable field
 getter

---
 src/botscript.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 00c5dbf..4461340 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -408,9 +408,7 @@ impl Parcelable<BotFunction> for BotDialog {
     fn get_field(&mut self, name: &str) -> Result<ParcelType<BotFunction>, ParcelableError> {
         match name {
             "commands" => Ok(ParcelType::Parcelable(&mut self.commands)),
-            "stateful_msg_handlersommands" => {
-                Ok(ParcelType::Parcelable(&mut self.stateful_msg_handlers))
-            }
+            "stateful_msg_handlers" => Ok(ParcelType::Parcelable(&mut self.stateful_msg_handlers)),
             field => Err(ParcelableError::FieldError(format!(
                 "tried to get field {field}, but this field does not exists or private"
             ))),

From 0dc71fda08ff4c7e65a533e9292438c3bb350354 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:46:46 +0500
Subject: [PATCH 052/131] fix BotFunction's call_context method

previously called by stored template string instead of actual function
---
 src/botscript.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 4461340..b961002 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -89,13 +89,13 @@ impl BotFunction {
     }
 
     pub fn call_context(&self, runner: &Runner) -> ScriptResult<JsValue> {
-        let func_name: &str = self
-            .func
-            .as_str_template()
-            .map(|o| o.as_str())
-            .unwrap_or("");
-
-        runner.run_script(&format!("{func_name}()"))
+        match &self.func {
+            FunctionMarker::Function(f) => {
+                let val = f.call(Default::default())?;
+                Ok(val)
+            }
+            FunctionMarker::StrTemplate(func_name) => runner.run_script(&format!("{func_name}()")),
+        }
     }
 
     pub fn set_js_function(&mut self, f: JsFunction) {

From d1b6d153d4ed57b0ff9a3df1f4f5ac76c6119d06 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 12:53:26 +0500
Subject: [PATCH 053/131] create call and call_args methods for BotFunction

---
 src/botscript.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index b961002..f52ab6c 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -24,6 +24,8 @@ pub enum ScriptError {
     SerdeError(#[from] quickjs_rusty::serde::Error),
     #[error("error value: {0:?}")]
     ValueError(#[from] ValueError),
+    #[error("error bot function execution: {0:?}")]
+    BotFunctionError(String),
 }
 
 pub type ScriptResult<T> = Result<T, ScriptError>;
@@ -98,6 +100,21 @@ impl BotFunction {
         }
     }
 
+    pub fn call(&self) -> ScriptResult<JsValue> {
+        self.call_args(Default::default())
+    }
+
+    pub fn call_args(&self, args: Vec<JsValue>) -> ScriptResult<JsValue> {
+        if let FunctionMarker::Function(f) = &self.func {
+            let val = f.call(args)?;
+            Ok(val)
+        } else {
+            Err(ScriptError::BotFunctionError(
+                "Js Function is not defined".to_string(),
+            ))
+        }
+    }
+
     pub fn set_js_function(&mut self, f: JsFunction) {
         self.func.set_js_function(f);
     }

From c33c67044a3119142fe368aba42cf59c8e9dd6bf Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 13:04:08 +0500
Subject: [PATCH 054/131] delete test test_deserialization_main, since it isnot
 actual anymore

---
 src/botscript.rs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index f52ab6c..1189369 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -521,16 +521,6 @@ mod tests {
         println!("Val: {:?}", val.to_string());
     }
 
-    #[test]
-    fn test_deserialization_main() {
-        let runner = Runner::init().unwrap();
-        let val = runner.run_script(include_str!("../mainbot.js")).unwrap();
-        let s: RunnerConfig = from_js(unsafe { runner.context.context_raw() }, &val).unwrap();
-        println!("deser: {:#?}", s);
-        let o = val.try_into_object().unwrap();
-        println!("o: {:?}", recursive_format(o));
-    }
-
     #[test]
     fn test_func_deserialization_main() {
         let runner = Runner::init().unwrap();

From ca2e661a0efafda86c7f79a09d3224db0ad632e8 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 14:06:09 +0500
Subject: [PATCH 055/131] fix: in Runner's init_config use deserialize_js
 instead of js_into

---
 src/botscript.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 1189369..7ef97ae 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -479,7 +479,7 @@ impl Runner {
         let val = self.run_script(content)?;
 
         // let rc: RunnerConfig = from_js(unsafe { self.context.context_raw() }, &val)?;
-        let rc: RunnerConfig = val.js_into()?;
+        let rc: RunnerConfig = DeserializerJS::deserialize_js(&val)?;
 
         Ok(rc)
     }

From d174ee7bc7f9bd7ed195b58f83888e0a7a744c2e Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 21 May 2025 14:07:02 +0500
Subject: [PATCH 056/131] fix: handle Runner in BotController

reason: earlier, Runner and js runtime in it were freed after init of
BotController, which potentially was able to lead into hanging function
in config without runtime, BUT, there is check in in JS_FreeRuntime to
have zero objects, so bug found without hesitation ;)
---
 src/main.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 4a81130..689b5f5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -105,6 +105,7 @@ pub struct BotController {
     pub bot: Bot,
     pub db: DB,
     pub rc: RunnerConfig,
+    pub runner: Runner,
 }
 
 impl BotController {
@@ -112,9 +113,15 @@ impl BotController {
         let bot = Bot::new(&config.bot_token);
         let db = DB::init(&config.db_url).await?;
 
-        let rc = Runner::init()?.init_config(include_str!("../mainbot.js"))?;
+        let runner = Runner::init()?;
+        let rc = runner.init_config(include_str!("../mainbot.js"))?;
 
-        Ok(Self { bot, db, rc })
+        Ok(Self {
+            bot,
+            db,
+            rc,
+            runner,
+        })
     }
 }
 

From 99758500b34fe1fc9ee8f921c7346aba93b5271f Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 15:28:41 +0500
Subject: [PATCH 057/131] fix mainbot.js: start_buttons: return actual buttons

---
 mainbot.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/mainbot.js b/mainbot.js
index 91a5450..a7ed9ca 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -49,7 +49,10 @@ function start_buttons() {
     const dateFormated = formatDate(now);
 
     // return 1
-    return dateFormated
+    return [
+        [{name: {name: dateFormated}, callback_name: "no"}],
+        [{name: {name: "Hello!"}, callback_name: "no"}],
+    ]
 }
 
 const config = {

From 1117af0724c4c863870696965f7b54cadd1acca4 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 15:49:30 +0500
Subject: [PATCH 058/131] impl ButtonName.resolve_name

---
 src/botscript.rs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 7ef97ae..3963ed5 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -388,6 +388,24 @@ pub enum ButtonName {
     Literal { literal: String },
 }
 
+impl ButtonName {
+    pub async fn resolve_name(self, db: &mut DB) -> ScriptResult<String> {
+        match self {
+            ButtonName::Value { name } => Ok(name),
+            ButtonName::Literal { literal } => {
+                let value = db.get_literal_value(&literal).await?;
+
+                Ok(match value {
+                    Some(value) => Ok(value),
+                    None => Err(ResolveError::IncorrectLiteral(format!(
+                        "not found literal `{literal}` in DB"
+                    ))),
+                }?)
+            }
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Button {
     name: String,

From 66180e0cfb9efcb88c8cab0fdb6ddb40baf5464b Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:03:12 +0500
Subject: [PATCH 059/131] add optional literal string in BotMessage

---
 src/botscript.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 3963ed5..c6e7a78 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -414,6 +414,7 @@ pub struct Button {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BotMessage {
     // buttons: Vec<Button>
+    literal: Option<String>,
     buttons: Option<KeyboardDefinition>,
     state: Option<String>,
 

From f8c63e5315fa8b84306b9346dca20f88683909cb Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:04:03 +0500
Subject: [PATCH 060/131] create BotMessage.fill_literal method

---
 src/botscript.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index c6e7a78..a14dec1 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -421,6 +421,15 @@ pub struct BotMessage {
     handler: Option<BotFunction>,
 }
 
+impl BotMessage {
+    pub fn fill_literal(&self, l: String) -> Self {
+        BotMessage {
+            literal: self.clone().literal.or(Some(l)),
+            ..self.clone()
+        }
+    }
+}
+
 impl Parcelable<BotFunction> for BotMessage {
     fn get_field(&mut self, name: &str) -> ParcelableResult<ParcelType<BotFunction>> {
         match name {

From cbb9c0c335d6a21a56bddf0c6081794e09db908d Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:13:56 +0500
Subject: [PATCH 061/131] botscript: create ButtonLayout enum

---
 src/botscript.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index a14dec1..4504dd2 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -430,6 +430,14 @@ impl BotMessage {
     }
 }
 
+pub enum ButtonLayout {
+    Callback {
+        name: String,
+        literal: Option<String>,
+        callback: String,
+    },
+}
+
 impl Parcelable<BotFunction> for BotMessage {
     fn get_field(&mut self, name: &str) -> ParcelableResult<ParcelType<BotFunction>> {
         match name {

From 6d5f748ab8bb9b5af874b9bac99237ddf3de478f Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:15:44 +0500
Subject: [PATCH 062/131] create ButtonLayout::resolve_raw

---
 src/botscript.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 4504dd2..b1439ad 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -438,6 +438,19 @@ pub enum ButtonLayout {
     },
 }
 
+impl ButtonLayout {
+    pub async fn resolve_raw(braw: ButtonRaw, db: &mut DB) -> ScriptResult<Self> {
+        let name = braw.name().clone().resolve_name(db).await?;
+        let literal = braw.literal();
+        let callback = braw.callback_name().to_string();
+        Ok(Self::Callback {
+            name,
+            literal,
+            callback,
+        })
+    }
+}
+
 impl Parcelable<BotFunction> for BotMessage {
     fn get_field(&mut self, name: &str) -> ParcelableResult<ParcelType<BotFunction>> {
         match name {

From 506fdcb26032e7c7f3fb9ef5b2e297fc8a15ac41 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:19:37 +0500
Subject: [PATCH 063/131] create BotMessage.resolve_buttons

---
 src/botscript.rs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index b1439ad..7428084 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -430,6 +430,33 @@ impl BotMessage {
     }
 }
 
+impl BotMessage {
+    pub async fn resolve_buttons(
+        &self,
+        db: &mut DB,
+    ) -> ScriptResult<Option<Vec<Vec<ButtonLayout>>>> {
+        let raw_buttons = self.buttons.clone().map(|b| b.resolve()).transpose()?;
+        match raw_buttons {
+            Some(braws) => {
+                let kbd: Vec<Vec<_>> = join_all(braws.into_iter().map(|rows| async {
+                    join_all(rows.into_iter().map(|b| async {
+                        let mut db = db.clone();
+                        ButtonLayout::resolve_raw(b, &mut db).await
+                    }))
+                    .await
+                    .into_iter()
+                    .collect()
+                }))
+                .await
+                .into_iter()
+                .collect::<Result<_, _>>()?;
+                Ok(Some(kbd))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
 pub enum ButtonLayout {
     Callback {
         name: String,

From 1730107e9affc4a1e0c9e6b6fc65a7502faf60ed Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:20:21 +0500
Subject: [PATCH 064/131] create BotMessage.literal getter

---
 src/botscript.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 7428084..379d1a2 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -455,6 +455,10 @@ impl BotMessage {
             None => Ok(None),
         }
     }
+
+    pub fn literal(&self) -> Option<&String> {
+        self.literal.as_ref()
+    }
 }
 
 pub enum ButtonLayout {

From 178f2a2399f1951f63d6b70257a0b94b0658d28f Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:21:26 +0500
Subject: [PATCH 065/131] create ButtonRaw name, callback_name and literal
 getters

---
 src/botscript.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 379d1a2..b5e98b8 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -379,6 +379,21 @@ impl ButtonRaw {
             callback_name: literal,
         }
     }
+
+    pub fn name(&self) -> &ButtonName {
+        &self.name
+    }
+
+    pub fn callback_name(&self) -> &str {
+        &self.callback_name
+    }
+
+    pub fn literal(&self) -> Option<String> {
+        match self.name() {
+            ButtonName::Value { .. } => None,
+            ButtonName::Literal { literal } => Some(literal.to_string()),
+        }
+    }
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]

From 9e35f4168e1ea4c2e95cce2644199370ea7e1860 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:23:12 +0500
Subject: [PATCH 066/131] use DB and join_all

---
 src/botscript.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index b5e98b8..aa7104e 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,6 +1,8 @@
 use std::collections::HashMap;
 
+use crate::db::{CallDB, DbError, DB};
 use crate::utils::parcelable::{ParcelType, Parcelable, ParcelableError, ParcelableResult};
+use futures::future::join_all;
 use itertools::Itertools;
 use quickjs_rusty::serde::from_js;
 use quickjs_rusty::utils::create_empty_object;

From 1c17639c0edd459a508b1b07831c48a1a676c069 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:23:54 +0500
Subject: [PATCH 067/131] handle DbError in ScriptError

---
 src/botscript.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index aa7104e..313de3d 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -28,6 +28,8 @@ pub enum ScriptError {
     ValueError(#[from] ValueError),
     #[error("error bot function execution: {0:?}")]
     BotFunctionError(String),
+    #[error("error from DB: {0:?}")]
+    DBError(#[from] DbError),
 }
 
 pub type ScriptResult<T> = Result<T, ScriptError>;

From 217a074c957ae965497a1ca2e04c255aa5599b4c Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:24:17 +0500
Subject: [PATCH 068/131] create ResolveError

---
 src/botscript.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 313de3d..7027025 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -30,6 +30,14 @@ pub enum ScriptError {
     BotFunctionError(String),
     #[error("error from DB: {0:?}")]
     DBError(#[from] DbError),
+    #[error("error resolving data: {0:?}")]
+    ResolveError(#[from] ResolveError),
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum ResolveError {
+    #[error("wrong literal: {0:?}")]
+    IncorrectLiteral(String),
 }
 
 pub type ScriptResult<T> = Result<T, ScriptError>;

From 31e78be68fc5f5c07ce5d802ffc9ec9ecf9013d1 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:26:35 +0500
Subject: [PATCH 069/131] change interface for ResolveValue

---
 src/botscript.rs | 50 +++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 11 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 7027025..81dc3ac 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -257,7 +257,8 @@ pub struct BotConfig {
 pub trait ResolveValue {
     type Value;
 
-    fn resolve(self, runner: &Runner) -> ScriptResult<Self::Value>;
+    fn resolve(self) -> ScriptResult<Self::Value>;
+    fn resolve_with(self, runner: &Runner) -> ScriptResult<Self::Value>;
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -285,11 +286,22 @@ impl Parcelable<BotFunction> for KeyboardDefinition {
 impl ResolveValue for KeyboardDefinition {
     type Value = Vec<<RowDefinition as ResolveValue>::Value>;
 
-    fn resolve(self, runner: &Runner) -> ScriptResult<Self::Value> {
+    fn resolve(self) -> ScriptResult<Self::Value> {
         match self {
-            KeyboardDefinition::Rows(rows) => rows.into_iter().map(|r| r.resolve(runner)).collect(),
+            KeyboardDefinition::Rows(rows) => rows.into_iter().map(|r| r.resolve()).collect(),
             KeyboardDefinition::Function(f) => {
-                <Self as ResolveValue>::resolve(f.call_context(runner)?.js_into()?, runner)
+                <Self as ResolveValue>::resolve(f.call()?.js_into()?)
+            }
+        }
+    }
+
+    fn resolve_with(self, runner: &Runner) -> ScriptResult<Self::Value> {
+        match self {
+            KeyboardDefinition::Rows(rows) => {
+                rows.into_iter().map(|r| r.resolve_with(runner)).collect()
+            }
+            KeyboardDefinition::Function(f) => {
+                <Self as ResolveValue>::resolve_with(f.call_context(runner)?.js_into()?, runner)
             }
         }
     }
@@ -320,13 +332,21 @@ impl Parcelable<BotFunction> for RowDefinition {
 impl ResolveValue for RowDefinition {
     type Value = Vec<<ButtonDefinition as ResolveValue>::Value>;
 
-    fn resolve(self, runner: &Runner) -> ScriptResult<Self::Value> {
+    fn resolve(self) -> ScriptResult<Self::Value> {
         match self {
-            RowDefinition::Buttons(buttons) => {
-                buttons.into_iter().map(|b| b.resolve(runner)).collect()
-            }
+            RowDefinition::Buttons(buttons) => buttons.into_iter().map(|b| b.resolve()).collect(),
+            RowDefinition::Function(f) => <Self as ResolveValue>::resolve(f.call()?.js_into()?),
+        }
+    }
+
+    fn resolve_with(self, runner: &Runner) -> ScriptResult<Self::Value> {
+        match self {
+            RowDefinition::Buttons(buttons) => buttons
+                .into_iter()
+                .map(|b| b.resolve_with(runner))
+                .collect(),
             RowDefinition::Function(f) => {
-                <Self as ResolveValue>::resolve(f.call_context(runner)?.js_into()?, runner)
+                <Self as ResolveValue>::resolve_with(f.call_context(runner)?.js_into()?, runner)
             }
         }
     }
@@ -343,12 +363,20 @@ pub enum ButtonDefinition {
 impl ResolveValue for ButtonDefinition {
     type Value = ButtonRaw;
 
-    fn resolve(self, runner: &Runner) -> ScriptResult<Self::Value> {
+    fn resolve(self) -> ScriptResult<Self::Value> {
+        match self {
+            ButtonDefinition::Button(button) => Ok(button),
+            ButtonDefinition::ButtonLiteral(l) => Ok(ButtonRaw::from_literal(l)),
+            ButtonDefinition::Function(f) => <Self as ResolveValue>::resolve(f.call()?.js_into()?),
+        }
+    }
+
+    fn resolve_with(self, runner: &Runner) -> ScriptResult<Self::Value> {
         match self {
             ButtonDefinition::Button(button) => Ok(button),
             ButtonDefinition::ButtonLiteral(l) => Ok(ButtonRaw::from_literal(l)),
             ButtonDefinition::Function(f) => {
-                <Self as ResolveValue>::resolve(f.call_context(runner)?.js_into()?, runner)
+                <Self as ResolveValue>::resolve_with(f.call_context(runner)?.js_into()?, runner)
             }
         }
     }

From 1ff86f641fe9cd7b8cc04034637639f9095000e4 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:27:06 +0500
Subject: [PATCH 070/131] impl RunnerConfig::get_command_message

---
 src/botscript.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 81dc3ac..f455f8c 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -574,6 +574,15 @@ pub struct RunnerConfig {
     pub dialog: BotDialog,
 }
 
+impl RunnerConfig {
+    /// command without starting `/`
+    pub fn get_command_message(&self, command: &str) -> Option<BotMessage> {
+        let bm = self.dialog.commands.get(command).cloned();
+
+        bm.map(|bm| bm.fill_literal(command.to_string()))
+    }
+}
+
 impl Parcelable<BotFunction> for RunnerConfig {
     fn get_field(&mut self, name: &str) -> Result<ParcelType<BotFunction>, ParcelableError> {
         match name {

From e8dbf3db7654a25aa9b6bd62130e3e3215814198 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:29:54 +0500
Subject: [PATCH 071/131] access RunnerConfig instead of manually using
 commands hash map

---
 src/main.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 689b5f5..cccbd00 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,7 +12,6 @@ use db::callback_info::CallbackInfo;
 use db::message_forward::MessageForward;
 use itertools::Itertools;
 use log::{error, info, warn};
-use std::collections::HashMap;
 use std::str::FromStr;
 use std::sync::RwLock;
 use std::time::Duration;
@@ -169,8 +168,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
     //
-    let cmdmap: std::sync::Arc<RwLock<HashMap<_, _>>> =
-        std::sync::Arc::new(RwLock::new(bc.rc.dialog.commands));
+    let rc: std::sync::Arc<RwLock<RunnerConfig>> = std::sync::Arc::new(RwLock::new(bc.rc));
 
     let handler = dptree::entry()
         .inspect(|u: Update| {
@@ -180,11 +178,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             Update::filter_message()
                 .filter_map(|m: Message| m.text().and_then(|t| BotCommand::from_str(t).ok()))
                 .filter_map(move |bc: BotCommand| {
-                    let rc = std::sync::Arc::clone(&cmdmap);
+                    let rc = std::sync::Arc::clone(&rc);
+                    let command = bc.command();
 
-                    let cmdmap = rc.read().expect("RwLock lock on commands map failed");
+                    let rc = rc.read().expect("RwLock lock on commands map failed");
 
-                    cmdmap.get(bc.command()).cloned()
+                    rc.get_command_message(command)
                 })
                 .endpoint(botscript_command_handler),
         )

From 4548419946daabe6f866d3bbd1f0302d16c2d6bd Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Fri, 23 May 2025 16:35:46 +0500
Subject: [PATCH 072/131] implement botscript_command_handler

---
 src/main.rs | 32 ++++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index cccbd00..c15f014 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,7 +5,7 @@ pub mod db;
 pub mod mongodb_storage;
 pub mod utils;
 
-use botscript::{BotMessage, Runner, RunnerConfig};
+use botscript::{BotMessage, Runner, RunnerConfig, ScriptError};
 use commands::BotCommand;
 use db::application::Application;
 use db::callback_info::CallbackInfo;
@@ -133,6 +133,7 @@ pub enum BotError {
     MsgTooOld(String),
     BotLogicError(String),
     AdminMisconfiguration(String),
+    ScriptError(#[from] ScriptError),
 }
 
 pub type BotResult<T> = Result<T, BotError>;
@@ -254,8 +255,35 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-async fn botscript_command_handler(bot: Bot, bm: BotMessage) -> BotResult<()> {
+async fn botscript_command_handler(
+    bot: Bot,
+    mut db: DB,
+    bm: BotMessage,
+    msg: Message,
+) -> BotResult<()> {
     info!("Eval BM: {:?}", bm);
+    let buttons = bm
+        .resolve_buttons(&mut db)
+        .await?
+        .map(|buttons| InlineKeyboardMarkup {
+            inline_keyboard: buttons
+                .iter()
+                .map(|r| {
+                    r.iter()
+                        .map(|b| match b {
+                            botscript::ButtonLayout::Callback {
+                                name,
+                                literal: _,
+                                callback,
+                            } => InlineKeyboardButton::callback(name, callback),
+                        })
+                        .collect()
+                })
+                .collect(),
+        });
+    let literal = bm.literal().map_or("", |s| s.as_str());
+
+    answer_message_varianted(&bot, msg.chat.id.0, &mut db, literal, None, buttons).await?;
 
     Ok(())
 }

From d5dbaa0b7530ccf0712f73856894da4799927294 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sun, 25 May 2025 09:40:41 +0500
Subject: [PATCH 073/131] refactor message answer and replace

---
 src/main.rs             | 389 +++++-----------------------------------
 src/message_answerer.rs | 302 +++++++++++++++++++++++++++++++
 2 files changed, 351 insertions(+), 340 deletions(-)
 create mode 100644 src/message_answerer.rs

diff --git a/src/main.rs b/src/main.rs
index c15f014..8ef3f30 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,6 +2,7 @@ pub mod admin;
 pub mod botscript;
 pub mod commands;
 pub mod db;
+pub mod message_answerer;
 pub mod mongodb_storage;
 pub mod utils;
 
@@ -12,6 +13,7 @@ use db::callback_info::CallbackInfo;
 use db::message_forward::MessageForward;
 use itertools::Itertools;
 use log::{error, info, warn};
+use message_answerer::MessageAnswerer;
 use std::str::FromStr;
 use std::sync::RwLock;
 use std::time::Duration;
@@ -283,7 +285,8 @@ async fn botscript_command_handler(
         });
     let literal = bm.literal().map_or("", |s| s.as_str());
 
-    answer_message_varianted(&bot, msg.chat.id.0, &mut db, literal, None, buttons).await?;
+    let ma = MessageAnswerer::new(&bot, &mut db, msg.chat.id.0);
+    ma.answer(literal, None, buttons).await?;
 
     Ok(())
 }
@@ -486,22 +489,18 @@ async fn callback_handler(bot: Bot, mut db: DB, q: CallbackQuery) -> BotResult<(
                 create_callback_button("go_home", Callback::GoHome, &mut db).await?
             ));
 
-            replace_message(
-                &bot,
-                &mut db,
-                q.chat_id().map(|i| i.0).unwrap_or(q.from.id.0 as i64),
-                q.message.map_or_else(
-                    || {
-                        Err(BotError::MsgTooOld(
-                            "Failed to get message id, probably message too old".to_string(),
-                        ))
-                    },
-                    |m| Ok(m.id().0),
-                )?,
-                "more_info_msg",
-                keyboard,
-            )
-            .await?
+            let chat_id = q.chat_id().map(|i| i.0).unwrap_or(q.from.id.0 as i64);
+            let message_id = q.message.map_or_else(
+                || {
+                    Err(BotError::MsgTooOld(
+                        "Failed to get message id, probably message too old".to_string(),
+                    ))
+                },
+                |m| Ok(m.id().0),
+            )?;
+            MessageAnswerer::new(&bot, &mut db, chat_id)
+                .replace_message(message_id, "more_info_msg", keyboard)
+                .await?
         }
         Callback::ProjectPage { id } => {
             let nextproject = match db
@@ -538,68 +537,50 @@ async fn callback_handler(bot: Bot, mut db: DB, q: CallbackQuery) -> BotResult<(
                 [create_callback_button("go_home", Callback::GoHome, &mut db).await?]
             );
 
-            replace_message(
-                &bot,
-                &mut db,
-                q.chat_id().map(|i| i.0).unwrap_or(q.from.id.0 as i64),
-                q.message.map_or_else(
-                    || {
-                        Err(BotError::MsgTooOld(
-                            "Failed to get message id, probably message too old".to_string(),
-                        ))
-                    },
-                    |m| Ok(m.id().0),
-                )?,
-                &format!("project_{}_msg", id),
-                Some(keyboard),
-            )
-            .await?
+            let chat_id = q.chat_id().map(|i| i.0).unwrap_or(q.from.id.0 as i64);
+            let message_id = q.message.map_or_else(
+                || {
+                    Err(BotError::MsgTooOld(
+                        "Failed to get message id, probably message too old".to_string(),
+                    ))
+                },
+                |m| Ok(m.id().0),
+            )?;
+            MessageAnswerer::new(&bot, &mut db, chat_id)
+                .replace_message(message_id, &format!("project_{}_msg", id), Some(keyboard))
+                .await?
         }
         Callback::GoHome => {
             let keyboard = make_start_buttons(&mut db).await?;
 
-            replace_message(
-                &bot,
-                &mut db,
-                q.chat_id().map(|i| i.0).unwrap_or(q.from.id.0 as i64),
-                q.message.map_or_else(
-                    || {
-                        Err(BotError::MsgTooOld(
-                            "Failed to get message id, probably message too old".to_string(),
-                        ))
-                    },
-                    |m| Ok(m.id().0),
-                )?,
-                "start",
-                Some(keyboard),
-            )
-            .await?
+            let chat_id = q.chat_id().map(|i| i.0).unwrap_or(q.from.id.0 as i64);
+            let message_id = q.message.map_or_else(
+                || {
+                    Err(BotError::MsgTooOld(
+                        "Failed to get message id, probably message too old".to_string(),
+                    ))
+                },
+                |m| Ok(m.id().0),
+            )?;
+            MessageAnswerer::new(&bot, &mut db, chat_id)
+                .replace_message(message_id, "start", Some(keyboard))
+                .await?
         }
         Callback::LeaveApplication => {
             let application = Application::new(q.from.clone()).store(&mut db).await?;
             let msg = send_application_to_chat(&bot, &mut db, &application).await?;
 
-            let (chat_id, msg_id) = answer_message(
-                &bot,
-                q.from.id.0 as i64,
-                &mut db,
-                "left_application_msg",
-                None as Option<InlineKeyboardMarkup>,
-            )
-            .await?;
+            let (chat_id, msg_id) = MessageAnswerer::new(&bot, &mut db, q.from.id.0 as i64)
+                .answer("left_application_msg", None, None)
+                .await?;
             MessageForward::new(msg.chat.id.0, msg.id.0, chat_id, msg_id, false)
                 .store(&mut db)
                 .await?;
         }
         Callback::AskQuestion => {
-            answer_message(
-                &bot,
-                q.from.id.0 as i64,
-                &mut db,
-                "ask_question_msg",
-                None as Option<InlineKeyboardMarkup>,
-            )
-            .await?;
+            MessageAnswerer::new(&bot, &mut db, q.from.id.0 as i64)
+                .answer("ask_question_msg", None, None)
+                .await?;
         }
     };
 
@@ -941,15 +922,9 @@ async fn user_command_handler(
                 variant => Some(variant),
             };
             let mut db2 = db.clone();
-            answer_message_varianted(
-                &bot,
-                msg.chat.id.0,
-                &mut db,
-                "start",
-                variant,
-                Some(make_start_buttons(&mut db2).await?),
-            )
-            .await?;
+            MessageAnswerer::new(&bot, &mut db, msg.chat.id.0)
+                .answer("start", variant, Some(make_start_buttons(&mut db2).await?))
+                .await?;
             Ok(())
         }
         UserCommands::Help => {
@@ -960,272 +935,6 @@ async fn user_command_handler(
     }
 }
 
-async fn answer_message<RM: Into<ReplyMarkup>>(
-    bot: &Bot,
-    chat_id: i64,
-    db: &mut DB,
-    literal: &str,
-    keyboard: Option<RM>,
-) -> BotResult<(i64, i32)> {
-    answer_message_varianted(bot, chat_id, db, literal, None, keyboard).await
-}
-
-async fn answer_message_varianted<RM: Into<ReplyMarkup>>(
-    bot: &Bot,
-    chat_id: i64,
-    db: &mut DB,
-    literal: &str,
-    variant: Option<&str>,
-    keyboard: Option<RM>,
-) -> BotResult<(i64, i32)> {
-    answer_message_varianted_silence_flag(bot, chat_id, db, literal, variant, false, keyboard).await
-}
-
-async fn answer_message_varianted_silence_flag<RM: Into<ReplyMarkup>>(
-    bot: &Bot,
-    chat_id: i64,
-    db: &mut DB,
-    literal: &str,
-    variant: Option<&str>,
-    silence_non_variant: bool,
-    keyboard: Option<RM>,
-) -> BotResult<(i64, i32)> {
-    let variant_text = match variant {
-        Some(variant) => {
-            let value = db.get_literal_alternative_value(literal, variant).await?;
-            if value.is_none() && !silence_non_variant {
-                notify_admin(&format!("variant {variant} for literal {literal} is not found! falling back to just literal")).await;
-            }
-            value
-        }
-        None => None,
-    };
-    let text = match variant_text {
-        Some(text) => text,
-        None => db
-            .get_literal_value(literal)
-            .await?
-            .unwrap_or("Please, set content of this message".into()),
-    };
-
-    let media = db.get_media(literal).await?;
-    let (chat_id, msg_id) = match media.len() {
-        // just a text
-        0 => {
-            let msg = bot.send_message(ChatId(chat_id), text);
-            let msg = match keyboard {
-                Some(kbd) => msg.reply_markup(kbd),
-                None => msg,
-            };
-            let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
-            info!("ENTS: {:?}", msg.entities);
-            let msg = msg.await?;
-
-            (msg.chat.id.0, msg.id.0)
-        }
-        // single media
-        1 => {
-            let media = &media[0]; // safe, cause we just checked len
-            match media.media_type.as_str() {
-                "photo" => {
-                    let msg = bot.send_photo(
-                        ChatId(chat_id),
-                        InputFile::file_id(media.file_id.to_string()),
-                    );
-                    let msg = match text.as_str() {
-                        "" => msg,
-                        text => msg.caption(text),
-                    };
-                    let msg = match keyboard {
-                        Some(kbd) => msg.reply_markup(kbd),
-                        None => msg,
-                    };
-
-                    let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
-                    let msg = msg.await?;
-
-                    (msg.chat.id.0, msg.id.0)
-                }
-                "video" => {
-                    let msg = bot.send_video(
-                        ChatId(chat_id),
-                        InputFile::file_id(media.file_id.to_string()),
-                    );
-                    let msg = match text.as_str() {
-                        "" => msg,
-                        text => msg.caption(text),
-                    };
-                    let msg = match keyboard {
-                        Some(kbd) => msg.reply_markup(kbd),
-                        None => msg,
-                    };
-
-                    let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
-                    let msg = msg.await?;
-
-                    (msg.chat.id.0, msg.id.0)
-                }
-                _ => {
-                    todo!()
-                }
-            }
-        }
-        // >= 2, should use media group
-        _ => {
-            let media: Vec<InputMedia> = media
-                .into_iter()
-                .enumerate()
-                .map(|(i, m)| {
-                    let ifile = InputFile::file_id(m.file_id);
-                    let caption = if i == 0 {
-                        match text.as_str() {
-                            "" => None,
-                            text => Some(text.to_string()),
-                        }
-                    } else {
-                        None
-                    };
-                    match m.media_type.as_str() {
-                        "photo" => InputMedia::Photo(teloxide::types::InputMediaPhoto {
-                            media: ifile,
-                            caption,
-                            parse_mode: Some(ParseMode::Html),
-                            caption_entities: None,
-                            has_spoiler: false,
-                            show_caption_above_media: false,
-                        }),
-                        "video" => InputMedia::Video(teloxide::types::InputMediaVideo {
-                            media: ifile,
-                            thumbnail: None,
-                            caption,
-                            parse_mode: Some(ParseMode::Html),
-                            caption_entities: None,
-                            show_caption_above_media: false,
-                            width: None,
-                            height: None,
-                            duration: None,
-                            supports_streaming: None,
-                            has_spoiler: false,
-                        }),
-                        _ => {
-                            todo!()
-                        }
-                    }
-                })
-                .collect();
-            let msg = bot.send_media_group(ChatId(chat_id), media);
-
-            let msg = msg.await?;
-
-            (msg[0].chat.id.0, msg[0].id.0)
-        }
-    };
-    match variant {
-        Some(variant) => {
-            db.set_message_literal_variant(chat_id, msg_id, literal, variant)
-                .await?
-        }
-        None => db.set_message_literal(chat_id, msg_id, literal).await?,
-    };
-    Ok((chat_id, msg_id))
-}
-
-async fn replace_message(
-    bot: &Bot,
-    db: &mut DB,
-    chat_id: i64,
-    message_id: i32,
-    literal: &str,
-    keyboard: Option<InlineKeyboardMarkup>,
-) -> BotResult<()> {
-    let variant = db
-        .get_message(chat_id, message_id)
-        .await?
-        .and_then(|m| m.variant);
-    let variant_text = match variant {
-        Some(ref variant) => db.get_literal_alternative_value(literal, variant).await?,
-        None => None,
-    };
-    let text = match variant_text {
-        Some(ref text) => text.to_string(),
-        None => db
-            .get_literal_value(literal)
-            .await?
-            .unwrap_or("Please, set content of this message".into()),
-    };
-    let media = db.get_media(literal).await?;
-    let (chat_id, msg_id) = match media.len() {
-        // just a text
-        0 => {
-            let msg = bot.edit_message_text(ChatId(chat_id), MessageId(message_id), text);
-            let msg = match keyboard {
-                Some(ref kbd) => msg.reply_markup(kbd.clone()),
-                None => msg,
-            };
-            let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
-            info!("ENTS: {:?}", msg.entities);
-            let msg = match msg.await {
-                Ok(msg) => msg,
-                Err(teloxide::RequestError::Api(teloxide::ApiError::Unknown(errtext)))
-                    if errtext.as_str()
-                        == "Bad Request: there is no text in the message to edit" =>
-                {
-                    // fallback to sending message
-                    warn!("Fallback into sending message instead of editing because it contains media");
-                    answer_message_varianted_silence_flag(
-                        bot,
-                        chat_id,
-                        db,
-                        literal,
-                        variant.as_deref(),
-                        true,
-                        keyboard,
-                    )
-                    .await?;
-                    return Ok(());
-                }
-                Err(err) => return Err(err.into()),
-            };
-
-            (msg.chat.id.0, msg.id.0)
-        }
-        // single media
-        1 => {
-            let media = &media[0]; // safe, cause we just checked len
-            let input_file = InputFile::file_id(media.file_id.to_string());
-            let media = match media.media_type.as_str() {
-                "photo" => InputMedia::Photo(teloxide::types::InputMediaPhoto::new(input_file)),
-                "video" => InputMedia::Video(teloxide::types::InputMediaVideo::new(input_file)),
-                _ => todo!(),
-            };
-            bot.edit_message_media(ChatId(chat_id), MessageId(message_id), media)
-                .await?;
-
-            let msg = bot.edit_message_caption(ChatId(chat_id), MessageId(message_id));
-            let msg = match text.as_str() {
-                "" => msg,
-                text => msg.caption(text),
-            };
-            let msg = match keyboard {
-                Some(kbd) => msg.reply_markup(kbd),
-                None => msg,
-            };
-
-            let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
-            let msg = msg.await?;
-
-            (msg.chat.id.0, msg.id.0)
-        }
-        // >= 2, should use media group
-        _ => {
-            unreachable!();
-        }
-    };
-    db.set_message_literal(chat_id, msg_id, literal).await?;
-
-    Ok(())
-}
-
 async fn make_start_buttons(db: &mut DB) -> BotResult<InlineKeyboardMarkup> {
     let mut buttons: Vec<Vec<InlineKeyboardButton>> = Vec::new();
     buttons.push(vec![
diff --git a/src/message_answerer.rs b/src/message_answerer.rs
new file mode 100644
index 0000000..c9d10ce
--- /dev/null
+++ b/src/message_answerer.rs
@@ -0,0 +1,302 @@
+use log::{info, warn};
+use teloxide::prelude::*;
+use teloxide::types::{
+    InputFile, InputMedia, InputMediaPhoto, InputMediaVideo, MessageId, ParseMode,
+};
+use teloxide::{
+    types::{ChatId, InlineKeyboardMarkup},
+    Bot,
+};
+
+use crate::db::Media;
+use crate::{
+    db::{CallDB, DB},
+    notify_admin, BotResult,
+};
+
+macro_rules! send_media {
+    ($self:ident, $method:ident, $chat_id:expr, $file_id: expr, $text: expr, $keyboard: expr) => {{
+        let msg = $self
+            .bot
+            .$method(ChatId($chat_id), InputFile::file_id($file_id.to_string()));
+        let msg = match $text.as_str() {
+            "" => msg,
+            text => msg.caption(text),
+        };
+        let msg = match $keyboard {
+            Some(kbd) => msg.reply_markup(kbd),
+            None => msg,
+        };
+        let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
+
+        let msg = msg.await?;
+        Ok((msg.chat.id.0, msg.id.0))
+    }};
+}
+
+pub struct MessageAnswerer<'a> {
+    bot: &'a Bot,
+    chat_id: i64,
+    db: &'a mut DB,
+}
+
+impl<'a> MessageAnswerer<'a> {
+    pub fn new(bot: &'a Bot, db: &'a mut DB, chat_id: i64) -> Self {
+        Self { bot, chat_id, db }
+    }
+
+    async fn get_text(
+        &mut self,
+        literal: &str,
+        variant: Option<&str>,
+        is_replace: bool,
+    ) -> BotResult<String> {
+        let variant_text = match variant {
+            Some(variant) => {
+                let value = self
+                    .db
+                    .get_literal_alternative_value(literal, variant)
+                    .await?;
+                if value.is_none() && !is_replace {
+                    notify_admin(&format!("variant {variant} for literal {literal} is not found! falling back to just literal")).await;
+                }
+                value
+            }
+            None => None,
+        };
+        let text = match variant_text {
+            Some(text) => text,
+            None => self
+                .db
+                .get_literal_value(literal)
+                .await?
+                .unwrap_or("Please, set content of this message".into()),
+        };
+
+        Ok(text)
+    }
+
+    pub async fn answer(
+        mut self,
+        literal: &str,
+        variant: Option<&str>,
+        keyboard: Option<InlineKeyboardMarkup>,
+    ) -> BotResult<(i64, i32)> {
+        let text = self.get_text(literal, variant, false).await?;
+        self.answer_inner(text, literal, variant, keyboard).await
+    }
+
+    async fn answer_inner(
+        mut self,
+        text: String,
+        literal: &str,
+        variant: Option<&str>,
+        keyboard: Option<InlineKeyboardMarkup>,
+    ) -> BotResult<(i64, i32)> {
+        let media = self.db.get_media(literal).await?;
+        let (chat_id, msg_id) = match media.len() {
+            // just a text
+            0 => self.send_message(text, keyboard).await?,
+            // single media
+            1 => self.send_media(&media[0], text, keyboard).await?,
+            // >= 2, should use media group
+            _ => self.send_media_group(media, text).await?,
+        };
+        self.store_message_info(msg_id, literal, variant).await?;
+        Ok((chat_id, msg_id))
+    }
+
+    pub async fn replace_message(
+        mut self,
+        message_id: i32,
+        literal: &str,
+        keyboard: Option<InlineKeyboardMarkup>,
+    ) -> BotResult<()> {
+        let variant = self
+            .db
+            .get_message(self.chat_id, message_id)
+            .await?
+            .and_then(|m| m.variant);
+        let text = self.get_text(literal, variant.as_deref(), true).await?;
+        let media = self.db.get_media(literal).await?;
+        let (chat_id, msg_id) = match media.len() {
+            // just a text
+            0 => {
+                let msg =
+                    self.bot
+                        .edit_message_text(ChatId(self.chat_id), MessageId(message_id), &text);
+                let msg = match keyboard {
+                    Some(ref kbd) => msg.reply_markup(kbd.clone()),
+                    None => msg,
+                };
+                let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
+                info!("ENTS: {:?}", msg.entities);
+                let msg = match msg.await {
+                    Ok(msg) => msg,
+                    Err(teloxide::RequestError::Api(teloxide::ApiError::Unknown(errtext)))
+                        if errtext.as_str()
+                            == "Bad Request: there is no text in the message to edit" =>
+                    {
+                        // fallback to sending message
+                        warn!("Fallback into sending message instead of editing because it contains media");
+                        self.answer_inner(text, literal, variant.as_deref(), keyboard)
+                            .await?;
+                        return Ok(());
+                    }
+                    Err(err) => return Err(err.into()),
+                };
+
+                (msg.chat.id.0, msg.id.0)
+            }
+            // single media
+            1 => {
+                let media = &media[0]; // safe, cause we just checked len
+                let input_file = InputFile::file_id(media.file_id.to_string());
+                let media = match media.media_type.as_str() {
+                    "photo" => InputMedia::Photo(teloxide::types::InputMediaPhoto::new(input_file)),
+                    "video" => InputMedia::Video(teloxide::types::InputMediaVideo::new(input_file)),
+                    _ => todo!(),
+                };
+                self.bot
+                    .edit_message_media(ChatId(self.chat_id), MessageId(message_id), media)
+                    .await?;
+
+                let msg = self
+                    .bot
+                    .edit_message_caption(ChatId(self.chat_id), MessageId(message_id));
+                let msg = match text.as_str() {
+                    "" => msg,
+                    text => msg.caption(text),
+                };
+                let msg = match keyboard {
+                    Some(kbd) => msg.reply_markup(kbd),
+                    None => msg,
+                };
+
+                let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
+                let msg = msg.await?;
+
+                (msg.chat.id.0, msg.id.0)
+            }
+            // >= 2, should use media group
+            _ => {
+                todo!();
+            }
+        };
+
+        self.store_message_info(msg_id, literal, variant.as_deref())
+            .await?;
+
+        Ok(())
+    }
+
+    async fn store_message_info(
+        &mut self,
+        message_id: i32,
+        literal: &str,
+        variant: Option<&str>,
+    ) -> BotResult<()> {
+        match variant {
+            Some(variant) => {
+                self.db
+                    .set_message_literal_variant(self.chat_id, message_id, literal, variant)
+                    .await?
+            }
+            None => {
+                self.db
+                    .set_message_literal(self.chat_id, message_id, literal)
+                    .await?
+            }
+        };
+
+        Ok(())
+    }
+
+    async fn send_message(
+        &self,
+        text: String,
+        keyboard: Option<InlineKeyboardMarkup>,
+    ) -> BotResult<(i64, i32)> {
+        let msg = self.bot.send_message(ChatId(self.chat_id), text);
+        let msg = match keyboard {
+            Some(kbd) => msg.reply_markup(kbd),
+            None => msg,
+        };
+        let msg = msg.parse_mode(teloxide::types::ParseMode::Html);
+        info!("ENTS: {:?}", msg.entities);
+        let msg = msg.await?;
+
+        Ok((msg.chat.id.0, msg.id.0))
+    }
+
+    async fn send_media(
+        &self,
+        media: &Media,
+        text: String,
+        keyboard: Option<InlineKeyboardMarkup>,
+    ) -> BotResult<(i64, i32)> {
+        match media.media_type.as_str() {
+            "photo" => {
+                send_media!(
+                    self,
+                    send_photo,
+                    self.chat_id,
+                    media.file_id,
+                    text,
+                    keyboard
+                )
+            }
+            "video" => {
+                send_media!(
+                    self,
+                    send_video,
+                    self.chat_id,
+                    media.file_id,
+                    text,
+                    keyboard
+                )
+            }
+            _ => {
+                todo!()
+            }
+        }
+    }
+
+    async fn send_media_group(&self, media: Vec<Media>, text: String) -> BotResult<(i64, i32)> {
+        let media: Vec<InputMedia> = media
+            .into_iter()
+            .enumerate()
+            .map(|(i, m)| {
+                let ifile = InputFile::file_id(m.file_id);
+                let caption = if i == 0 {
+                    match text.as_str() {
+                        "" => None,
+                        text => Some(text.to_string()),
+                    }
+                } else {
+                    None
+                };
+                match m.media_type.as_str() {
+                    "photo" => InputMedia::Photo(InputMediaPhoto {
+                        caption,
+                        parse_mode: Some(ParseMode::Html),
+                        ..InputMediaPhoto::new(ifile)
+                    }),
+                    "video" => InputMedia::Video(InputMediaVideo {
+                        caption,
+                        parse_mode: Some(ParseMode::Html),
+                        ..InputMediaVideo::new(ifile)
+                    }),
+                    _ => {
+                        todo!()
+                    }
+                }
+            })
+            .collect();
+        let msg = self.bot.send_media_group(ChatId(self.chat_id), media);
+
+        let msg = msg.await?;
+
+        Ok((msg[0].chat.id.0, msg[0].id.0))
+    }
+}

From d1c1b7500d749075dbf50ea75ec768b85550c522 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:06:07 +0500
Subject: [PATCH 074/131] create script_handler function that creates
 teloxide's handler for botscript dispatch

---
 src/bot_handler.rs | 86 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 src/bot_handler.rs

diff --git a/src/bot_handler.rs b/src/bot_handler.rs
new file mode 100644
index 0000000..8a670ec
--- /dev/null
+++ b/src/bot_handler.rs
@@ -0,0 +1,86 @@
+use log::info;
+use std::{
+    str::FromStr,
+    sync::{Arc, RwLock},
+};
+use teloxide::{
+    dispatching::UpdateFilterExt,
+    dptree::{self, Handler},
+    prelude::DependencyMap,
+    types::{InlineKeyboardButton, InlineKeyboardMarkup, Message, Update},
+    Bot,
+};
+
+use crate::{
+    botscript::{self, BotMessage, RunnerConfig},
+    commands::BotCommand,
+    db::{CallDB, DB},
+    message_answerer::MessageAnswerer,
+    update_user_tg, BotResult,
+};
+
+pub fn script_handler(
+    rc: Arc<RwLock<RunnerConfig>>,
+) -> Handler<'static, DependencyMap, BotResult<()>, teloxide::dispatching::DpHandlerDescription> {
+    dptree::entry()
+        .inspect(|u: Update| {
+            info!("{u:#?}"); // Print the update to the console with inspect
+        })
+        .branch(
+            Update::filter_message()
+                .filter_map(|m: Message| m.text().and_then(|t| BotCommand::from_str(t).ok()))
+                .filter_map(move |bc: BotCommand| {
+                    let rc = std::sync::Arc::clone(&rc);
+                    let command = bc.command();
+
+                    let rc = rc.read().expect("RwLock lock on commands map failed");
+
+                    rc.get_command_message(command)
+                })
+                .endpoint(botscript_command_handler),
+        )
+}
+
+async fn botscript_command_handler(
+    bot: Bot,
+    mut db: DB,
+    bm: BotMessage,
+    msg: Message,
+) -> BotResult<()> {
+    info!("Eval BM: {:?}", bm);
+    let tguser = match msg.from.clone() {
+        Some(user) => user,
+        None => return Ok(()), // do nothing, cause its not usecase of function
+    };
+    let user = db
+        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
+        .await?;
+    let user = update_user_tg(user, &tguser);
+    user.update_user(&mut db).await?;
+
+    let buttons = bm
+        .resolve_buttons(&mut db)
+        .await?
+        .map(|buttons| InlineKeyboardMarkup {
+            inline_keyboard: buttons
+                .iter()
+                .map(|r| {
+                    r.iter()
+                        .map(|b| match b {
+                            botscript::ButtonLayout::Callback {
+                                name,
+                                literal: _,
+                                callback,
+                            } => InlineKeyboardButton::callback(name, callback),
+                        })
+                        .collect()
+                })
+                .collect(),
+        });
+    let literal = bm.literal().map_or("", |s| s.as_str());
+
+    let ma = MessageAnswerer::new(&bot, &mut db, msg.chat.id.0);
+    ma.answer(literal, None, buttons).await?;
+
+    Ok(())
+}

From bdb30c8d98de70422b89fd9ff06de9f917c3ce7e Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:08:55 +0500
Subject: [PATCH 075/131] create default script for new bots

---
 default_script.js | 58 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 default_script.js

diff --git a/default_script.js b/default_script.js
new file mode 100644
index 0000000..91553cf
--- /dev/null
+++ b/default_script.js
@@ -0,0 +1,58 @@
+// db - is set globally
+
+const dialog = {
+    commands: {
+        start: {
+            buttons: start_buttons, // default is `null`
+            state: "start"
+        },
+    },
+    buttons: {
+        more_info: {},
+    },
+    stateful_msg_handlers: {
+        start: {}, // everything is by default, so just send message `start`
+        enter_name: {
+            // name of the handler function. This field has a side effect:
+            // when is set, no automatic sending of message, should be sent
+            // manually in handler
+            handler: enter_name,
+            state: "none"
+        },
+    },
+}
+
+function enter_name() {}
+
+const fmt = (number) => number.toString().padStart(2, '0');
+
+const formatDate = (date) => {
+    const [h, m, d, M, y] = [
+        date.getHours(),
+        date.getMinutes(),
+        date.getDate(),
+        date.getMonth(),
+        date.getFullYear()
+    ];
+    return `${fmt(h)}:${fmt(m)} ${fmt(d)}-${fmt(M + 1)}-${y}`
+};
+
+function start_buttons() {
+    const now = new Date();
+    const dateFormated = formatDate(now);
+
+    // const user = db.find_one("users", {id: 1});
+
+    return [
+        // [{name: {name: user.first_name}, callback_name: "no"}],
+        [{name: {name: dateFormated}, callback_name: "no"}],
+        [{name: {name: "Hello!"}, callback_name: "no"}],
+    ]
+}
+
+const config = {
+    version: 1.1,
+}
+
+const c = {config: config, dialog: dialog}
+c

From a7433cd8cc93b762a3ce23fe6f5d3dc220f22324 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:10:12 +0500
Subject: [PATCH 076/131] create /deploy admin command

---
 src/admin.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/admin.rs b/src/admin.rs
index e8102cc..5cf648f 100644
--- a/src/admin.rs
+++ b/src/admin.rs
@@ -1,3 +1,5 @@
+use std::fmt::format;
+
 use itertools::Itertools;
 use teloxide::{
     prelude::*,
@@ -5,6 +7,7 @@ use teloxide::{
 };
 
 use crate::{
+    bot_manager::deploy_bot,
     db::{CallDB, DB},
     BotResult,
 };
@@ -41,6 +44,8 @@ pub enum AdminCommands {
     Users,
     /// Cancel current action and sets user state to default
     Cancel,
+    /// Create new instance of telegram bot
+    Deploy { token: String },
 }
 
 pub async fn admin_command_handler(
@@ -156,6 +161,15 @@ pub async fn admin_command_handler(
                 .await?;
             Ok(())
         }
+        AdminCommands::Deploy { token } => {
+            let bot_info = deploy_bot(&mut db, &token).await?;
+            bot.send_message(
+                msg.chat.id,
+                format!("Deployed bot with name: {}", bot_info.name),
+            )
+            .await?;
+            Ok(())
+        }
     }
 }
 

From 4c149b69228b5fc306ba0a17cf0194c04269bb97 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:10:54 +0500
Subject: [PATCH 077/131] create BotInstance collection

---
 src/db/bots.rs | 51 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/db/mod.rs  |  1 +
 2 files changed, 52 insertions(+)
 create mode 100644 src/db/bots.rs

diff --git a/src/db/bots.rs b/src/db/bots.rs
new file mode 100644
index 0000000..44bc500
--- /dev/null
+++ b/src/db/bots.rs
@@ -0,0 +1,51 @@
+use bson::doc;
+use bson::oid::ObjectId;
+use chrono::{DateTime, FixedOffset, Local};
+use futures::StreamExt;
+use futures::TryStreamExt;
+use serde::{Deserialize, Serialize};
+
+use super::DbCollection;
+use super::DbResult;
+use crate::db::GetCollection;
+use crate::query_call_consume;
+use crate::CallDB;
+
+#[derive(Serialize, Deserialize, Default)]
+pub struct BotInstance {
+    pub _id: bson::oid::ObjectId,
+    pub name: String,
+    pub token: String,
+    pub script: String,
+    pub created_at: DateTime<FixedOffset>,
+}
+
+impl DbCollection for BotInstance {
+    const COLLECTION: &str = "bots";
+}
+
+impl BotInstance {
+    pub fn new(name: String, token: String, script: String) -> Self {
+        Self {
+            _id: Default::default(),
+            name,
+            token,
+            script,
+            created_at: Local::now().into(),
+        }
+    }
+
+    query_call_consume!(store, self, db, Self, {
+        let bi = db.get_collection::<Self>().await;
+
+        bi.insert_one(&self).await?;
+
+        Ok(self)
+    });
+
+    pub async fn get_all<D: CallDB>(db: &mut D) -> DbResult<Vec<Self>> {
+        let bi = db.get_collection::<Self>().await;
+
+        Ok(bi.find(doc! {}).await?.try_collect().await?)
+    }
+}
diff --git a/src/db/mod.rs b/src/db/mod.rs
index d1e22e6..b703147 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -1,4 +1,5 @@
 pub mod application;
+pub mod bots;
 pub mod callback_info;
 pub mod message_forward;
 

From 9c15b0a3756c915ab132c8a095c256e12e5862d7 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:15:27 +0500
Subject: [PATCH 078/131] create DbCollection and GetCollection traits

---
 src/db/mod.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/db/mod.rs b/src/db/mod.rs
index b703147..1a0715b 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -12,7 +12,7 @@ use futures::stream::TryStreamExt;
 
 use mongodb::options::IndexOptions;
 use mongodb::{bson::doc, options::ClientOptions, Client};
-use mongodb::{Database, IndexModel};
+use mongodb::{Collection, Database, IndexModel};
 use serde::{Deserialize, Serialize};
 
 #[derive(EnumStringify)]
@@ -193,6 +193,14 @@ impl DB {
     }
 }
 
+pub trait DbCollection {
+    const COLLECTION: &str;
+}
+
+pub trait GetCollection {
+    async fn get_collection<C: DbCollection + Send + Sync>(&mut self) -> Collection<C>;
+}
+
 #[async_trait]
 impl CallDB for DB {
     async fn get_database(&mut self) -> Database {

From a33d4b393c1031e2c35c054d3c4fe57ffea99180 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:16:12 +0500
Subject: [PATCH 079/131] impl GetCollection for CallDB

---
 src/db/mod.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/db/mod.rs b/src/db/mod.rs
index 1a0715b..6f3ab70 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -208,6 +208,14 @@ impl CallDB for DB {
     }
 }
 
+impl<T: CallDB> GetCollection for T {
+    async fn get_collection<C: DbCollection + Send + Sync>(&mut self) -> Collection<C> {
+        self.get_database()
+            .await
+            .collection(<C as DbCollection>::COLLECTION)
+    }
+}
+
 #[derive(thiserror::Error, Debug)]
 pub enum DbError {
     #[error("error while processing mongodb query: {0}")]

From cb7c8880286cdeb2576acfc2f81c62cac8261412 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:22:46 +0500
Subject: [PATCH 080/131] create RawCall trait, that will contain DB methods to
 call from script runtime

---
 src/db/mod.rs       |  1 +
 src/db/raw_calls.rs | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+)
 create mode 100644 src/db/raw_calls.rs

diff --git a/src/db/mod.rs b/src/db/mod.rs
index 6f3ab70..f0ec585 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -2,6 +2,7 @@ pub mod application;
 pub mod bots;
 pub mod callback_info;
 pub mod message_forward;
+pub mod raw_calls;
 
 use std::time::Duration;
 
diff --git a/src/db/raw_calls.rs b/src/db/raw_calls.rs
new file mode 100644
index 0000000..36488fd
--- /dev/null
+++ b/src/db/raw_calls.rs
@@ -0,0 +1,38 @@
+use mongodb::Database;
+
+use super::CallDB;
+use serde_json::Value;
+
+#[derive(thiserror::Error, Debug)]
+pub enum RawCallError {
+    #[error("error while processing mongodb query: {0}")]
+    MongodbError(#[from] mongodb::error::Error),
+    #[error("error while buildint bson's query document: {0}")]
+    DocumentError(#[from] mongodb::bson::extjson::de::Error),
+    #[error("error when expected map: {0}")]
+    NotAMapError(String),
+}
+pub type RawCallResult<T> = Result<T, RawCallError>;
+
+pub trait RawCall {
+    async fn get_database(&mut self) -> Database;
+    async fn find_one(&mut self, collection: &str, query: Value) -> RawCallResult<Option<Value>> {
+        let db = self.get_database().await;
+        let value = db.collection::<Value>(collection);
+
+        let map = match query {
+            Value::Object(map) => map,
+            _ => return Err(RawCallError::NotAMapError("query is not a map".to_string())),
+        };
+
+        let doc = map.try_into()?;
+        let ret = value.find_one(doc).await?;
+        Ok(ret)
+    }
+}
+
+impl<T: CallDB> RawCall for T {
+    async fn get_database(&mut self) -> Database {
+        CallDB::get_database(self).await
+    }
+}

From aac968e4083812ac7c755bcd542e5300b7bdcae3 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:43:04 +0500
Subject: [PATCH 081/131] add RawCallError to ScriptError

---
 src/botscript.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index f455f8c..b816030 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 
+use crate::db::raw_calls::RawCallError;
 use crate::db::{CallDB, DbError, DB};
 use crate::utils::parcelable::{ParcelType, Parcelable, ParcelableError, ParcelableResult};
 use futures::future::join_all;
@@ -32,6 +33,8 @@ pub enum ScriptError {
     DBError(#[from] DbError),
     #[error("error resolving data: {0:?}")]
     ResolveError(#[from] ResolveError),
+    #[error("error while calling db from runtime: {0:?}")]
+    RawCallError(#[from] RawCallError),
 }
 
 #[derive(thiserror::Error, Debug)]

From ff7f317ae54f98540a1bc9a454dd55097fee4231 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:44:34 +0500
Subject: [PATCH 082/131] create attach_db_obj for botscript

---
 src/botscript.rs    |  1 +
 src/botscript/db.rs | 50 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+)
 create mode 100644 src/botscript/db.rs

diff --git a/src/botscript.rs b/src/botscript.rs
index b816030..e737ee7 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,3 +1,4 @@
+pub mod db;
 use std::collections::HashMap;
 
 use crate::db::raw_calls::RawCallError;
diff --git a/src/botscript/db.rs b/src/botscript/db.rs
new file mode 100644
index 0000000..912b48a
--- /dev/null
+++ b/src/botscript/db.rs
@@ -0,0 +1,50 @@
+use std::sync::RwLock;
+
+use quickjs_rusty::context::Context;
+
+use quickjs_rusty::serde::{from_js, to_js};
+use quickjs_rusty::{utils::create_empty_object, OwnedJsObject, OwnedJsValue as JsValue};
+
+use crate::db::raw_calls::RawCall;
+use crate::db::DB;
+
+use super::ScriptError;
+
+pub fn attach_db_obj(c: &Context, o: &mut OwnedJsObject, db: &DB) -> Result<(), ScriptError> {
+    let dbobj = JsValue::new(o.context(), create_empty_object(o.context())?)
+        .try_into_object()
+        .expect("the created object was not an object :/");
+
+    let db: std::sync::Arc<RwLock<DB>> = std::sync::Arc::new(RwLock::new(db.clone()));
+    let dbbox = Box::new(db);
+    let db: &'static _ = Box::leak(dbbox);
+
+    let find_one = c.create_callback(
+        |collection: String, q: OwnedJsObject| -> Result<_, ScriptError> {
+            let query: serde_json::Value = match from_js(q.context(), &q) {
+                Ok(q) => q,
+                Err(_) => todo!(),
+            };
+            let db = db.clone();
+
+            let value = futures::executor::block_on(
+                db.write()
+                    .expect("failed to gain write acces to db (probably RwLock is poisoned)")
+                    .find_one(&collection, query),
+            )?;
+
+            let ret = match value {
+                Some(v) => Some(to_js(q.context(), &v)?),
+                None => None,
+            };
+            Ok(ret)
+        },
+    )?;
+    let find_one = JsValue::from((unsafe { c.context_raw() }, find_one));
+
+    dbobj.set_property("find_one", find_one)?;
+
+    o.set_property("db", dbobj.into_value())?;
+
+    Ok(())
+}

From 13a861e74bc33d7366186d98eaa4e5fd5b101658 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:45:59 +0500
Subject: [PATCH 083/131] cargo add serde_json

---
 Cargo.lock | 1 +
 Cargo.toml | 1 +
 2 files changed, 2 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 561ed82..ab30f10 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -921,6 +921,7 @@ dependencies = [
  "pretty_env_logger",
  "quickjs-rusty",
  "serde",
+ "serde_json",
  "teloxide",
  "thiserror 2.0.12",
  "tokio",
diff --git a/Cargo.toml b/Cargo.toml
index ffa5767..eaa399e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,6 +20,7 @@ mongodb = "3.2.3"
 pretty_env_logger = "0.5.0"
 quickjs-rusty = "0.9.0"
 serde = { version = "1.0.219", features = ["derive", "serde_derive"] }
+serde_json = "1.0.140"
 teloxide = { version = "0.14.0", features = ["macros", "postgres-storage-nativetls"] }
 thiserror = "2.0.12"
 tokio = { version = "1.44.1", features = ["rt-multi-thread", "macros"] }

From 4384431696f1b8ff0a2e44157a1c93f0951c371c Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:47:35 +0500
Subject: [PATCH 084/131] create RunnerConfig::init_with_db

---
 src/botscript.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index e737ee7..761c53f 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -4,6 +4,7 @@ use std::collections::HashMap;
 use crate::db::raw_calls::RawCallError;
 use crate::db::{CallDB, DbError, DB};
 use crate::utils::parcelable::{ParcelType, Parcelable, ParcelableError, ParcelableResult};
+use db::attach_db_obj;
 use futures::future::join_all;
 use itertools::Itertools;
 use quickjs_rusty::serde::from_js;
@@ -615,6 +616,20 @@ impl Runner {
         Ok(Runner { context })
     }
 
+    pub fn init_with_db(db: &mut DB) -> ScriptResult<Self> {
+        let context = Context::new(None)?;
+        let mut global = context.global()?;
+        attach_db_obj(&context, &mut global, db)?;
+
+        context.add_callback("print", |a: String| {
+            print(a);
+
+            None::<bool>
+        })?;
+
+        Ok(Runner { context })
+    }
+
     pub fn run_script(&self, content: &str) -> ScriptResult<JsValue> {
         let ctx = &self.context;
 

From 9bbf481002869f50b4582ef378636b449c751178 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:48:11 +0500
Subject: [PATCH 085/131] derive Clone on bot and runner config

---
 src/botscript.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 761c53f..b019e8b 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -254,7 +254,7 @@ fn print(s: String) {
     println!("{s}");
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BotConfig {
     version: f64,
 }
@@ -555,7 +555,7 @@ impl Parcelable<BotFunction> for BotMessage {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BotDialog {
     pub commands: HashMap<String, BotMessage>,
     stateful_msg_handlers: HashMap<String, BotMessage>,
@@ -573,7 +573,7 @@ impl Parcelable<BotFunction> for BotDialog {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct RunnerConfig {
     config: BotConfig,
     pub dialog: BotDialog,

From 4be9c034c90df8f2e0d996d9405c2a2007f400b8 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Mon, 26 May 2025 20:50:25 +0500
Subject: [PATCH 086/131] use variable db name instead of hardcoded one

---
 src/db/mod.rs       | 11 ++++++-----
 src/db/tests/mod.rs |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/db/mod.rs b/src/db/mod.rs
index f0ec585..82a8079 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -142,14 +142,15 @@ pub struct Media {
 #[derive(Clone)]
 pub struct DB {
     client: Client,
+    name: String,
 }
 
 impl DB {
-    pub async fn new<S: Into<String>>(db_url: S) -> DbResult<Self> {
+    pub async fn new<S: Into<String>>(db_url: S, name: String) -> DbResult<Self> {
         let options = ClientOptions::parse(db_url.into()).await?;
         let client = Client::with_options(options)?;
 
-        Ok(DB { client })
+        Ok(DB { client, name })
     }
 
     pub async fn migrate(&mut self) -> DbResult<()> {
@@ -186,8 +187,8 @@ impl DB {
         Ok(())
     }
 
-    pub async fn init<S: Into<String>>(db_url: S) -> DbResult<Self> {
-        let mut db = Self::new(db_url).await?;
+    pub async fn init<S: Into<String>>(db_url: S, name: String) -> DbResult<Self> {
+        let mut db = Self::new(db_url, name).await?;
         db.migrate().await?;
 
         Ok(db)
@@ -205,7 +206,7 @@ pub trait GetCollection {
 #[async_trait]
 impl CallDB for DB {
     async fn get_database(&mut self) -> Database {
-        self.client.database("gongbot")
+        self.client.database(&self.name)
     }
 }
 
diff --git a/src/db/tests/mod.rs b/src/db/tests/mod.rs
index 5c63fa8..8da40ce 100644
--- a/src/db/tests/mod.rs
+++ b/src/db/tests/mod.rs
@@ -10,7 +10,7 @@ async fn setup_db() -> DB {
     dotenvy::dotenv().unwrap();
     let db_url = std::env::var("DATABASE_URL").unwrap();
 
-    DB::new(db_url).await.unwrap()
+    DB::new(db_url, "gongbot".to_string()).await.unwrap()
 }
 
 #[tokio::test]

From 3acd168155d3206402e36c189d0e447f0c50436e Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 04:08:27 +0500
Subject: [PATCH 087/131] make Runner thread safe

---
 src/botscript.rs | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index b019e8b..ba6db4e 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,11 +1,13 @@
 pub mod db;
 use std::collections::HashMap;
+use std::sync::{Arc, Mutex, PoisonError};
 
 use crate::db::raw_calls::RawCallError;
 use crate::db::{CallDB, DbError, DB};
 use crate::utils::parcelable::{ParcelType, Parcelable, ParcelableError, ParcelableResult};
 use db::attach_db_obj;
 use futures::future::join_all;
+use futures::lock::MutexGuard;
 use itertools::Itertools;
 use quickjs_rusty::serde::from_js;
 use quickjs_rusty::utils::create_empty_object;
@@ -37,6 +39,8 @@ pub enum ScriptError {
     ResolveError(#[from] ResolveError),
     #[error("error while calling db from runtime: {0:?}")]
     RawCallError(#[from] RawCallError),
+    #[error("error while locking mutex: {0:?}")]
+    MutexError(String),
 }
 
 #[derive(thiserror::Error, Debug)]
@@ -599,8 +603,9 @@ impl Parcelable<BotFunction> for RunnerConfig {
     }
 }
 
+#[derive(Clone)]
 pub struct Runner {
-    context: Context,
+    context: Arc<Mutex<Context>>,
 }
 
 impl Runner {
@@ -613,7 +618,9 @@ impl Runner {
             None::<bool>
         })?;
 
-        Ok(Runner { context })
+        Ok(Runner {
+            context: Arc::new(Mutex::new(context)),
+        })
     }
 
     pub fn init_with_db(db: &mut DB) -> ScriptResult<Self> {
@@ -627,11 +634,20 @@ impl Runner {
             None::<bool>
         })?;
 
-        Ok(Runner { context })
+        Ok(Runner {
+            context: Arc::new(Mutex::new(context)),
+        })
     }
 
     pub fn run_script(&self, content: &str) -> ScriptResult<JsValue> {
-        let ctx = &self.context;
+        let ctx = match self.context.lock() {
+            Ok(ctx) => ctx,
+            Err(err) => {
+                return Err(ScriptError::MutexError(format!(
+                    "can't lock js Context mutex, err: {err}"
+                )))
+            }
+        };
 
         let val = ctx.eval(content, false)?;
 

From 9e99064bc507a0070f8dc6ef314beee0cb013b3d Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 04:09:05 +0500
Subject: [PATCH 088/131] create DB.with_name method

---
 src/db/mod.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/db/mod.rs b/src/db/mod.rs
index 82a8079..1e5882f 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -193,6 +193,10 @@ impl DB {
 
         Ok(db)
     }
+
+    pub fn with_name(self, name: String) -> Self {
+        Self { name, ..self }
+    }
 }
 
 pub trait DbCollection {

From a136558681f52fc5855775ec93b0f6f5a6bcd822 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 04:09:47 +0500
Subject: [PATCH 089/131] create MongodbStorage::from_db initializer

---
 src/mongodb_storage.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/mongodb_storage.rs b/src/mongodb_storage.rs
index 9289aef..6a703dc 100644
--- a/src/mongodb_storage.rs
+++ b/src/mongodb_storage.rs
@@ -9,6 +9,8 @@ use mongodb::Database;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use teloxide::dispatching::dialogue::{Serializer, Storage};
 
+use crate::db::{CallDB, DB};
+
 pub struct MongodbStorage<S> {
     database: Database,
     serializer: S,
@@ -28,6 +30,13 @@ impl<S> MongodbStorage<S> {
             serializer,
         }))
     }
+
+    pub async fn from_db(db: &mut DB, serializer: S) -> Result<Arc<Self>, mongodb::error::Error> {
+        Ok(Arc::new(Self {
+            database: CallDB::get_database(db).await,
+            serializer,
+        }))
+    }
 }
 
 #[derive(Serialize, Deserialize)]

From 593316d5415f8f2207ca542322cd11f5dcfe849c Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 04:15:39 +0500
Subject: [PATCH 090/131] cargo add lazy_static

---
 Cargo.lock | 7 +++++++
 Cargo.toml | 1 +
 2 files changed, 8 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index ab30f10..d00b307 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -916,6 +916,7 @@ dependencies = [
  "envconfig",
  "futures",
  "itertools 0.14.0",
+ "lazy_static",
  "log",
  "mongodb",
  "pretty_env_logger",
@@ -1437,6 +1438,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libc"
 version = "0.2.171"
diff --git a/Cargo.toml b/Cargo.toml
index eaa399e..e29d0c4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,7 @@ enum_stringify = "0.6.3"
 envconfig = "0.11.0"
 futures = "0.3.31"
 itertools = "0.14.0"
+lazy_static = "1.5.0"
 log = "0.4.27"
 mongodb = "3.2.3"
 pretty_env_logger = "0.5.0"

From ef5d74cf1c305c1ba0d2a02d419a6ebd58ff9794 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 04:15:56 +0500
Subject: [PATCH 091/131] create bot_manager module to handle background bot
 start

---
 src/bot_manager.rs | 106 +++++++++++++++++++++++++++++++++++++++++++++
 src/main.rs        |   1 +
 2 files changed, 107 insertions(+)
 create mode 100644 src/bot_manager.rs

diff --git a/src/bot_manager.rs b/src/bot_manager.rs
new file mode 100644
index 0000000..7c3766f
--- /dev/null
+++ b/src/bot_manager.rs
@@ -0,0 +1,106 @@
+use std::{collections::HashMap, sync::RwLock, thread::JoinHandle};
+
+use lazy_static::lazy_static;
+use teloxide::{
+    dispatching::dialogue::serializer::Json,
+    dptree,
+    prelude::{Dispatcher, Requester},
+    Bot,
+};
+
+use crate::{
+    bot_handler::script_handler,
+    db::{bots::BotInstance, DbError, DB},
+    mongodb_storage::MongodbStorage,
+    BotController, BotError, BotResult,
+};
+
+pub struct BotRunner {
+    controller: BotController,
+    info: BotInfo,
+    thread: JoinHandle<BotResult<()>>,
+}
+
+unsafe impl Sync for BotRunner {}
+unsafe impl Send for BotRunner {}
+
+#[derive(Clone)]
+pub struct BotInfo {
+    pub name: String,
+}
+
+lazy_static! {
+    static ref BOT_POOL: RwLock<HashMap<String, BotRunner>> = RwLock::new(HashMap::new());
+}
+
+static DEFAULT_SCRIPT: &str =
+    include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/default_script.js"));
+
+pub async fn deploy_bot(db: &mut DB, token: &str) -> BotResult<BotInfo> {
+    let bot = Bot::new(token);
+    let name = bot.get_me().await?.username().to_string();
+
+    let bi = BotInstance::new(name.clone(), token.to_string(), DEFAULT_SCRIPT.to_string())
+        .store(db)
+        .await?;
+
+    start_bot(bi, &mut db.clone().with_name(name)).await
+}
+
+pub async fn start_bot(bi: BotInstance, db: &mut DB) -> BotResult<BotInfo> {
+    let controller = BotController::with_db(db.clone(), &bi.token, &bi.script).await?;
+
+    let thread = spawn_bot_thread(controller.clone(), db).await?;
+
+    let info = BotInfo {
+        name: bi.name.clone(),
+    };
+    let runner = BotRunner {
+        controller,
+        info: info.clone(),
+        thread,
+    };
+
+    BOT_POOL
+        .write()
+        .map_or_else(
+            |err| {
+                Err(BotError::RwLockError(format!(
+                    "Failed to lock BOT_POOL because previous thread paniced, err: {err}"
+                )))
+            },
+            Ok,
+        )?
+        .insert(bi.name.clone(), runner);
+
+    Ok(info)
+}
+
+pub async fn spawn_bot_thread(
+    bc: BotController,
+    db: &mut DB,
+) -> BotResult<JoinHandle<BotResult<()>>> {
+    let state_mgr = MongodbStorage::from_db(db, Json)
+        .await
+        .map_err(DbError::from)?;
+    let thread = std::thread::spawn(move || -> BotResult<()> {
+        let state_mgr = state_mgr;
+
+        let handler = script_handler(bc.rc);
+
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()?;
+
+        rt.block_on(
+            Dispatcher::builder(bc.bot, handler)
+                .dependencies(dptree::deps![bc.db, state_mgr])
+                .build()
+                .dispatch(),
+        );
+
+        Ok(())
+    });
+
+    Ok(thread)
+}
diff --git a/src/main.rs b/src/main.rs
index 8ef3f30..bdd6aab 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,5 @@
 pub mod admin;
+pub mod bot_manager;
 pub mod botscript;
 pub mod commands;
 pub mod db;

From 6ac3665dee1db09b3c3b71044b856fef495a7a7a Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 04:17:26 +0500
Subject: [PATCH 092/131] fix: add bot_handler to compile tree

---
 src/main.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main.rs b/src/main.rs
index bdd6aab..8cb1bae 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,5 @@
 pub mod admin;
+pub mod bot_handler;
 pub mod bot_manager;
 pub mod botscript;
 pub mod commands;

From 77ba6dcfc5251154056060fb2c31794246728bef Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 14:10:48 +0500
Subject: [PATCH 093/131] define const MAIN_BOT_SCRIPT

---
 src/main.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index 8cb1bae..5a4b0b4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -111,6 +111,8 @@ pub struct BotController {
     pub runner: Runner,
 }
 
+const MAIN_BOT_SCRIPT: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/mainbot.js"));
+
 impl BotController {
     pub async fn new(config: &Config) -> Result<Self, Box<dyn std::error::Error>> {
         let bot = Bot::new(&config.bot_token);

From 1757571f3557caabfe1f4e01dec6f19b437498f7 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 14:11:33 +0500
Subject: [PATCH 094/131] create bot_name field in Config

---
 src/main.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index 5a4b0b4..178a823 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -55,6 +55,8 @@ pub struct Config {
     pub admin_password: String,
     #[envconfig(from = "ADMIN_ID")]
     pub admin_id: u64,
+    #[envconfig(from = "BOT_NAME")]
+    pub bot_name: String,
 }
 
 #[derive(BotCommands, Clone)]

From 4a35243a4c23f54930aa9b7ec42dec164201ca19 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 14:13:28 +0500
Subject: [PATCH 095/131] store RunnerConfig in BotController as atomic rw lock
 for thread safety

---
 src/main.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 178a823..8e1d17a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -17,7 +17,7 @@ use itertools::Itertools;
 use log::{error, info, warn};
 use message_answerer::MessageAnswerer;
 use std::str::FromStr;
-use std::sync::RwLock;
+use std::sync::{Arc, RwLock};
 use std::time::Duration;
 use teloxide::sugar::request::RequestReplyExt;
 use utils::create_callback_button;
@@ -109,7 +109,7 @@ type CallbackStore = CallbackInfo<Callback>;
 pub struct BotController {
     pub bot: Bot,
     pub db: DB,
-    pub rc: RunnerConfig,
+    pub rc: Arc<RwLock<RunnerConfig>>,
     pub runner: Runner,
 }
 
@@ -177,7 +177,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
     //
-    let rc: std::sync::Arc<RwLock<RunnerConfig>> = std::sync::Arc::new(RwLock::new(bc.rc));
+    let rc: std::sync::Arc<RwLock<_>> = bc.rc;
 
     let handler = dptree::entry()
         .inspect(|u: Update| {

From e1b6b5aa104ac215a6d94a26d623bd67b93feef0 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 14:14:23 +0500
Subject: [PATCH 096/131] derive Clone for BotController

---
 src/main.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main.rs b/src/main.rs
index 8e1d17a..db5e909 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -106,6 +106,7 @@ pub enum Callback {
 
 type CallbackStore = CallbackInfo<Callback>;
 
+#[derive(Clone)]
 pub struct BotController {
     pub bot: Bot,
     pub db: DB,

From 8fed0daf4c8e4eb39350e634ea04f41e6c029c4b Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 14:17:29 +0500
Subject: [PATCH 097/131] extend BotController creation implementation

---
 src/main.rs | 28 ++++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index db5e909..1c89d71 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,7 +8,7 @@ pub mod message_answerer;
 pub mod mongodb_storage;
 pub mod utils;
 
-use botscript::{BotMessage, Runner, RunnerConfig, ScriptError};
+use botscript::{BotMessage, Runner, RunnerConfig, ScriptError, ScriptResult};
 use commands::BotCommand;
 use db::application::Application;
 use db::callback_info::CallbackInfo;
@@ -117,12 +117,28 @@ pub struct BotController {
 const MAIN_BOT_SCRIPT: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/mainbot.js"));
 
 impl BotController {
-    pub async fn new(config: &Config) -> Result<Self, Box<dyn std::error::Error>> {
-        let bot = Bot::new(&config.bot_token);
-        let db = DB::init(&config.db_url).await?;
+    pub async fn new(config: &Config) -> ScriptResult<Self> {
+        Self::create(
+            &config.bot_token,
+            &config.db_url,
+            &config.bot_name,
+            MAIN_BOT_SCRIPT,
+        )
+        .await
+    }
 
-        let runner = Runner::init()?;
-        let rc = runner.init_config(include_str!("../mainbot.js"))?;
+    pub async fn create(token: &str, db_url: &str, name: &str, script: &str) -> ScriptResult<Self> {
+        let db = DB::init(db_url, name.to_owned()).await?;
+
+        Self::with_db(db, token, script).await
+    }
+
+    pub async fn with_db(mut db: DB, token: &str, script: &str) -> ScriptResult<Self> {
+        let bot = Bot::new(token);
+
+        let runner = Runner::init_with_db(&mut db)?;
+        let rc = runner.init_config(script)?;
+        let rc = Arc::new(RwLock::new(rc));
 
         Ok(Self {
             bot,

From 8e3c647727e599b980bd434a179bcc3f1fb70162 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 14:20:02 +0500
Subject: [PATCH 098/131] fix: handle io and RwLock error for bot manager

---
 src/main.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index 1c89d71..bae49bb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -159,6 +159,8 @@ pub enum BotError {
     BotLogicError(String),
     AdminMisconfiguration(String),
     ScriptError(#[from] ScriptError),
+    IoError(#[from] std::io::Error),
+    RwLockError(String),
 }
 
 pub type BotResult<T> = Result<T, BotError>;

From d10acc992a8cde99bb2bac8761814d38585a4d93 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 14:21:36 +0500
Subject: [PATCH 099/131] start bot instances in main

---
 src/main.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index bae49bb..dbc2786 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,9 +8,11 @@ pub mod message_answerer;
 pub mod mongodb_storage;
 pub mod utils;
 
+use bot_manager::start_bot;
 use botscript::{BotMessage, Runner, RunnerConfig, ScriptError, ScriptResult};
 use commands::BotCommand;
 use db::application::Application;
+use db::bots::BotInstance;
 use db::callback_info::CallbackInfo;
 use db::message_forward::MessageForward;
 use itertools::Itertools;
@@ -180,6 +182,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut bc = BotController::new(&config).await?;
     let state_mgr = MongodbStorage::open(config.db_url.clone().as_ref(), "gongbot", Json).await?;
 
+    for bi in BotInstance::get_all(&mut bc.db).await? {
+        let info = start_bot(bi, &mut bc.db).await?;
+        println!("Started bot: {}", info.name);
+    }
+
     // TODO: delete this in production
     // allow because values are hardcoded and if they will be unparsable
     // we should panic anyway

From 2fdd8a346d72909ae6a74364bb313c27561cff6a Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 15:08:03 +0500
Subject: [PATCH 100/131] fix: instead of actually starting bot on /deploy,
 just put info in DB

reason: it's not a responsibility of /deploy command to store bot info
AND starting bot thread, isntead it is responsible only for storing info
in DB, as every other command does, and then bot will lazily start by
bot manager
---
 src/admin.rs       | 7 ++++---
 src/bot_manager.rs | 4 ++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/admin.rs b/src/admin.rs
index 5cf648f..709c624 100644
--- a/src/admin.rs
+++ b/src/admin.rs
@@ -7,7 +7,7 @@ use teloxide::{
 };
 
 use crate::{
-    bot_manager::deploy_bot,
+    bot_manager::create_bot,
     db::{CallDB, DB},
     BotResult,
 };
@@ -162,10 +162,11 @@ pub async fn admin_command_handler(
             Ok(())
         }
         AdminCommands::Deploy { token } => {
-            let bot_info = deploy_bot(&mut db, &token).await?;
+            let bot_instance = create_bot(&mut db, &token).await?;
+
             bot.send_message(
                 msg.chat.id,
-                format!("Deployed bot with name: {}", bot_info.name),
+                format!("Deployed bot with name: {}", bot_instance.name),
             )
             .await?;
             Ok(())
diff --git a/src/bot_manager.rs b/src/bot_manager.rs
index 7c3766f..8e34e73 100644
--- a/src/bot_manager.rs
+++ b/src/bot_manager.rs
@@ -36,7 +36,7 @@ lazy_static! {
 static DEFAULT_SCRIPT: &str =
     include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/default_script.js"));
 
-pub async fn deploy_bot(db: &mut DB, token: &str) -> BotResult<BotInfo> {
+pub async fn create_bot(db: &mut DB, token: &str) -> BotResult<BotInstance> {
     let bot = Bot::new(token);
     let name = bot.get_me().await?.username().to_string();
 
@@ -44,7 +44,7 @@ pub async fn deploy_bot(db: &mut DB, token: &str) -> BotResult<BotInfo> {
         .store(db)
         .await?;
 
-    start_bot(bi, &mut db.clone().with_name(name)).await
+    Ok(bi)
 }
 
 pub async fn start_bot(bi: BotInstance, db: &mut DB) -> BotResult<BotInfo> {

From 6eb6f2f4540b14284f8d5f42e8bbae1fdd20dc5d Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 15:34:50 +0500
Subject: [PATCH 101/131] fix: start bot with it's db name

---
 src/bot_manager.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/bot_manager.rs b/src/bot_manager.rs
index 8e34e73..4e05966 100644
--- a/src/bot_manager.rs
+++ b/src/bot_manager.rs
@@ -48,9 +48,10 @@ pub async fn create_bot(db: &mut DB, token: &str) -> BotResult<BotInstance> {
 }
 
 pub async fn start_bot(bi: BotInstance, db: &mut DB) -> BotResult<BotInfo> {
+    let mut db = db.clone().with_name(bi.name.clone());
     let controller = BotController::with_db(db.clone(), &bi.token, &bi.script).await?;
 
-    let thread = spawn_bot_thread(controller.clone(), db).await?;
+    let thread = spawn_bot_thread(controller.clone(), &mut db).await?;
 
     let info = BotInfo {
         name: bi.name.clone(),

From d428c8798da7c466c65e0bbb52d08172ebab7b4f Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Tue, 27 May 2025 15:35:40 +0500
Subject: [PATCH 102/131] make script_handler return a public type

---
 src/bot_handler.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/bot_handler.rs b/src/bot_handler.rs
index 8a670ec..848d166 100644
--- a/src/bot_handler.rs
+++ b/src/bot_handler.rs
@@ -19,9 +19,10 @@ use crate::{
     update_user_tg, BotResult,
 };
 
-pub fn script_handler(
-    rc: Arc<RwLock<RunnerConfig>>,
-) -> Handler<'static, DependencyMap, BotResult<()>, teloxide::dispatching::DpHandlerDescription> {
+pub type BotHandler =
+    Handler<'static, DependencyMap, BotResult<()>, teloxide::dispatching::DpHandlerDescription>;
+
+pub fn script_handler(rc: Arc<RwLock<RunnerConfig>>) -> BotHandler {
     dptree::entry()
         .inspect(|u: Update| {
             info!("{u:#?}"); // Print the update to the console with inspect

From 098cff72bdf20e74339d34106907316fb2e55e5b Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 28 May 2025 10:13:11 +0500
Subject: [PATCH 103/131] delete inspector in botscript handler

---
 src/bot_handler.rs | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/src/bot_handler.rs b/src/bot_handler.rs
index 848d166..a0d7d19 100644
--- a/src/bot_handler.rs
+++ b/src/bot_handler.rs
@@ -23,23 +23,21 @@ pub type BotHandler =
     Handler<'static, DependencyMap, BotResult<()>, teloxide::dispatching::DpHandlerDescription>;
 
 pub fn script_handler(rc: Arc<RwLock<RunnerConfig>>) -> BotHandler {
-    dptree::entry()
-        .inspect(|u: Update| {
-            info!("{u:#?}"); // Print the update to the console with inspect
-        })
-        .branch(
-            Update::filter_message()
-                .filter_map(|m: Message| m.text().and_then(|t| BotCommand::from_str(t).ok()))
-                .filter_map(move |bc: BotCommand| {
-                    let rc = std::sync::Arc::clone(&rc);
-                    let command = bc.command();
+    dptree::entry().branch(
+        Update::filter_message()
+            // check if message is command
+            .filter_map(|m: Message| m.text().and_then(|t| BotCommand::from_str(t).ok()))
+            // check if command is presented in config
+            .filter_map(move |bc: BotCommand| {
+                let rc = std::sync::Arc::clone(&rc);
+                let command = bc.command();
 
-                    let rc = rc.read().expect("RwLock lock on commands map failed");
+                let rc = rc.read().expect("RwLock lock on commands map failed");
 
-                    rc.get_command_message(command)
-                })
-                .endpoint(botscript_command_handler),
-        )
+                rc.get_command_message(command)
+            })
+            .endpoint(botscript_command_handler),
+    )
 }
 
 async fn botscript_command_handler(

From e63187dcd35a174910f38fc9b0e2bc479adfb106 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 28 May 2025 10:15:30 +0500
Subject: [PATCH 104/131] rename botscript_command_handler to more correct
 handle_botmessage

---
 src/bot_handler.rs | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/bot_handler.rs b/src/bot_handler.rs
index a0d7d19..f8e8355 100644
--- a/src/bot_handler.rs
+++ b/src/bot_handler.rs
@@ -36,16 +36,11 @@ pub fn script_handler(rc: Arc<RwLock<RunnerConfig>>) -> BotHandler {
 
                 rc.get_command_message(command)
             })
-            .endpoint(botscript_command_handler),
+            .endpoint(handle_botmessage),
     )
 }
 
-async fn botscript_command_handler(
-    bot: Bot,
-    mut db: DB,
-    bm: BotMessage,
-    msg: Message,
-) -> BotResult<()> {
+async fn handle_botmessage(bot: Bot, mut db: DB, bm: BotMessage, msg: Message) -> BotResult<()> {
     info!("Eval BM: {:?}", bm);
     let tguser = match msg.from.clone() {
         Some(user) => user,

From 866a028de1b55ce10c2c7b29f422d9e282cb1e16 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 28 May 2025 11:10:32 +0500
Subject: [PATCH 105/131] move out bot handlers to separate module

---
 src/handlers/admin.rs | 468 +++++++++++++++++++++++++++++++++++++++++
 src/handlers/mod.rs   |   1 +
 src/main.rs           | 469 +-----------------------------------------
 3 files changed, 475 insertions(+), 463 deletions(-)
 create mode 100644 src/handlers/admin.rs
 create mode 100644 src/handlers/mod.rs

diff --git a/src/handlers/admin.rs b/src/handlers/admin.rs
new file mode 100644
index 0000000..c76a936
--- /dev/null
+++ b/src/handlers/admin.rs
@@ -0,0 +1,468 @@
+use std::str::FromStr;
+
+use itertools::Itertools;
+use log::info;
+use std::time::Duration;
+use teloxide::dispatching::dialogue::serializer::Json;
+use teloxide::prelude::*;
+use teloxide::sugar::request::RequestReplyExt;
+use teloxide::types::{MediaKind, MessageId, MessageKind, ParseMode};
+use teloxide::utils::render::RenderMessageTextHelper;
+use teloxide::{dptree, types::Update};
+
+use crate::admin::{admin_command_handler, AdminCommands};
+use crate::bot_handler::BotHandler;
+use crate::db::message_forward::MessageForward;
+use crate::db::{CallDB, DB};
+use crate::mongodb_storage::MongodbStorage;
+use crate::{BotDialogue, BotError, BotResult, CallbackStore, State};
+
+pub fn admin_handler() -> BotHandler {
+    dptree::entry()
+        .branch(
+            Update::filter_callback_query()
+                .filter_async(async |q: CallbackQuery, mut db: DB| {
+                    let tguser = q.from.clone();
+                    let user = db
+                        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
+                        .await;
+                    user.map(|u| u.is_admin).unwrap_or(false)
+                })
+                .enter_dialogue::<CallbackQuery, MongodbStorage<Json>, State>()
+                .branch(dptree::case![State::EditButton].endpoint(button_edit_callback)),
+        )
+        .branch(command_handler())
+        .branch(
+            Update::filter_message()
+                .filter_async(async |msg: Message, mut db: DB| {
+                    let tguser = match msg.from.clone() {
+                        Some(user) => user,
+                        None => return false, // do nothing, cause its not usecase of function
+                    };
+                    let user = db
+                        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
+                        .await;
+                    user.map(|u| u.is_admin).unwrap_or(false)
+                })
+                .enter_dialogue::<Message, MongodbStorage<Json>, State>()
+                .branch(
+                    Update::filter_message()
+                        .filter(|msg: Message| {
+                            msg.text().unwrap_or("").to_lowercase().as_str() == "edit"
+                        })
+                        .endpoint(edit_msg_cmd_handler),
+                )
+                .branch(
+                    Update::filter_message()
+                        .filter(|msg: Message| msg.reply_to_message().is_some())
+                        .filter(|state: State| matches!(state, State::Start))
+                        .endpoint(support_reply_handler),
+                )
+                .branch(
+                    dptree::case![State::Edit {
+                        literal,
+                        variant,
+                        lang,
+                        is_caption_set
+                    }]
+                    .endpoint(edit_msg_handler),
+                ),
+        )
+        .branch(
+            Update::filter_message()
+                .enter_dialogue::<Message, MongodbStorage<Json>, State>()
+                .branch(dptree::case![State::MessageForwardReply].endpoint(user_reply_to_support)),
+        )
+}
+
+async fn button_edit_callback(
+    bot: Bot,
+    mut db: DB,
+    dialogue: BotDialogue,
+    q: CallbackQuery,
+) -> BotResult<()> {
+    bot.answer_callback_query(&q.id).await?;
+
+    let id = match q.data {
+        Some(id) => id,
+        None => {
+            bot.send_message(q.from.id, "Not compatible callback to edit text on")
+                .await?;
+
+            return Ok(());
+        }
+    };
+
+    let ci = match CallbackStore::get(&mut db, &id).await? {
+        Some(ci) => ci,
+        None => {
+            bot.send_message(
+                q.from.id,
+                "Can't get button information. Maybe created not by this bot or message too old",
+            )
+            .await?;
+
+            return Ok(());
+        }
+    };
+    let literal = match ci.literal {
+        Some(l) => l,
+        None => {
+            bot.send_message(
+                q.from.id,
+                "This button is not editable (probably text is generated)",
+            )
+            .await?;
+
+            return Ok(());
+        }
+    };
+
+    let lang = "ru".to_string();
+    dialogue
+        .update(State::Edit {
+            literal,
+            variant: None,
+            lang,
+            is_caption_set: false,
+        })
+        .await?;
+
+    bot.send_message(q.from.id, "Send text of button").await?;
+
+    Ok(())
+}
+
+fn command_handler() -> BotHandler {
+    Update::filter_message()
+        .filter_async(async |msg: Message, mut db: DB| {
+            let tguser = match msg.from.clone() {
+                Some(user) => user,
+                None => return false, // do nothing, cause its not usecase of function
+            };
+            let user = db
+                .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
+                .await;
+            user.map(|u| u.is_admin).unwrap_or(false)
+        })
+        .filter_command::<AdminCommands>()
+        .enter_dialogue::<Message, MongodbStorage<Json>, State>()
+        .endpoint(admin_command_handler)
+}
+
+async fn edit_msg_cmd_handler(
+    bot: Bot,
+    mut db: DB,
+    dialogue: BotDialogue,
+    msg: Message,
+) -> BotResult<()> {
+    match msg.reply_to_message() {
+        Some(replied) => {
+            let msgid = replied.id;
+            // look for message in db and set text
+            let literal = match db.get_message_literal(msg.chat.id.0, msgid.0).await? {
+                Some(l) => l,
+                None => {
+                    bot.send_message(msg.chat.id, "No such message found to edit. Look if you replying bot's message and this message is supposed to be editable").await?;
+                    return Ok(());
+                }
+            };
+            // TODO: language selector will be implemented in future 😈
+            let lang = "ru".to_string();
+            dialogue
+                .update(State::Edit {
+                    literal,
+                    variant: None,
+                    lang,
+                    is_caption_set: false,
+                })
+                .await?;
+            bot.send_message(
+                msg.chat.id,
+                "Ok, now you have to send message text (formatting supported)\n\
+                 <b>Notice:</b> if this message supposed to replace message (tg shows them as edited) \
+                 or be raplaced, do NOT send message with multiple media, only single photo, video etc. \
+                 To get more information about why, see in /why_media_group",
+            ).parse_mode(ParseMode::Html)
+            .await?;
+        }
+        None => {
+            bot.send_message(msg.chat.id, "You have to reply to message to edit it")
+                .await?;
+        }
+    };
+    Ok(())
+}
+
+async fn support_reply_handler(
+    bot: Bot,
+    mut db: DB,
+    msg: Message,
+    state_mgr: std::sync::Arc<MongodbStorage<Json>>,
+) -> BotResult<()> {
+    use teloxide::utils::render::Renderer;
+
+    let rm = match msg.reply_to_message() {
+        Some(rm) => rm,
+        None => {
+            return Err(BotError::BotLogicError(
+                "support_reply_handler should not be called when no message is replied".to_string(),
+            ));
+        }
+    };
+    let (chat_id, message_id) = (rm.chat.id.0, rm.id.0);
+    let mf = match MessageForward::get(&mut db, chat_id, message_id).await? {
+        Some(mf) => mf,
+        None => {
+            bot.send_message(msg.chat.id, "No forwarded message found for your reply")
+                .await?;
+
+            return Ok(());
+        }
+    };
+
+    let text = match msg.kind {
+        MessageKind::Common(message_common) => match message_common.media_kind {
+            MediaKind::Text(media_text) => {
+                Renderer::new(&media_text.text, &media_text.entities).as_html()
+            }
+            _ => {
+                bot.send_message(msg.chat.id, "Only text messages currently supported!")
+                    .await?;
+                return Ok(());
+            }
+        },
+        // can't hapen because we already have check for reply
+        _ => unreachable!(),
+    };
+
+    let msg = bot
+        .send_message(ChatId(mf.source_chat_id), text)
+        .parse_mode(ParseMode::Html);
+    let msg = match mf.reply {
+        false => msg,
+        true => msg.reply_to(MessageId(mf.source_message_id)),
+    };
+    msg.await?;
+
+    let user_dialogue = BotDialogue::new(state_mgr, ChatId(mf.source_chat_id));
+    user_dialogue.update(State::MessageForwardReply).await?;
+
+    Ok(())
+}
+
+async fn edit_msg_handler(
+    bot: Bot,
+    mut db: DB,
+    dialogue: BotDialogue,
+    (literal, variant, lang, is_caption_set): (String, Option<String>, String, bool),
+    msg: Message,
+) -> BotResult<()> {
+    use teloxide::utils::render::Renderer;
+
+    let chat_id = msg.chat.id;
+    info!("Type: {:#?}", msg.kind);
+    let msg = if let MessageKind::Common(msg) = msg.kind {
+        msg
+    } else {
+        info!("Not a Common, somehow");
+        return Ok(());
+    };
+
+    if let Some(variant) = variant {
+        if let MediaKind::Text(text) = msg.media_kind {
+            let html_text = Renderer::new(&text.text, &text.entities).as_html();
+
+            db.set_literal_alternative(&literal, &variant, &html_text)
+                .await?;
+            bot.send_message(chat_id, "Updated text of variant!")
+                .await?;
+
+            dialogue.exit().await?;
+            return Ok(());
+        } else {
+            bot.send_message(
+                chat_id,
+                "On variants only text alternating supported. Try to send text only",
+            )
+            .await?;
+
+            return Ok(());
+        }
+    };
+
+    match msg.media_kind {
+        MediaKind::Text(text) => {
+            db.drop_media(&literal).await?;
+            if is_caption_set {
+                return Ok(());
+            };
+            let html_text = Renderer::new(&text.text, &text.entities).as_html();
+            db.set_literal(&literal, &html_text).await?;
+            bot.send_message(chat_id, "Updated text of message!")
+                .await?;
+            dialogue.exit().await?;
+        }
+        MediaKind::Photo(photo) => {
+            let group = photo.media_group_id;
+            if let Some(group) = group.clone() {
+                db.drop_media_except(&literal, &group).await?;
+            } else {
+                db.drop_media(&literal).await?;
+            }
+            let file_id = photo.photo[0].file.id.clone();
+            db.add_media(&literal, "photo", &file_id, group.as_deref())
+                .await?;
+            match photo.caption {
+                Some(text) => {
+                    let html_text = Renderer::new(&text, &photo.caption_entities).as_html();
+                    db.set_literal(&literal, &html_text).await?;
+                    bot.send_message(chat_id, "Updated photo caption!").await?;
+                }
+                None => {
+                    // if it is a first message in group,
+                    // or just a photo without caption (unwrap_or case),
+                    // set text empty
+                    if !db
+                        .is_media_group_exists(group.as_deref().unwrap_or(""))
+                        .await?
+                    {
+                        db.set_literal(&literal, "").await?;
+                        bot.send_message(chat_id, "Set photo without caption")
+                            .await?;
+                    };
+                }
+            }
+            // Some workaround because Telegram's group system
+            // is not easily and obviously handled with this
+            // code architecture, but probably there is a solution.
+            //
+            // So, this code will just wait for all media group
+            // updates to be processed
+            dialogue
+                .update(State::Edit {
+                    literal,
+                    variant: None,
+                    lang,
+                    is_caption_set: true,
+                })
+                .await?;
+            tokio::spawn(async move {
+                tokio::time::sleep(Duration::from_millis(200)).await;
+                dialogue.exit().await.unwrap_or(());
+            });
+        }
+        MediaKind::Video(video) => {
+            let group = video.media_group_id;
+            if let Some(group) = group.clone() {
+                db.drop_media_except(&literal, &group).await?;
+            } else {
+                db.drop_media(&literal).await?;
+            }
+            let file_id = video.video.file.id;
+            db.add_media(&literal, "video", &file_id, group.as_deref())
+                .await?;
+            match video.caption {
+                Some(text) => {
+                    let html_text = Renderer::new(&text, &video.caption_entities).as_html();
+                    db.set_literal(&literal, &html_text).await?;
+                    bot.send_message(chat_id, "Updated video caption!").await?;
+                }
+                None => {
+                    // if it is a first message in group,
+                    // or just a video without caption (unwrap_or case),
+                    // set text empty
+                    if !db
+                        .is_media_group_exists(group.as_deref().unwrap_or(""))
+                        .await?
+                    {
+                        db.set_literal(&literal, "").await?;
+                        bot.send_message(chat_id, "Set video without caption")
+                            .await?;
+                    };
+                }
+            }
+            // Some workaround because Telegram's group system
+            // is not easily and obviously handled with this
+            // code architecture, but probably there is a solution.
+            //
+            // So, this code will just wait for all media group
+            // updates to be processed
+            dialogue
+                .update(State::Edit {
+                    literal,
+                    variant: None,
+                    lang,
+                    is_caption_set: true,
+                })
+                .await?;
+            tokio::spawn(async move {
+                tokio::time::sleep(Duration::from_millis(200)).await;
+                dialogue.exit().await.unwrap_or(());
+            });
+        }
+        _ => {
+            bot.send_message(chat_id, "this type of message is not supported yet")
+                .await?;
+        }
+    }
+
+    Ok(())
+}
+
+async fn user_reply_to_support(bot: Bot, mut db: DB, msg: Message) -> BotResult<()> {
+    let (source_chat_id, source_message_id) = (msg.chat.id.0, msg.id.0);
+    let text = match msg.html_text() {
+        Some(text) => text,
+        // TODO: come up with better idea than just ignoring (say something to user)
+        None => return Ok(()),
+    };
+    let scid =
+        db.get_literal_value("support_chat_id")
+            .await?
+            .ok_or(BotError::AdminMisconfiguration(
+                "support_chat_id is not set".to_string(),
+            ))?;
+    let support_chat_id = match scid.parse::<i64>() {
+        Ok(cid) => cid,
+        Err(parseerr) => {
+            return Err(BotError::BotLogicError(format!(
+                "source_chat_id, got: {scid}, expected: i64, err: {parseerr}"
+            )))
+        }
+    };
+    let user = msg.from.ok_or(BotError::BotLogicError(
+        "Unable to get user somehow:/".to_string(),
+    ))?;
+    let parts = [
+        Some(user.first_name),
+        user.last_name,
+        user.username.map(|un| format!("(@{un})")),
+    ];
+    #[allow(unstable_name_collisions)]
+    let userformat: String = parts
+        .into_iter()
+        .flatten()
+        .intersperse(" ".to_string())
+        .collect();
+    let msgtext = format!("From: {userformat}\nMessage:\n{text}");
+
+    // TODO: fix bug: parse mode's purpose is to display user-formated text in right way,
+    // but there is a bug: user can inject html code with his first/last/user name
+    // it's not harmful, only visible to support, but still need a fix
+    let sentmsg = bot
+        .send_message(ChatId(support_chat_id), msgtext)
+        .parse_mode(ParseMode::Html)
+        .await?;
+    MessageForward::new(
+        sentmsg.chat.id.0,
+        sentmsg.id.0,
+        source_chat_id,
+        source_message_id,
+        true,
+    )
+    .store(&mut db)
+    .await?;
+
+    Ok(())
+}
diff --git a/src/handlers/mod.rs b/src/handlers/mod.rs
new file mode 100644
index 0000000..92918b0
--- /dev/null
+++ b/src/handlers/mod.rs
@@ -0,0 +1 @@
+pub mod admin;
diff --git a/src/main.rs b/src/main.rs
index dbc2786..694bf65 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,6 +4,7 @@ pub mod bot_manager;
 pub mod botscript;
 pub mod commands;
 pub mod db;
+pub mod handlers;
 pub mod message_answerer;
 pub mod mongodb_storage;
 pub mod utils;
@@ -222,61 +223,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 })
                 .endpoint(botscript_command_handler),
         )
-        .branch(
-            Update::filter_callback_query()
-                .filter_async(async |q: CallbackQuery, mut db: DB| {
-                    let tguser = q.from.clone();
-                    let user = db
-                        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
-                        .await;
-                    user.map(|u| u.is_admin).unwrap_or(false)
-                })
-                .enter_dialogue::<CallbackQuery, MongodbStorage<Json>, State>()
-                .branch(dptree::case![State::EditButton].endpoint(button_edit_callback)),
-        )
-        .branch(Update::filter_callback_query().endpoint(callback_handler))
-        .branch(command_handler(config))
-        .branch(
-            Update::filter_message()
-                .filter_async(async |msg: Message, mut db: DB| {
-                    let tguser = match msg.from.clone() {
-                        Some(user) => user,
-                        None => return false, // do nothing, cause its not usecase of function
-                    };
-                    let user = db
-                        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
-                        .await;
-                    user.map(|u| u.is_admin).unwrap_or(false)
-                })
-                .enter_dialogue::<Message, MongodbStorage<Json>, State>()
-                .branch(
-                    Update::filter_message()
-                        .filter(|msg: Message| {
-                            msg.text().unwrap_or("").to_lowercase().as_str() == "edit"
-                        })
-                        .endpoint(edit_msg_cmd_handler),
-                )
-                .branch(
-                    Update::filter_message()
-                        .filter(|msg: Message| msg.reply_to_message().is_some())
-                        .filter(|state: State| matches!(state, State::Start))
-                        .endpoint(support_reply_handler),
-                )
-                .branch(
-                    dptree::case![State::Edit {
-                        literal,
-                        variant,
-                        lang,
-                        is_caption_set
-                    }]
-                    .endpoint(edit_msg_handler),
-                ),
-        )
-        .branch(
-            Update::filter_message()
-                .enter_dialogue::<Message, MongodbStorage<Json>, State>()
-                .branch(dptree::case![State::MessageForwardReply].endpoint(user_reply_to_support)),
-        )
+        // .branch(
+        //     Update::filter_message()
+        //         .enter_dialogue::<Message, MongodbStorage<Json>, State>()
+        //         .branch(dptree::case![State::MessageForwardReply].endpoint(user_reply_to_support)),
+        // )
         .branch(Update::filter_message().endpoint(echo));
 
     Dispatcher::builder(bc.bot, handler)
@@ -323,178 +274,6 @@ async fn botscript_command_handler(
     Ok(())
 }
 
-async fn user_reply_to_support(bot: Bot, mut db: DB, msg: Message) -> BotResult<()> {
-    let (source_chat_id, source_message_id) = (msg.chat.id.0, msg.id.0);
-    let text = match msg.html_text() {
-        Some(text) => text,
-        // TODO: come up with better idea than just ignoring (say something to user)
-        None => return Ok(()),
-    };
-    let scid =
-        db.get_literal_value("support_chat_id")
-            .await?
-            .ok_or(BotError::AdminMisconfiguration(
-                "support_chat_id is not set".to_string(),
-            ))?;
-    let support_chat_id = match scid.parse::<i64>() {
-        Ok(cid) => cid,
-        Err(parseerr) => {
-            return Err(BotError::BotLogicError(format!(
-                "source_chat_id, got: {scid}, expected: i64, err: {parseerr}"
-            )))
-        }
-    };
-    let user = msg.from.ok_or(BotError::BotLogicError(
-        "Unable to get user somehow:/".to_string(),
-    ))?;
-    let parts = [
-        Some(user.first_name),
-        user.last_name,
-        user.username.map(|un| format!("(@{un})")),
-    ];
-    #[allow(unstable_name_collisions)]
-    let userformat: String = parts
-        .into_iter()
-        .flatten()
-        .intersperse(" ".to_string())
-        .collect();
-    let msgtext = format!("From: {userformat}\nMessage:\n{text}");
-
-    // TODO: fix bug: parse mode's purpose is to display user-formated text in right way,
-    // but there is a bug: user can inject html code with his first/last/user name
-    // it's not harmful, only visible to support, but still need a fix
-    let sentmsg = bot
-        .send_message(ChatId(support_chat_id), msgtext)
-        .parse_mode(ParseMode::Html)
-        .await?;
-    MessageForward::new(
-        sentmsg.chat.id.0,
-        sentmsg.id.0,
-        source_chat_id,
-        source_message_id,
-        true,
-    )
-    .store(&mut db)
-    .await?;
-
-    Ok(())
-}
-
-async fn support_reply_handler(
-    bot: Bot,
-    mut db: DB,
-    msg: Message,
-    state_mgr: std::sync::Arc<MongodbStorage<Json>>,
-) -> BotResult<()> {
-    use teloxide::utils::render::Renderer;
-
-    let rm = match msg.reply_to_message() {
-        Some(rm) => rm,
-        None => {
-            return Err(BotError::BotLogicError(
-                "support_reply_handler should not be called when no message is replied".to_string(),
-            ));
-        }
-    };
-    let (chat_id, message_id) = (rm.chat.id.0, rm.id.0);
-    let mf = match MessageForward::get(&mut db, chat_id, message_id).await? {
-        Some(mf) => mf,
-        None => {
-            bot.send_message(msg.chat.id, "No forwarded message found for your reply")
-                .await?;
-
-            return Ok(());
-        }
-    };
-
-    let text = match msg.kind {
-        MessageKind::Common(message_common) => match message_common.media_kind {
-            MediaKind::Text(media_text) => {
-                Renderer::new(&media_text.text, &media_text.entities).as_html()
-            }
-            _ => {
-                bot.send_message(msg.chat.id, "Only text messages currently supported!")
-                    .await?;
-                return Ok(());
-            }
-        },
-        // can't hapen because we already have check for reply
-        _ => unreachable!(),
-    };
-
-    let msg = bot
-        .send_message(ChatId(mf.source_chat_id), text)
-        .parse_mode(ParseMode::Html);
-    let msg = match mf.reply {
-        false => msg,
-        true => msg.reply_to(MessageId(mf.source_message_id)),
-    };
-    msg.await?;
-
-    let user_dialogue = BotDialogue::new(state_mgr, ChatId(mf.source_chat_id));
-    user_dialogue.update(State::MessageForwardReply).await?;
-
-    Ok(())
-}
-
-async fn button_edit_callback(
-    bot: Bot,
-    mut db: DB,
-    dialogue: BotDialogue,
-    q: CallbackQuery,
-) -> BotResult<()> {
-    bot.answer_callback_query(&q.id).await?;
-
-    let id = match q.data {
-        Some(id) => id,
-        None => {
-            bot.send_message(q.from.id, "Not compatible callback to edit text on")
-                .await?;
-
-            return Ok(());
-        }
-    };
-
-    let ci = match CallbackStore::get(&mut db, &id).await? {
-        Some(ci) => ci,
-        None => {
-            bot.send_message(
-                q.from.id,
-                "Can't get button information. Maybe created not by this bot or message too old",
-            )
-            .await?;
-
-            return Ok(());
-        }
-    };
-    let literal = match ci.literal {
-        Some(l) => l,
-        None => {
-            bot.send_message(
-                q.from.id,
-                "This button is not editable (probably text is generated)",
-            )
-            .await?;
-
-            return Ok(());
-        }
-    };
-
-    let lang = "ru".to_string();
-    dialogue
-        .update(State::Edit {
-            literal,
-            variant: None,
-            lang,
-            is_caption_set: false,
-        })
-        .await?;
-
-    bot.send_message(q.from.id, "Send text of button").await?;
-
-    Ok(())
-}
-
 async fn callback_handler(bot: Bot, mut db: DB, q: CallbackQuery) -> BotResult<()> {
     bot.answer_callback_query(&q.id).await?;
 
@@ -689,242 +468,6 @@ async fn notify_admin(text: &str) {
     }
 }
 
-async fn edit_msg_cmd_handler(
-    bot: Bot,
-    mut db: DB,
-    dialogue: BotDialogue,
-    msg: Message,
-) -> BotResult<()> {
-    match msg.reply_to_message() {
-        Some(replied) => {
-            let msgid = replied.id;
-            // look for message in db and set text
-            let literal = match db.get_message_literal(msg.chat.id.0, msgid.0).await? {
-                Some(l) => l,
-                None => {
-                    bot.send_message(msg.chat.id, "No such message found to edit. Look if you replying bot's message and this message is supposed to be editable").await?;
-                    return Ok(());
-                }
-            };
-            // TODO: language selector will be implemented in future 😈
-            let lang = "ru".to_string();
-            dialogue
-                .update(State::Edit {
-                    literal,
-                    variant: None,
-                    lang,
-                    is_caption_set: false,
-                })
-                .await?;
-            bot.send_message(
-                msg.chat.id,
-                "Ok, now you have to send message text (formatting supported)\n\
-                 <b>Notice:</b> if this message supposed to replace message (tg shows them as edited) \
-                 or be raplaced, do NOT send message with multiple media, only single photo, video etc. \
-                 To get more information about why, see in /why_media_group",
-            ).parse_mode(ParseMode::Html)
-            .await?;
-        }
-        None => {
-            bot.send_message(msg.chat.id, "You have to reply to message to edit it")
-                .await?;
-        }
-    };
-    Ok(())
-}
-
-async fn edit_msg_handler(
-    bot: Bot,
-    mut db: DB,
-    dialogue: BotDialogue,
-    (literal, variant, lang, is_caption_set): (String, Option<String>, String, bool),
-    msg: Message,
-) -> BotResult<()> {
-    use teloxide::utils::render::Renderer;
-
-    let chat_id = msg.chat.id;
-    info!("Type: {:#?}", msg.kind);
-    let msg = if let MessageKind::Common(msg) = msg.kind {
-        msg
-    } else {
-        info!("Not a Common, somehow");
-        return Ok(());
-    };
-
-    if let Some(variant) = variant {
-        if let MediaKind::Text(text) = msg.media_kind {
-            let html_text = Renderer::new(&text.text, &text.entities).as_html();
-
-            db.set_literal_alternative(&literal, &variant, &html_text)
-                .await?;
-            bot.send_message(chat_id, "Updated text of variant!")
-                .await?;
-
-            dialogue.exit().await?;
-            return Ok(());
-        } else {
-            bot.send_message(
-                chat_id,
-                "On variants only text alternating supported. Try to send text only",
-            )
-            .await?;
-
-            return Ok(());
-        }
-    };
-
-    match msg.media_kind {
-        MediaKind::Text(text) => {
-            db.drop_media(&literal).await?;
-            if is_caption_set {
-                return Ok(());
-            };
-            let html_text = Renderer::new(&text.text, &text.entities).as_html();
-            db.set_literal(&literal, &html_text).await?;
-            bot.send_message(chat_id, "Updated text of message!")
-                .await?;
-            dialogue.exit().await?;
-        }
-        MediaKind::Photo(photo) => {
-            let group = photo.media_group_id;
-            if let Some(group) = group.clone() {
-                db.drop_media_except(&literal, &group).await?;
-            } else {
-                db.drop_media(&literal).await?;
-            }
-            let file_id = photo.photo[0].file.id.clone();
-            db.add_media(&literal, "photo", &file_id, group.as_deref())
-                .await?;
-            match photo.caption {
-                Some(text) => {
-                    let html_text = Renderer::new(&text, &photo.caption_entities).as_html();
-                    db.set_literal(&literal, &html_text).await?;
-                    bot.send_message(chat_id, "Updated photo caption!").await?;
-                }
-                None => {
-                    // if it is a first message in group,
-                    // or just a photo without caption (unwrap_or case),
-                    // set text empty
-                    if !db
-                        .is_media_group_exists(group.as_deref().unwrap_or(""))
-                        .await?
-                    {
-                        db.set_literal(&literal, "").await?;
-                        bot.send_message(chat_id, "Set photo without caption")
-                            .await?;
-                    };
-                }
-            }
-            // Some workaround because Telegram's group system
-            // is not easily and obviously handled with this
-            // code architecture, but probably there is a solution.
-            //
-            // So, this code will just wait for all media group
-            // updates to be processed
-            dialogue
-                .update(State::Edit {
-                    literal,
-                    variant: None,
-                    lang,
-                    is_caption_set: true,
-                })
-                .await?;
-            tokio::spawn(async move {
-                tokio::time::sleep(Duration::from_millis(200)).await;
-                dialogue.exit().await.unwrap_or(());
-            });
-        }
-        MediaKind::Video(video) => {
-            let group = video.media_group_id;
-            if let Some(group) = group.clone() {
-                db.drop_media_except(&literal, &group).await?;
-            } else {
-                db.drop_media(&literal).await?;
-            }
-            let file_id = video.video.file.id;
-            db.add_media(&literal, "video", &file_id, group.as_deref())
-                .await?;
-            match video.caption {
-                Some(text) => {
-                    let html_text = Renderer::new(&text, &video.caption_entities).as_html();
-                    db.set_literal(&literal, &html_text).await?;
-                    bot.send_message(chat_id, "Updated video caption!").await?;
-                }
-                None => {
-                    // if it is a first message in group,
-                    // or just a video without caption (unwrap_or case),
-                    // set text empty
-                    if !db
-                        .is_media_group_exists(group.as_deref().unwrap_or(""))
-                        .await?
-                    {
-                        db.set_literal(&literal, "").await?;
-                        bot.send_message(chat_id, "Set video without caption")
-                            .await?;
-                    };
-                }
-            }
-            // Some workaround because Telegram's group system
-            // is not easily and obviously handled with this
-            // code architecture, but probably there is a solution.
-            //
-            // So, this code will just wait for all media group
-            // updates to be processed
-            dialogue
-                .update(State::Edit {
-                    literal,
-                    variant: None,
-                    lang,
-                    is_caption_set: true,
-                })
-                .await?;
-            tokio::spawn(async move {
-                tokio::time::sleep(Duration::from_millis(200)).await;
-                dialogue.exit().await.unwrap_or(());
-            });
-        }
-        _ => {
-            bot.send_message(chat_id, "this type of message is not supported yet")
-                .await?;
-        }
-    }
-
-    Ok(())
-}
-
-fn command_handler(
-    config: Config,
-) -> Handler<'static, DependencyMap, BotResult<()>, teloxide::dispatching::DpHandlerDescription> {
-    Update::filter_message()
-        .branch(
-            dptree::entry()
-                .filter_command::<UserCommands>()
-                .endpoint(user_command_handler),
-        )
-        .branch(
-            dptree::entry()
-                .filter_command::<SecretCommands>()
-                .map(move || config.admin_password.clone())
-                .endpoint(secret_command_handler),
-        )
-        .branch(
-            dptree::entry()
-                .filter_async(async |msg: Message, mut db: DB| {
-                    let tguser = match msg.from.clone() {
-                        Some(user) => user,
-                        None => return false, // do nothing, cause its not usecase of function
-                    };
-                    let user = db
-                        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
-                        .await;
-                    user.map(|u| u.is_admin).unwrap_or(false)
-                })
-                .filter_command::<AdminCommands>()
-                .enter_dialogue::<Message, MongodbStorage<Json>, State>()
-                .endpoint(admin_command_handler),
-        )
-}
-
 async fn user_command_handler(
     mut db: DB,
     bot: Bot,

From 67ad3c2acdf5afb8a73ab1f46bbe33f9c742880d Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Wed, 28 May 2025 11:11:25 +0500
Subject: [PATCH 106/131] plug provided handlers in start_bot

---
 src/bot_manager.rs | 21 ++++++++++++++++-----
 src/main.rs        |  3 ++-
 2 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/bot_manager.rs b/src/bot_manager.rs
index 4e05966..3cfa0eb 100644
--- a/src/bot_manager.rs
+++ b/src/bot_manager.rs
@@ -9,7 +9,7 @@ use teloxide::{
 };
 
 use crate::{
-    bot_handler::script_handler,
+    bot_handler::{script_handler, BotHandler},
     db::{bots::BotInstance, DbError, DB},
     mongodb_storage::MongodbStorage,
     BotController, BotError, BotResult,
@@ -47,11 +47,23 @@ pub async fn create_bot(db: &mut DB, token: &str) -> BotResult<BotInstance> {
     Ok(bi)
 }
 
-pub async fn start_bot(bi: BotInstance, db: &mut DB) -> BotResult<BotInfo> {
+pub async fn start_bot(
+    bi: BotInstance,
+    db: &mut DB,
+    plug_handlers: Vec<BotHandler>,
+) -> BotResult<BotInfo> {
     let mut db = db.clone().with_name(bi.name.clone());
     let controller = BotController::with_db(db.clone(), &bi.token, &bi.script).await?;
 
-    let thread = spawn_bot_thread(controller.clone(), &mut db).await?;
+    let handler = script_handler(controller.rc.clone());
+    // each handler will be added to dptree::entry()
+    let handler = plug_handlers
+        .into_iter()
+        // as well as the script handler at the end
+        .chain(std::iter::once(handler))
+        .fold(dptree::entry(), |h, plug| h.branch(plug));
+
+    let thread = spawn_bot_thread(controller.clone(), &mut db, handler).await?;
 
     let info = BotInfo {
         name: bi.name.clone(),
@@ -80,6 +92,7 @@ pub async fn start_bot(bi: BotInstance, db: &mut DB) -> BotResult<BotInfo> {
 pub async fn spawn_bot_thread(
     bc: BotController,
     db: &mut DB,
+    handler: BotHandler,
 ) -> BotResult<JoinHandle<BotResult<()>>> {
     let state_mgr = MongodbStorage::from_db(db, Json)
         .await
@@ -87,8 +100,6 @@ pub async fn spawn_bot_thread(
     let thread = std::thread::spawn(move || -> BotResult<()> {
         let state_mgr = state_mgr;
 
-        let handler = script_handler(bc.rc);
-
         let rt = tokio::runtime::Builder::new_current_thread()
             .enable_all()
             .build()?;
diff --git a/src/main.rs b/src/main.rs
index 694bf65..3b24ff5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -16,6 +16,7 @@ use db::application::Application;
 use db::bots::BotInstance;
 use db::callback_info::CallbackInfo;
 use db::message_forward::MessageForward;
+use handlers::admin::admin_handler;
 use itertools::Itertools;
 use log::{error, info, warn};
 use message_answerer::MessageAnswerer;
@@ -184,7 +185,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let state_mgr = MongodbStorage::open(config.db_url.clone().as_ref(), "gongbot", Json).await?;
 
     for bi in BotInstance::get_all(&mut bc.db).await? {
-        let info = start_bot(bi, &mut bc.db).await?;
+        let info = start_bot(bi, &mut bc.db, vec![admin_handler()]).await?;
         println!("Started bot: {}", info.name);
     }
 

From fde70871729cef214bea828b3230f817e35cfce9 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:28:22 +0500
Subject: [PATCH 107/131] create /newscript command handler

---
 src/handlers/admin.rs | 66 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 65 insertions(+), 1 deletion(-)

diff --git a/src/handlers/admin.rs b/src/handlers/admin.rs
index c76a936..29a2c34 100644
--- a/src/handlers/admin.rs
+++ b/src/handlers/admin.rs
@@ -1,17 +1,21 @@
 use std::str::FromStr;
 
 use itertools::Itertools;
-use log::info;
+use log::{info, warn};
 use std::time::Duration;
 use teloxide::dispatching::dialogue::serializer::Json;
+use teloxide::net::Download;
 use teloxide::prelude::*;
 use teloxide::sugar::request::RequestReplyExt;
 use teloxide::types::{MediaKind, MessageId, MessageKind, ParseMode};
 use teloxide::utils::render::RenderMessageTextHelper;
 use teloxide::{dptree, types::Update};
 
+use futures::StreamExt;
+
 use crate::admin::{admin_command_handler, AdminCommands};
 use crate::bot_handler::BotHandler;
+use crate::db::bots::BotInstance;
 use crate::db::message_forward::MessageForward;
 use crate::db::{CallDB, DB};
 use crate::mongodb_storage::MongodbStorage;
@@ -52,6 +56,21 @@ pub fn admin_handler() -> BotHandler {
                         })
                         .endpoint(edit_msg_cmd_handler),
                 )
+                .branch(
+                    Update::filter_message()
+                        .filter_map(|msg: Message| {
+                            let text = msg.caption().unwrap_or("");
+                            let mut parts = text.split_whitespace();
+                            let cmd = parts.next().unwrap_or("");
+                            let arg = parts.next().unwrap_or("");
+
+                            match cmd.to_lowercase().as_str() == "/newscript" {
+                                true => Some(arg.to_string()),
+                                false => None,
+                            }
+                        })
+                        .endpoint(newscript_handler),
+                )
                 .branch(
                     Update::filter_message()
                         .filter(|msg: Message| msg.reply_to_message().is_some())
@@ -74,6 +93,51 @@ pub fn admin_handler() -> BotHandler {
                 .branch(dptree::case![State::MessageForwardReply].endpoint(user_reply_to_support)),
         )
 }
+async fn newscript_handler(bot: Bot, mut db: DB, msg: Message, name: String) -> BotResult<()> {
+    let script = match msg.kind {
+        MessageKind::Common(message) => {
+            match message.media_kind {
+                MediaKind::Document(media_document) => {
+                    let doc = media_document.document;
+                    let file = bot.get_file(doc.file.id).await?;
+                    let mut stream = bot.download_file_stream(&file.path);
+                    let mut buf: Vec<u8> = Vec::new();
+                    while let Some(bytes) = stream.next().await {
+                        let mut bytes = bytes.unwrap().to_vec();
+                        buf.append(&mut bytes);
+                    }
+                    let script = match String::from_utf8(buf) {
+                        Ok(s) => s,
+                        Err(err) => {
+                            warn!("Failed to parse buf to string, err: {err}");
+                            bot.send_message(msg.chat.id, format!("Failed to Convert file to script: file is not UTF-8, err: {err}")).await?;
+                            return Ok(());
+                        }
+                    };
+                    script
+                }
+                _ => todo!(),
+            }
+        }
+        _ => todo!(),
+    };
+
+    match BotInstance::get_by_name(&mut db, &name).await? {
+        Some(bi) => bi,
+        None => {
+            bot.send_message(
+                msg.chat.id,
+                format!("Failed to set script, possibly bots name is incorrent"),
+            )
+            .await?;
+            return Ok(());
+        }
+    };
+    BotInstance::update_script(&mut db, &name, &script).await?;
+
+    bot.send_message(msg.chat.id, "New script is set!").await?;
+    Ok(())
+}
 
 async fn button_edit_callback(
     bot: Bot,

From bc2397a32ceeda84bfe19dd0d4861aa605e4bc10 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:29:03 +0500
Subject: [PATCH 108/131] derive Clone for BotInstance

---
 src/db/bots.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/db/bots.rs b/src/db/bots.rs
index 44bc500..6f8f097 100644
--- a/src/db/bots.rs
+++ b/src/db/bots.rs
@@ -11,7 +11,7 @@ use crate::db::GetCollection;
 use crate::query_call_consume;
 use crate::CallDB;
 
-#[derive(Serialize, Deserialize, Default)]
+#[derive(Serialize, Deserialize, Default, Clone)]
 pub struct BotInstance {
     pub _id: bson::oid::ObjectId,
     pub name: String,

From 102fae25c710714eedc56c09f77929de7f903e63 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:30:03 +0500
Subject: [PATCH 109/131] create BotInstance::get_by_name

---
 src/db/bots.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/db/bots.rs b/src/db/bots.rs
index 6f8f097..1c4f27b 100644
--- a/src/db/bots.rs
+++ b/src/db/bots.rs
@@ -48,4 +48,10 @@ impl BotInstance {
 
         Ok(bi.find(doc! {}).await?.try_collect().await?)
     }
+
+    pub async fn get_by_name<D: CallDB>(db: &mut D, name: &str) -> DbResult<Option<Self>> {
+        let bi = db.get_collection::<Self>().await;
+
+        Ok(bi.find_one(doc! {"name": name}).await?)
+    }
 }

From 308b15ed692f03b32d1ac6550296bf43b6028747 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:30:39 +0500
Subject: [PATCH 110/131] create BotInstance::restart_one and restart_all

---
 src/db/bots.rs | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/db/bots.rs b/src/db/bots.rs
index 1c4f27b..c711b77 100644
--- a/src/db/bots.rs
+++ b/src/db/bots.rs
@@ -17,6 +17,7 @@ pub struct BotInstance {
     pub name: String,
     pub token: String,
     pub script: String,
+    pub restart_flag: bool,
     pub created_at: DateTime<FixedOffset>,
 }
 
@@ -31,6 +32,7 @@ impl BotInstance {
             name,
             token,
             script,
+            restart_flag: false,
             created_at: Local::now().into(),
         }
     }
@@ -54,4 +56,23 @@ impl BotInstance {
 
         Ok(bi.find_one(doc! {"name": name}).await?)
     }
+
+    pub async fn restart_one<D: CallDB>(db: &mut D, name: &str, restart: bool) -> DbResult<()> {
+        let bi = db.get_collection::<Self>().await;
+
+        bi.update_one(
+            doc! {"name": name},
+            doc! { "$set": { "restart_flag": restart } },
+        )
+        .await?;
+        Ok(())
+    }
+
+    pub async fn restart_all<D: CallDB>(db: &mut D, restart: bool) -> DbResult<()> {
+        let bi = db.get_collection::<Self>().await;
+
+        bi.update_many(doc! {}, doc! { "$set": { "restart_flag": restart } })
+            .await?;
+        Ok(())
+    }
 }

From 39e376195c0ccd4e74d6dc9b302356f1cfaaaf17 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:31:09 +0500
Subject: [PATCH 111/131] create BotInstance::update_script

---
 src/db/bots.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/db/bots.rs b/src/db/bots.rs
index c711b77..cd412ae 100644
--- a/src/db/bots.rs
+++ b/src/db/bots.rs
@@ -75,4 +75,19 @@ impl BotInstance {
             .await?;
         Ok(())
     }
+
+    pub async fn update_script<D: CallDB>(db: &mut D, name: &str, script: &str) -> DbResult<()> {
+        let bi = db.get_collection::<Self>().await;
+
+        bi.update_one(
+            doc! {"name": name},
+            doc! { "$set": {
+                    "script": script,
+                    "restart_flag": true,
+                }
+            },
+        )
+        .await?;
+        Ok(())
+    }
 }

From fdf1e352a66beedefee88237dbaa3d6485bf04ba Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:33:26 +0500
Subject: [PATCH 112/131] add buttons field to BotDialog

---
 src/botscript.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index ba6db4e..ad1364f 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -562,6 +562,7 @@ impl Parcelable<BotFunction> for BotMessage {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BotDialog {
     pub commands: HashMap<String, BotMessage>,
+    pub buttons: HashMap<String, BotMessage>,
     stateful_msg_handlers: HashMap<String, BotMessage>,
 }
 
@@ -569,6 +570,7 @@ impl Parcelable<BotFunction> for BotDialog {
     fn get_field(&mut self, name: &str) -> Result<ParcelType<BotFunction>, ParcelableError> {
         match name {
             "commands" => Ok(ParcelType::Parcelable(&mut self.commands)),
+            "buttons" => Ok(ParcelType::Parcelable(&mut self.buttons)),
             "stateful_msg_handlers" => Ok(ParcelType::Parcelable(&mut self.stateful_msg_handlers)),
             field => Err(ParcelableError::FieldError(format!(
                 "tried to get field {field}, but this field does not exists or private"

From 474795bd999dcb8371f400ebadee8139308cda8b Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:34:06 +0500
Subject: [PATCH 113/131] create RunnerConfig.get_callback_message

---
 src/botscript.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index ad1364f..2fd1576 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -592,6 +592,12 @@ impl RunnerConfig {
 
         bm.map(|bm| bm.fill_literal(command.to_string()))
     }
+
+    pub fn get_callback_message(&self, callback: &str) -> Option<BotMessage> {
+        let bm = self.dialog.buttons.get(callback).cloned();
+
+        bm.map(|bm| bm.fill_literal(callback.to_string()))
+    }
 }
 
 impl Parcelable<BotFunction> for RunnerConfig {

From 3bd16a58cd5083807e298705fc52959180234cc0 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:34:29 +0500
Subject: [PATCH 114/131] add replace flag to BotMessage

---
 src/botscript.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 2fd1576..5d6324c 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -479,6 +479,8 @@ pub struct Button {
 pub struct BotMessage {
     // buttons: Vec<Button>
     literal: Option<String>,
+    #[serde(default)]
+    replace: bool,
     buttons: Option<KeyboardDefinition>,
     state: Option<String>,
 
@@ -492,6 +494,10 @@ impl BotMessage {
             ..self.clone()
         }
     }
+
+    pub fn is_replace(&self) -> bool {
+        self.replace
+    }
 }
 
 impl BotMessage {

From 22025cde110eb6c3ee21b39ab72e53b1cd5a8ac9 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:35:52 +0500
Subject: [PATCH 115/131] handle callbacks in script_handler

---
 src/bot_handler.rs | 114 ++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 98 insertions(+), 16 deletions(-)

diff --git a/src/bot_handler.rs b/src/bot_handler.rs
index f8e8355..1b9e7bc 100644
--- a/src/bot_handler.rs
+++ b/src/bot_handler.rs
@@ -4,10 +4,10 @@ use std::{
     sync::{Arc, RwLock},
 };
 use teloxide::{
-    dispatching::UpdateFilterExt,
+    dispatching::{dialogue::GetChatId, UpdateFilterExt},
     dptree::{self, Handler},
     prelude::DependencyMap,
-    types::{InlineKeyboardButton, InlineKeyboardMarkup, Message, Update},
+    types::{CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, Message, Update},
     Bot,
 };
 
@@ -16,28 +16,42 @@ use crate::{
     commands::BotCommand,
     db::{CallDB, DB},
     message_answerer::MessageAnswerer,
-    update_user_tg, BotResult,
+    update_user_tg, BotError, BotResult,
 };
 
 pub type BotHandler =
     Handler<'static, DependencyMap, BotResult<()>, teloxide::dispatching::DpHandlerDescription>;
 
 pub fn script_handler(rc: Arc<RwLock<RunnerConfig>>) -> BotHandler {
-    dptree::entry().branch(
-        Update::filter_message()
-            // check if message is command
-            .filter_map(|m: Message| m.text().and_then(|t| BotCommand::from_str(t).ok()))
-            // check if command is presented in config
-            .filter_map(move |bc: BotCommand| {
-                let rc = std::sync::Arc::clone(&rc);
-                let command = bc.command();
+    let crc = rc.clone();
+    dptree::entry()
+        .branch(
+            Update::filter_message()
+                // check if message is command
+                .filter_map(|m: Message| m.text().and_then(|t| BotCommand::from_str(t).ok()))
+                // check if command is presented in config
+                .filter_map(move |bc: BotCommand| {
+                    let rc = std::sync::Arc::clone(&rc);
+                    let command = bc.command();
 
-                let rc = rc.read().expect("RwLock lock on commands map failed");
+                    let rc = rc.read().expect("RwLock lock on commands map failed");
 
-                rc.get_command_message(command)
-            })
-            .endpoint(handle_botmessage),
-    )
+                    rc.get_command_message(command)
+                })
+                .endpoint(handle_botmessage),
+        )
+        .branch(
+            Update::filter_callback_query()
+                .filter_map(move |q: CallbackQuery| {
+                    q.data.and_then(|data| {
+                        let rc = std::sync::Arc::clone(&crc);
+                        let rc = rc.read().expect("RwLock lock on commands map failed");
+
+                        rc.get_callback_message(&data)
+                    })
+                })
+                .endpoint(handle_callback),
+        )
 }
 
 async fn handle_botmessage(bot: Bot, mut db: DB, bm: BotMessage, msg: Message) -> BotResult<()> {
@@ -78,3 +92,71 @@ async fn handle_botmessage(bot: Bot, mut db: DB, bm: BotMessage, msg: Message) -
 
     Ok(())
 }
+
+async fn handle_callback(bot: Bot, mut db: DB, bm: BotMessage, q: CallbackQuery) -> BotResult<()> {
+    info!("Eval BM: {:?}", bm);
+    let tguser = q.from.clone();
+    let user = db
+        .get_or_init_user(tguser.id.0 as i64, &tguser.first_name)
+        .await?;
+    let user = update_user_tg(user, &tguser);
+    user.update_user(&mut db).await?;
+
+    let buttons = bm
+        .resolve_buttons(&mut db)
+        .await?
+        .map(|buttons| InlineKeyboardMarkup {
+            inline_keyboard: buttons
+                .iter()
+                .map(|r| {
+                    r.iter()
+                        .map(|b| match b {
+                            botscript::ButtonLayout::Callback {
+                                name,
+                                literal: _,
+                                callback,
+                            } => InlineKeyboardButton::callback(name, callback),
+                        })
+                        .collect()
+                })
+                .collect(),
+        });
+    let literal = bm.literal().map_or("", |s| s.as_str());
+
+    let (chat_id, msg_id) = {
+        let chat_id = match q.chat_id() {
+            Some(chat_id) => chat_id.0,
+            None => tguser.id.0 as i64,
+        };
+
+        let msg_id = q.message.map_or_else(
+            || {
+                Err(BotError::MsgTooOld(
+                    "Failed to get message id, probably message too old".to_string(),
+                ))
+            },
+            |m| Ok(m.id().0),
+        );
+
+        (chat_id, msg_id)
+    };
+
+    let ma = MessageAnswerer::new(&bot, &mut db, chat_id);
+    match bm.is_replace() {
+        true => {
+            match msg_id {
+                Ok(msg_id) => {
+                    ma.replace_message(msg_id, literal, buttons).await?;
+                }
+                Err(err) => {
+                    ma.answer(literal, None, buttons).await?;
+                }
+            };
+        }
+        false => {
+            ma.answer(literal, None, buttons).await?;
+        }
+    }
+
+    Ok(())
+}

From f27fb670bd958ea52d79996f0f1ed719494c99f9 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:43:05 +0500
Subject: [PATCH 116/131] create BotManager

---
 src/bot_manager.rs | 141 +++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 137 insertions(+), 4 deletions(-)

diff --git a/src/bot_manager.rs b/src/bot_manager.rs
index 3cfa0eb..6c95623 100644
--- a/src/bot_manager.rs
+++ b/src/bot_manager.rs
@@ -1,6 +1,7 @@
-use std::{collections::HashMap, sync::RwLock, thread::JoinHandle};
+use std::{collections::HashMap, future::Future, sync::RwLock, thread::JoinHandle, time::Duration};
 
 use lazy_static::lazy_static;
+use log::{error, info};
 use teloxide::{
     dispatching::dialogue::serializer::Json,
     dptree,
@@ -18,7 +19,7 @@ use crate::{
 pub struct BotRunner {
     controller: BotController,
     info: BotInfo,
-    thread: JoinHandle<BotResult<()>>,
+    thread: Option<JoinHandle<BotResult<()>>>,
 }
 
 unsafe impl Sync for BotRunner {}
@@ -33,9 +34,141 @@ lazy_static! {
     static ref BOT_POOL: RwLock<HashMap<String, BotRunner>> = RwLock::new(HashMap::new());
 }
 
-static DEFAULT_SCRIPT: &str =
+pub static DEFAULT_SCRIPT: &str =
     include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/default_script.js"));
 
+pub struct BotManager<BIG, HM, BIS, HI, FBIS, FHI>
+where
+    BIG: FnMut() -> FBIS,
+    FBIS: Future<Output = BIS>,
+    BIS: Iterator<Item = BotInstance>,
+    HM: FnMut(BotInstance) -> FHI,
+    FHI: Future<Output = HI>,
+    HI: Iterator<Item = BotHandler>,
+{
+    bot_pool: HashMap<String, BotRunner>,
+    bi_getter: BIG,
+    h_mapper: HM,
+}
+
+impl<BIG, HM, BIS, HI, FBIS, FHI> BotManager<BIG, HM, BIS, HI, FBIS, FHI>
+where
+    BIG: FnMut() -> FBIS,
+    FBIS: Future<Output = BIS>,
+    BIS: Iterator<Item = BotInstance>,
+    HM: FnMut(BotInstance) -> FHI,
+    FHI: Future<Output = HI>,
+    HI: Iterator<Item = BotHandler>,
+{
+    /// bi_getter - fnmut that returns iterator over BotInstance
+    /// h_map     - fnmut that returns iterator over handlers by BotInstance
+    pub fn with(bi_getter: BIG, h_mapper: HM) -> Self {
+        Self {
+            bot_pool: Default::default(),
+            bi_getter,
+            h_mapper,
+        }
+    }
+
+    pub async fn dispatch(mut self, db: &mut DB) -> ! {
+        loop {
+            'biter: for bi in (self.bi_getter)().await {
+                // removing handler to force restart
+                // TODO: wait till all updates are processed in bot
+                // Temporarly disabling code, because it's free of js runtime
+                // spreads panic
+                if bi.restart_flag {
+                    info!(
+                        "Trying to restart bot `{}`, new script: {}",
+                        bi.name, bi.script
+                    );
+                    let runner = self.bot_pool.remove(&bi.name);
+                };
+                // start, if not started
+                let mut bot_runner = match self.bot_pool.remove(&bi.name) {
+                    Some(br) => br,
+                    None => {
+                        let handlers = (self.h_mapper)(bi.clone()).await;
+                        info!("NEW INSTANCE: Starting new instance! bot name: {}", bi.name);
+                        self.start_bot(bi, db, handlers.collect()).await.unwrap();
+                        continue 'biter;
+                    }
+                };
+
+                // checking if thread is not finished, otherwise clearing handler
+                bot_runner.thread = match bot_runner.thread {
+                    Some(thread) => {
+                        if thread.is_finished() {
+                            let err = thread.join();
+                            error!("Thread bot `{}` finished with error: {:?}", bi.name, err);
+                            None
+                        } else {
+                            Some(thread)
+                        }
+                    }
+                    None => None,
+                };
+
+                // checking if thread is running, otherwise start thread
+                bot_runner.thread = match bot_runner.thread {
+                    Some(thread) => Some(thread),
+                    None => {
+                        let handlers = (self.h_mapper)(bi.clone()).await;
+                        let handler =
+                            script_handler_gen(bot_runner.controller.clone(), handlers.collect())
+                                .await;
+                        Some(
+                            spawn_bot_thread(bot_runner.controller.clone(), db, handler)
+                                .await
+                                .unwrap(),
+                        )
+                    }
+                };
+                self.bot_pool.insert(bi.name.clone(), bot_runner);
+            }
+            tokio::time::sleep(Duration::from_secs(1)).await;
+        }
+    }
+
+    pub async fn start_bot(
+        &mut self,
+        bi: BotInstance,
+        db: &mut DB,
+        plug_handlers: Vec<BotHandler>,
+    ) -> BotResult<BotInfo> {
+        let mut db = db.clone().with_name(bi.name.clone());
+        let controller = BotController::with_db(db.clone(), &bi.token, &bi.script).await?;
+
+        let handler = script_handler_gen(controller.clone(), plug_handlers).await;
+
+        let thread = spawn_bot_thread(controller.clone(), &mut db, handler).await?;
+
+        let info = BotInfo {
+            name: bi.name.clone(),
+        };
+        let runner = BotRunner {
+            controller,
+            info: info.clone(),
+            thread: Some(thread),
+        };
+
+        self.bot_pool.insert(bi.name.clone(), runner);
+
+        Ok(info)
+    }
+}
+
+async fn script_handler_gen(c: BotController, plug_handlers: Vec<BotHandler>) -> BotHandler {
+    let handler = script_handler(c.rc.clone());
+    // each handler will be added to dptree::entry()
+    let handler = plug_handlers
+        .into_iter()
+        // as well as the script handler at the end
+        .chain(std::iter::once(handler))
+        .fold(dptree::entry(), |h, plug| h.branch(plug));
+    handler
+}
+
 pub async fn create_bot(db: &mut DB, token: &str) -> BotResult<BotInstance> {
     let bot = Bot::new(token);
     let name = bot.get_me().await?.username().to_string();
@@ -71,7 +204,7 @@ pub async fn start_bot(
     let runner = BotRunner {
         controller,
         info: info.clone(),
-        thread,
+        thread: Some(thread),
     };
 
     BOT_POOL

From 6dfe9b839dd63901f3fc0a54bec8061845d8d100 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:45:34 +0500
Subject: [PATCH 117/131] fix logic: move bot insertion to db to /deploy
 command, instead of function in bot_manager

---
 src/admin.rs       | 28 +++++++++++++++++++++++-----
 src/bot_manager.rs | 11 -----------
 2 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/src/admin.rs b/src/admin.rs
index 709c624..10fbba2 100644
--- a/src/admin.rs
+++ b/src/admin.rs
@@ -1,5 +1,3 @@
-use std::fmt::format;
-
 use itertools::Itertools;
 use teloxide::{
     prelude::*,
@@ -7,8 +5,8 @@ use teloxide::{
 };
 
 use crate::{
-    bot_manager::create_bot,
-    db::{CallDB, DB},
+    bot_manager::DEFAULT_SCRIPT,
+    db::{bots::BotInstance, CallDB, DB},
     BotResult,
 };
 use crate::{BotDialogue, LogMsg, State};
@@ -162,7 +160,27 @@ pub async fn admin_command_handler(
             Ok(())
         }
         AdminCommands::Deploy { token } => {
-            let bot_instance = create_bot(&mut db, &token).await?;
+            let bot_instance = {
+                let botnew = Bot::new(&token);
+                let name = match botnew.get_me().await {
+                    Ok(me) => me.username().to_string(),
+                    Err(teloxide::RequestError::Api(teloxide::ApiError::InvalidToken)) => {
+                        bot.send_message(msg.chat.id, "Error: bot token is invalid")
+                            .await?;
+                        return Ok(());
+                    }
+                    Err(err) => {
+                        return Err(err.into());
+                    }
+                };
+
+                let bi =
+                    BotInstance::new(name.clone(), token.to_string(), DEFAULT_SCRIPT.to_string())
+                        .store(&mut db)
+                        .await?;
+
+                bi
+            };
 
             bot.send_message(
                 msg.chat.id,
diff --git a/src/bot_manager.rs b/src/bot_manager.rs
index 6c95623..be324ec 100644
--- a/src/bot_manager.rs
+++ b/src/bot_manager.rs
@@ -169,17 +169,6 @@ async fn script_handler_gen(c: BotController, plug_handlers: Vec<BotHandler>) ->
     handler
 }
 
-pub async fn create_bot(db: &mut DB, token: &str) -> BotResult<BotInstance> {
-    let bot = Bot::new(token);
-    let name = bot.get_me().await?.username().to_string();
-
-    let bi = BotInstance::new(name.clone(), token.to_string(), DEFAULT_SCRIPT.to_string())
-        .store(db)
-        .await?;
-
-    Ok(bi)
-}
-
 pub async fn start_bot(
     bi: BotInstance,
     db: &mut DB,

From e993a6c941e66b60d98d33f92ffa33a3e2c88b88 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:47:49 +0500
Subject: [PATCH 118/131] derive Clone on Config

---
 src/main.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index 3b24ff5..33e7cdf 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -49,7 +49,7 @@ use teloxide::{
 
 type BotDialogue = Dialogue<State, MongodbStorage<Json>>;
 
-#[derive(Envconfig)]
+#[derive(Envconfig, Clone)]
 pub struct Config {
     #[envconfig(from = "BOT_TOKEN")]
     pub bot_token: String,

From 02659424499e5e994d3f26a1f8489691f0b44b19 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:48:15 +0500
Subject: [PATCH 119/131] enable Send for BotController

---
 src/main.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index 33e7cdf..d3ac948 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -118,6 +118,8 @@ pub struct BotController {
     pub runner: Runner,
 }
 
+unsafe impl Send for BotController {}
+
 const MAIN_BOT_SCRIPT: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/mainbot.js"));
 
 impl BotController {

From bee93b32d1f2248fb267fad39c070fe736213871 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 10:48:52 +0500
Subject: [PATCH 120/131] use BotController

---
 src/main.rs | 90 +++++++++++++----------------------------------------
 1 file changed, 22 insertions(+), 68 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index d3ac948..c34618f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -9,38 +9,27 @@ pub mod message_answerer;
 pub mod mongodb_storage;
 pub mod utils;
 
-use bot_manager::start_bot;
+use bot_manager::BotManager;
 use botscript::{BotMessage, Runner, RunnerConfig, ScriptError, ScriptResult};
-use commands::BotCommand;
 use db::application::Application;
 use db::bots::BotInstance;
 use db::callback_info::CallbackInfo;
 use db::message_forward::MessageForward;
 use handlers::admin::admin_handler;
-use itertools::Itertools;
 use log::{error, info, warn};
 use message_answerer::MessageAnswerer;
-use std::str::FromStr;
 use std::sync::{Arc, RwLock};
-use std::time::Duration;
-use teloxide::sugar::request::RequestReplyExt;
 use utils::create_callback_button;
 
-use crate::admin::{admin_command_handler, AdminCommands};
-use crate::admin::{secret_command_handler, SecretCommands};
 use crate::db::{CallDB, DB};
 use crate::mongodb_storage::MongodbStorage;
 
-use chrono::{DateTime, Utc};
 use db::DbError;
 use envconfig::Envconfig;
 use serde::{Deserialize, Serialize};
 use teloxide::dispatching::dialogue::serializer::Json;
 use teloxide::dispatching::dialogue::{GetChatId, Serializer};
-use teloxide::types::{
-    InlineKeyboardButton, InlineKeyboardMarkup, InputFile, InputMedia, MediaKind, MessageId,
-    MessageKind, ParseMode, ReplyMarkup,
-};
+use teloxide::types::{InlineKeyboardButton, InlineKeyboardMarkup};
 use teloxide::{
     payloads::SendMessageSetters,
     prelude::*,
@@ -183,64 +172,29 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     pretty_env_logger::init();
     let config = Config::init_from_env()?;
 
-    let mut bc = BotController::new(&config).await?;
-    let state_mgr = MongodbStorage::open(config.db_url.clone().as_ref(), "gongbot", Json).await?;
+    let mut db = DB::init(&config.db_url, config.bot_name.to_owned()).await?;
 
-    for bi in BotInstance::get_all(&mut bc.db).await? {
-        let info = start_bot(bi, &mut bc.db, vec![admin_handler()]).await?;
-        println!("Started bot: {}", info.name);
-    }
+    BotInstance::restart_all(&mut db, false).await?;
+    let bm = BotManager::with(
+        async || {
+            let config = config.clone();
 
-    // TODO: delete this in production
-    // allow because values are hardcoded and if they will be unparsable
-    // we should panic anyway
-    #[allow(clippy::unwrap_used)]
-    let events: Vec<DateTime<Utc>> = ["2025-04-09T18:00:00+04:00", "2025-04-11T16:00:00+04:00"]
-        .iter()
-        .map(|d| DateTime::parse_from_rfc3339(d).unwrap().into())
-        .collect();
+            let mut db = DB::init(config.db_url, config.bot_name.to_owned())
+                .await
+                .unwrap();
+            let bi = BotInstance::new(
+                config.bot_name,
+                config.bot_token,
+                MAIN_BOT_SCRIPT.to_string(),
+            );
+            let instances = BotInstance::get_all(&mut db).await.unwrap();
+            BotInstance::restart_all(&mut db, false).await.unwrap();
+            std::iter::once(bi).chain(instances)
+        },
+        async |bi| vec![admin_handler()].into_iter(),
+    );
 
-    for event in events {
-        match bc.db.create_event(event).await {
-            Ok(e) => info!("Created event {}", e._id),
-            Err(err) => info!("Failed to create event, error: {}", err),
-        }
-    }
-    //
-    let rc: std::sync::Arc<RwLock<_>> = bc.rc;
-
-    let handler = dptree::entry()
-        .inspect(|u: Update| {
-            info!("{u:#?}"); // Print the update to the console with inspect
-        })
-        .branch(
-            Update::filter_message()
-                .filter_map(|m: Message| m.text().and_then(|t| BotCommand::from_str(t).ok()))
-                .filter_map(move |bc: BotCommand| {
-                    let rc = std::sync::Arc::clone(&rc);
-                    let command = bc.command();
-
-                    let rc = rc.read().expect("RwLock lock on commands map failed");
-
-                    rc.get_command_message(command)
-                })
-                .endpoint(botscript_command_handler),
-        )
-        // .branch(
-        //     Update::filter_message()
-        //         .enter_dialogue::<Message, MongodbStorage<Json>, State>()
-        //         .branch(dptree::case![State::MessageForwardReply].endpoint(user_reply_to_support)),
-        // )
-        .branch(Update::filter_message().endpoint(echo));
-
-    Dispatcher::builder(bc.bot, handler)
-        .dependencies(dptree::deps![bc.db, state_mgr])
-        .enable_ctrlc_handler()
-        .build()
-        .dispatch()
-        .await;
-
-    Ok(())
+    bm.dispatch(&mut db).await;
 }
 
 async fn botscript_command_handler(

From c936ea38a9ef3a325e62ccef62597fc686694789 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 11:04:35 +0500
Subject: [PATCH 121/131] update mainbot.js

---
 mainbot.js | 66 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 38 insertions(+), 28 deletions(-)

diff --git a/mainbot.js b/mainbot.js
index a7ed9ca..6917c04 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -1,21 +1,31 @@
 // db - is set globally
 
+const PROJECTS_COUNT = 2
+
 const dialog = {
     commands: {
         start: {
-            buttons: start_buttons, // default is `null`
+            buttons: [
+                [{name: {literal: "more_info_btn"}, callback_name: "more_info"}],
+                [{name: {literal: "show_projects"}, callback_name: "project_0"}],
+            ], // default is `null`
             state: "start"
         },
-        cancel: {
-            buttons: [
-                [{name: {name: "Def"}, callback_name: "defcall"}]
-            ],
-            state: "none"
-        },
-        somecomplicatedcmd: {}
     },
     buttons: {
-        more_info: {},
+        more_info: {
+            buttons: [
+                [{name: {name: "На главную"}, callback_name: "start"}],
+            ]
+        },
+        start: {
+            buttons: [
+                [{name: {literal: "more_info_btn"}, callback_name: "more_info"}],
+                [{name: {literal: "show_projects"}, callback_name: "project_0"}],
+            ], // default is `null`
+            replace: true,
+            state: "start"
+        },
     },
     stateful_msg_handlers: {
         start: {}, // everything is by default, so just send message `start`
@@ -33,27 +43,27 @@ function enter_name() {}
 
 const fmt = (number) => number.toString().padStart(2, '0');
 
-const formatDate = (date) => {
-    const [h, m, d, M, y] = [
-        date.getHours(),
-        date.getMinutes(),
-        date.getDate(),
-        date.getMonth(),
-        date.getFullYear()
-    ];
-    return `${fmt(h)}:${fmt(m)} ${fmt(d)}-${fmt(M + 1)}-${y}`
-};
+function add_project_callbacks(point) {
+    for (const i of Array(PROJECTS_COUNT).keys()) {
+        buttons = [
+            [],
+            [{name: {name: "На главную"}, callback_name: "start"}]
+        ]
+        if (i > 0) {
+            buttons[0].push({name: {literal: "prev_project"}, callback_name: `project_${i-1}`})
+        }
+        if (i < PROJECTS_COUNT - 1) {
+            buttons[0].push({name: {literal: "next_project"}, callback_name: `project_${i+1}`})
+        }
 
-function start_buttons() {
-    const now = new Date();
-    const dateFormated = formatDate(now);
-
-    // return 1
-    return [
-        [{name: {name: dateFormated}, callback_name: "no"}],
-        [{name: {name: "Hello!"}, callback_name: "no"}],
-    ]
+        point[`project_${i}`] = {
+            replace: true,
+            buttons: buttons
+        }
+    }
 }
+add_project_callbacks(dialog.buttons)
+print(JSON.stringify(dialog.buttons))
 
 const config = {
     version: 1.1,

From 845071c80021f19d02eb154d54641d86275016e1 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:39:17 +0500
Subject: [PATCH 122/131] create botscript application module for js's runtime
 user_application function

---
 src/botscript.rs             |  1 +
 src/botscript/application.rs | 81 ++++++++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+)
 create mode 100644 src/botscript/application.rs

diff --git a/src/botscript.rs b/src/botscript.rs
index 5d6324c..b5cb769 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -1,3 +1,4 @@
+pub mod application;
 pub mod db;
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex, PoisonError};
diff --git a/src/botscript/application.rs b/src/botscript/application.rs
new file mode 100644
index 0000000..e08c548
--- /dev/null
+++ b/src/botscript/application.rs
@@ -0,0 +1,81 @@
+use std::sync::RwLock;
+
+use log::info;
+use quickjs_rusty::{context::Context, serde::from_js, OwnedJsObject};
+use teloxide::Bot;
+use tokio::runtime::Handle;
+
+use crate::{
+    db::{application::Application, message_forward::MessageForward, CallDB, DB},
+    message_answerer::MessageAnswerer,
+    send_application_to_chat, BotError,
+};
+
+use super::ScriptError;
+
+pub fn attach_user_application(
+    c: &Context,
+    o: &mut OwnedJsObject,
+    db: &DB,
+    bot: &Bot,
+) -> Result<(), ScriptError> {
+    let db: std::sync::Arc<RwLock<DB>> = std::sync::Arc::new(RwLock::new(db.clone()));
+    let dbbox = Box::new(db.clone());
+    let db: &'static _ = Box::leak(dbbox);
+
+    let bot: std::sync::Arc<RwLock<Bot>> = std::sync::Arc::new(RwLock::new(bot.clone()));
+    let botbox = Box::new(bot.clone());
+    let bot: &'static _ = Box::leak(botbox);
+
+    let user_application =
+        c.create_callback(move |q: OwnedJsObject| -> Result<_, ScriptError> {
+            let db = db.clone();
+            let user: teloxide::types::User = match from_js(q.context(), &q) {
+                Ok(q) => q,
+                Err(_) => todo!(),
+            };
+
+            let application = futures::executor::block_on(
+                Application::new(user.clone()).store_db(&mut db.write().unwrap()),
+            )?;
+
+            let db2 = db.clone();
+            let msg = tokio::task::block_in_place(move || {
+                Handle::current().block_on(async move {
+                    send_application_to_chat(
+                        &bot.read().unwrap(),
+                        &mut db2.write().unwrap(),
+                        &application,
+                    )
+                    .await
+                })
+            });
+            let msg = match msg {
+                Ok(msg) => msg,
+                Err(err) => {
+                    info!("Got err: {err}");
+                    return Err(ScriptError::MutexError("🤦‍♂️".to_string()));
+                }
+            };
+
+            let (chat_id, msg_id) = futures::executor::block_on(
+                MessageAnswerer::new(
+                    &bot.read().unwrap(),
+                    &mut db.write().unwrap(),
+                    user.id.0 as i64,
+                )
+                .answer("left_application_msg", None, None),
+            )
+            .unwrap();
+            futures::executor::block_on(
+                MessageForward::new(msg.chat.id.0, msg.id.0, chat_id, msg_id, false)
+                    .store_db(&mut db.write().unwrap()),
+            )?;
+
+            let ret = true;
+            Ok(ret)
+        })?;
+
+    o.set_property("user_application", user_application.into_value())?;
+    Ok(())
+}

From bc46e0fda44b6127dcf635610facfbf6d85ff842 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:41:42 +0500
Subject: [PATCH 123/131] create BotFunction context getter

---
 src/botscript.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index b5cb769..1e0557f 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -122,6 +122,13 @@ impl BotFunction {
         }
     }
 
+    pub fn context(&self) -> Option<*mut quickjs_rusty::JSContext> {
+        match &self.func {
+            FunctionMarker::Function(js_function) => Some(js_function.context()),
+            FunctionMarker::StrTemplate(_) => None,
+        }
+    }
+
     pub fn call(&self) -> ScriptResult<JsValue> {
         self.call_args(Default::default())
     }

From 9cd0765030fc634f303d971204f88936218e0362 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:42:10 +0500
Subject: [PATCH 124/131] create BotMessage js function handler getter

---
 src/botscript.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/botscript.rs b/src/botscript.rs
index 1e0557f..67ae0dd 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -506,6 +506,10 @@ impl BotMessage {
     pub fn is_replace(&self) -> bool {
         self.replace
     }
+
+    pub fn get_handler(&self) -> Option<&BotFunction> {
+        self.handler.as_ref()
+    }
 }
 
 impl BotMessage {

From a1068910504f8545cddc8d501fa230c55e146dd5 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:42:54 +0500
Subject: [PATCH 125/131] create call_attacher for Runner to attach global
 objects on initialization

---
 src/botscript.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/botscript.rs b/src/botscript.rs
index 67ae0dd..fff66c9 100644
--- a/src/botscript.rs
+++ b/src/botscript.rs
@@ -13,12 +13,12 @@ use itertools::Itertools;
 use quickjs_rusty::serde::from_js;
 use quickjs_rusty::utils::create_empty_object;
 use quickjs_rusty::utils::create_string;
-use quickjs_rusty::Context;
 use quickjs_rusty::ContextError;
 use quickjs_rusty::ExecutionError;
 use quickjs_rusty::JsFunction;
 use quickjs_rusty::OwnedJsValue as JsValue;
 use quickjs_rusty::ValueError;
+use quickjs_rusty::{Context, OwnedJsObject};
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -665,6 +665,17 @@ impl Runner {
         })
     }
 
+    pub fn call_attacher<F, R>(&mut self, f: F) -> ScriptResult<R>
+    where
+        F: FnOnce(&Context, &mut OwnedJsObject) -> R,
+    {
+        let context = self.context.lock().unwrap();
+        let mut global = context.global()?;
+
+        let res = f(&context, &mut global);
+        Ok(res)
+    }
+
     pub fn run_script(&self, content: &str) -> ScriptResult<JsValue> {
         let ctx = match self.context.lock() {
             Ok(ctx) => ctx,

From d749b57811fcf9961244ff6d30edb3d900f54193 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:43:41 +0500
Subject: [PATCH 126/131] call js function handler if set in script_handler

---
 src/bot_handler.rs | 69 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 68 insertions(+), 1 deletion(-)

diff --git a/src/bot_handler.rs b/src/bot_handler.rs
index 1b9e7bc..d85ddfd 100644
--- a/src/bot_handler.rs
+++ b/src/bot_handler.rs
@@ -1,4 +1,5 @@
-use log::info;
+use log::{error, info};
+use quickjs_rusty::serde::to_js;
 use std::{
     str::FromStr,
     sync::{Arc, RwLock},
@@ -66,6 +67,39 @@ async fn handle_botmessage(bot: Bot, mut db: DB, bm: BotMessage, msg: Message) -
     let user = update_user_tg(user, &tguser);
     user.update_user(&mut db).await?;
 
+    let is_propagate: bool = match bm.get_handler() {
+        Some(handler) => 'prop: {
+            let ctx = match handler.context() {
+                Some(ctx) => ctx,
+                // falling back to propagation
+                None => break 'prop true,
+            };
+            let jsuser = to_js(ctx, &tguser).unwrap();
+            match handler.call_args(vec![jsuser]) {
+                Ok(v) => {
+                    if v.is_bool() {
+                        v.to_bool().unwrap_or(true)
+                    } else if v.is_int() {
+                        v.to_int().unwrap_or(1) != 0
+                    } else {
+                        // falling back to propagation
+                        true
+                    }
+                }
+                Err(err) => {
+                    error!("Failed to get return of handler, err: {err}");
+                    // falling back to propagation
+                    true
+                }
+            }
+        }
+        None => true,
+    };
+
+    if !is_propagate {
+        return Ok(());
+    }
+
     let buttons = bm
         .resolve_buttons(&mut db)
         .await?
@@ -102,6 +136,39 @@ async fn handle_callback(bot: Bot, mut db: DB, bm: BotMessage, q: CallbackQuery)
     let user = update_user_tg(user, &tguser);
     user.update_user(&mut db).await?;
 
+    let is_propagate: bool = match bm.get_handler() {
+        Some(handler) => 'prop: {
+            let ctx = match handler.context() {
+                Some(ctx) => ctx,
+                // falling back to propagation
+                None => break 'prop true,
+            };
+            let jsuser = to_js(ctx, &tguser).unwrap();
+            match handler.call_args(vec![jsuser]) {
+                Ok(v) => {
+                    if v.is_bool() {
+                        v.to_bool().unwrap_or(true)
+                    } else if v.is_int() {
+                        v.to_int().unwrap_or(1) != 0
+                    } else {
+                        // falling back to propagation
+                        true
+                    }
+                }
+                Err(err) => {
+                    error!("Failed to get return of handler, err: {err}");
+                    // falling back to propagation
+                    true
+                }
+            }
+        }
+        None => true,
+    };
+
+    if !is_propagate {
+        return Ok(());
+    }
+
     let buttons = bm
         .resolve_buttons(&mut db)
         .await?

From 2e447e87fddc4ce3f548465dc270678d3a94b1c6 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:45:02 +0500
Subject: [PATCH 127/131] create Application.store_db to store by DB type

---
 src/db/application.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/db/application.rs b/src/db/application.rs
index 150c5fc..556983b 100644
--- a/src/db/application.rs
+++ b/src/db/application.rs
@@ -2,6 +2,7 @@ use chrono::{DateTime, FixedOffset, Local};
 use serde::{Deserialize, Serialize};
 
 use super::DbResult;
+use super::DB;
 use crate::query_call_consume;
 use crate::CallDB;
 
@@ -36,4 +37,13 @@ where
 
         Ok(self)
     });
+
+    pub async fn store_db(self, db: &mut DB) -> DbResult<Self> {
+        let db = db.get_database().await;
+        let ci = db.collection::<Self>("applications");
+
+        ci.insert_one(&self).await?;
+
+        Ok(self)
+    }
 }

From b8d07d0ad5bc6016a33325acef1bd374cb4f1c7c Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:45:45 +0500
Subject: [PATCH 128/131] create MessageForward.store_db to store by DB type

reason: easier to use with RwLock
---
 src/db/message_forward.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/db/message_forward.rs b/src/db/message_forward.rs
index acf7f01..31e168b 100644
--- a/src/db/message_forward.rs
+++ b/src/db/message_forward.rs
@@ -2,6 +2,7 @@ use bson::doc;
 use serde::{Deserialize, Serialize};
 
 use super::DbResult;
+use super::DB;
 use crate::query_call_consume;
 use crate::CallDB;
 
@@ -42,6 +43,15 @@ impl MessageForward {
         Ok(self)
     });
 
+    pub async fn store_db(self, db: &mut DB) -> DbResult<Self> {
+        let db = db.get_database().await;
+        let ci = db.collection::<Self>("message_forward");
+
+        ci.insert_one(&self).await?;
+
+        Ok(self)
+    }
+
     pub async fn get<D: CallDB>(
         db: &mut D,
         chat_id: i64,

From b980a653cbeed570908a10ba52c66b515b0a5979 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:46:54 +0500
Subject: [PATCH 129/131] attach user_application to runner

---
 src/main.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index c34618f..c3a2f91 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,6 +10,7 @@ pub mod mongodb_storage;
 pub mod utils;
 
 use bot_manager::BotManager;
+use botscript::application::attach_user_application;
 use botscript::{BotMessage, Runner, RunnerConfig, ScriptError, ScriptResult};
 use db::application::Application;
 use db::bots::BotInstance;
@@ -131,7 +132,8 @@ impl BotController {
     pub async fn with_db(mut db: DB, token: &str, script: &str) -> ScriptResult<Self> {
         let bot = Bot::new(token);
 
-        let runner = Runner::init_with_db(&mut db)?;
+        let mut runner = Runner::init_with_db(&mut db)?;
+        runner.call_attacher(|c, o| attach_user_application(c, o, &db, &bot))??;
         let rc = runner.init_config(script)?;
         let rc = Arc::new(RwLock::new(rc));
 

From 714853730a8fb88ff1b7dff827f527f91c4249f1 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:47:14 +0500
Subject: [PATCH 130/131] create /cancel command for users

---
 src/handlers/admin.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/handlers/admin.rs b/src/handlers/admin.rs
index 29a2c34..7b74aec 100644
--- a/src/handlers/admin.rs
+++ b/src/handlers/admin.rs
@@ -23,6 +23,8 @@ use crate::{BotDialogue, BotError, BotResult, CallbackStore, State};
 
 pub fn admin_handler() -> BotHandler {
     dptree::entry()
+        // keep on top to cancel any action
+        .branch(cancel_handler())
         .branch(
             Update::filter_callback_query()
                 .filter_async(async |q: CallbackQuery, mut db: DB| {
@@ -197,6 +199,17 @@ async fn button_edit_callback(
     Ok(())
 }
 
+fn cancel_handler() -> BotHandler {
+    Update::filter_message()
+        .filter(|msg: Message| msg.text() == Some("/cancel"))
+        .enter_dialogue::<Message, MongodbStorage<Json>, State>()
+        .endpoint(async |bot: Bot, msg: Message, dialogue: BotDialogue| {
+            dialogue.exit().await?;
+            bot.send_message(msg.chat.id, "Диалог закончен!").await?;
+            Ok(())
+        })
+}
+
 fn command_handler() -> BotHandler {
     Update::filter_message()
         .filter_async(async |msg: Message, mut db: DB| {
@@ -300,6 +313,10 @@ async fn support_reply_handler(
         _ => unreachable!(),
     };
 
+    let text = format!(
+        "Сообщение от поддержки:\n{}\nЧтобы закончить диалог, нажмите на /cancel",
+        text
+    );
     let msg = bot
         .send_message(ChatId(mf.source_chat_id), text)
         .parse_mode(ParseMode::Html);

From adad94ad4337217e4c9c402f4f138c49c011eb40 Mon Sep 17 00:00:00 2001
From: Akulij <aakulij@gmail.com>
Date: Sat, 31 May 2025 13:47:46 +0500
Subject: [PATCH 131/131] update mainbot.js logic

---
 mainbot.js | 48 ++++++++++++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 20 deletions(-)

diff --git a/mainbot.js b/mainbot.js
index 6917c04..55dfab9 100644
--- a/mainbot.js
+++ b/mainbot.js
@@ -2,30 +2,31 @@
 
 const PROJECTS_COUNT = 2
 
+const start_msg = {
+    buttons: [
+        [{ name: { literal: "show_projects" }, callback_name: "project_0" }],
+        [{ name: { literal: "more_info_btn" }, callback_name: "more_info" }],
+        [{ name: { literal: "leave_application" }, callback_name: "leave_application" }],
+        [{ name: { literal: "ask_question_btn" }, callback_name: "ask_question" }],
+    ], // default is `null`
+    replace: true,
+    state: "start"
+};
 const dialog = {
     commands: {
-        start: {
-            buttons: [
-                [{name: {literal: "more_info_btn"}, callback_name: "more_info"}],
-                [{name: {literal: "show_projects"}, callback_name: "project_0"}],
-            ], // default is `null`
-            state: "start"
-        },
+        start: start_msg,
     },
     buttons: {
         more_info: {
             buttons: [
-                [{name: {name: "На главную"}, callback_name: "start"}],
+                [{ name: { name: "На главную" }, callback_name: "start" }],
             ]
         },
-        start: {
-            buttons: [
-                [{name: {literal: "more_info_btn"}, callback_name: "more_info"}],
-                [{name: {literal: "show_projects"}, callback_name: "project_0"}],
-            ], // default is `null`
-            replace: true,
-            state: "start"
+        start: start_msg,
+        leave_application: {
+            handler: leave_application
         },
+        ask_question: {}
     },
     stateful_msg_handlers: {
         start: {}, // everything is by default, so just send message `start`
@@ -39,7 +40,14 @@ const dialog = {
     },
 }
 
-function enter_name() {}
+function leave_application(user) {
+    print(JSON.stringify(user))
+    user_application(user)
+
+    return false
+}
+
+function enter_name() { }
 
 const fmt = (number) => number.toString().padStart(2, '0');
 
@@ -47,13 +55,13 @@ function add_project_callbacks(point) {
     for (const i of Array(PROJECTS_COUNT).keys()) {
         buttons = [
             [],
-            [{name: {name: "На главную"}, callback_name: "start"}]
+            [{ name: { name: "На главную" }, callback_name: "start" }]
         ]
         if (i > 0) {
-            buttons[0].push({name: {literal: "prev_project"}, callback_name: `project_${i-1}`})
+            buttons[0].push({ name: { literal: "prev_project" }, callback_name: `project_${i - 1}` })
         }
         if (i < PROJECTS_COUNT - 1) {
-            buttons[0].push({name: {literal: "next_project"}, callback_name: `project_${i+1}`})
+            buttons[0].push({ name: { literal: "next_project" }, callback_name: `project_${i + 1}` })
         }
 
         point[`project_${i}`] = {
@@ -70,5 +78,5 @@ const config = {
 }
 
 // {config, dialog}
-const c = {config: config, dialog: dialog}
+const c = { config: config, dialog: dialog }
 c