fmt

Auth server

.gitignore

@@ -6,7 +6,14 @@ tmp/
 db/
 
 com/test.lua
+com/_config.lua
 
 .vscode
 Taskfile.yml
 config.yaml
+
+wiki
+
+# Garbage
+com/_*
+com/test.lua

Makefile

@@ -4,7 +4,10 @@ GOPATH := $(shell go env GOPATH)
 export CONFIG_PATH := ./config.yaml
 export NODE_PATH := $(shell pwd)
 
-LDFLAGS := -X 'github.com/akyaiy/GoSally-mvp/internal/engine/config.NodeVersion=v0.0.1-dev'
+NODE_VERSION := v0.0.1-dev
+SV1_VERSION := v0.0.1-dev
+
+LDFLAGS := -X 'github.com/akyaiy/GoSally-mvp/src/internal/engine/config.NodeVersion=$(NODE_VERSION)' -X 'github.com/akyaiy/GoSally-mvp/src/internal/server/sv1.SV1Version=$(SV1_VERSION)'
 CGO_CFLAGS := -I/usr/local/include
 CGO_LDFLAGS := -L/usr/local/lib -llua5.1 -lm -ldl
 .PHONY: all build run runq test fmt vet lint check clean
@@ -30,14 +33,14 @@ build:
 	@# @echo "CGO_CFLAGS is: '$(CGO_CFLAGS)'"
 	@# @echo "CGO_LDFLAGS is: '$(CGO_LDFLAGS)'"
 	@# CGO_CFLAGS="$(CGO_CFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)"
-	@go build -trimpath -ldflags "-w -s $(LDFLAGS)" -o $(BIN_DIR)/$(APP_NAME) ./
-	@if ! command -v upx >/dev/null 2>&1; then \
-		echo "upx not found, skipping compression."; \
-	elif upx -t $(BIN_DIR)/$(APP_NAME) >/dev/null 2>&1; then \
-		echo "$(BIN_DIR)/$(APP_NAME) already compressed, skipping."; \
-	else \
-		upx $(BIN_DIR)/$(APP_NAME) >/dev/null 2>&1 || true; \
-	fi
+	cd src && go build -trimpath -ldflags "-w -s $(LDFLAGS)" -o ../$(BIN_DIR)/$(APP_NAME) ./
+# 	@if ! command -v upx >/dev/null 2>&1; then \
+# 		echo "upx not found, skipping compression."; \
+# 	elif upx -t $(BIN_DIR)/$(APP_NAME) >/dev/null 2>&1; then \
+# 		echo "$(BIN_DIR)/$(APP_NAME) already compressed, skipping."; \
+# 	else \
+# 		upx $(BIN_DIR)/$(APP_NAME) >/dev/null 2>&1 || true; \
+# 	fi
 
 run: build
 	@echo "Running!"
@@ -52,30 +55,22 @@ pure-run:
 	exec ./$(BIN_DIR)/$(APP_NAME)
 
 test:
-	@go test ./... | grep -v '^?' || true
+	@cd src && go test ./... | grep -v '^?' || true
 
 fmt:
-	@go fmt ./internal/./...
-	@go fmt ./cmd/./...
-	@go fmt ./hooks/./...
-	@$(GOPATH)/bin/goimports -w ./internal/
-	@$(GOPATH)/bin/goimports -w ./cmd/
-	@$(GOPATH)/bin/goimports -w ./hooks/
+	@cd src && go fmt .
+	@cd src && $(GOPATH)/bin/goimports -w .
 
 vet:
-	@go vet ./...
-
-lint:
-	@$(GOPATH)/bin/golangci-lint run
-
+	@cd src && go vet ./...
 check: fmt vet lint test
-
-licenses:
+lint:
+	@cd src && $(GOPATH)/bin/golangci-lint run ./...
 	@$(GOPATH)/bin/go-licenses save ./... --save_path=third_party/licenses --force
 	@echo "Licenses have been exported to third_party/licenses"
 
-clean:
-	@rm -rf bin
-
+licenses:
+	@cd src && $(GOPATH)/bin/go-licenses save ./... --save_path=../third_party/licenses --force
+	@echo "Licenses have been exported to third_party/licenses"
 help:
 	@echo "Available commands: $$(cat Makefile | grep -E '^[a-zA-Z_-]+:.*?' | grep -v -- '-setup:' | sed 's/:.*//g' | sort | uniq | tr '\n' ' ')"

README.md

@@ -1,51 +1,132 @@
 # Go Sally MVP (Minimum/Minimal Viable Product)
+[![Status](https://img.shields.io/badge/status-MVP-orange.svg)]()
+[![Go Version](https://img.shields.io/badge/Go-1.24.6-informational)](https://go.dev/)
+[![Lua Version](https://img.shields.io/badge/Lua-5.1-informational)](https://www.lua.org/manual/5.1/)
+[![Go Reference](https://pkg.go.dev/badge/github.com/akyaiy/GoSally-mvp.svg)](https://pkg.go.dev/github.com/akyaiy/GoSally-mvp)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue)](LICENSE)
 
-### What is this?
-System that allows you to build your own infrastructure based on identical nodes and various scripts written using built-in Lua 5.1, shebang scripts (scripts that start with the `#!` symbols), compiled binaries.
+[![Last Commit](https://img.shields.io/github/last-commit/akyaiy/GoSally-mvp)]()
+[![Commits per month](https://img.shields.io/github/commit-activity/m/akyaiy/GoSally-mvp)]()
+[![Docs](https://img.shields.io/badge/docs-wiki-blue)](https://github.com/akyaiy/GoSally-mvp/wiki)
 
-### Features
-Go Sally is not viable at the moment, but it already has the ability to run embedded scripts, log slog events to stdout, handle RPC like requests, and independent automatic update from the repository (my pride, to be honest).
 
-### Example of use
-The basic directory tree looks something like this
-```
-.
-├── bin
-│   └── node			Node core binary file
-├── com
-│   ├── echo.lua
-│   ├── _globals.lua	Declaring global variables and functions for all internal scripts (also required for luarc to work correctly)
-│   └── _prepare.lua	Script that is executed before each script launch
-└── config.yaml
+> ⚡ **What, Why, Why Care?**
 
-3 directories, 5 files
+> **What:** Go Sally is a lightweight decentralized node system with Lua scripting and JSON-RPC2.0.
 
-```
-Launch by command 
+> **Why:** Large admin tools are too heavy, and Raspberry Pi and small servers require a lightweight, modular architecture.
+
+> **Why Care:** Create, automate, and expand your infrastructure quickly, without unnecessary software or dependencies. 
+
+## Navigation
+* [Core features](#core-features)
+* [Quick start](#quick-start)
+  * [Test it](#test-it)
+* [Concept](#concept)
+* [API](#api)
+* [License](#license)
+* [Wiki →](https://github.com/akyaiy/GoSally-mvp/wiki)
+
+> [!NOTE]
+> If you see "💡" in the text, it means the information below is about plans for the future of the project.
+
+## Core features
+- **Decentralized nodes**<details>this means that *multiple GS[^1] nodes can be located on a single machine*, provided no attempt is made to disrupt, sabotage, or bypass the built-in protection mechanism against running a node under the same identifier as one already running in the system. Identification plays a role in node communication. 💡 In the future, we plan to create tools for conveniently building distributed systems using node identification.
+**Why Care?** Multiple nodes on one machine allow testing, experimentation, and scaling small infrastructures without extra hardware or complex setup.</details>
+- **RPC request processing**<details>the GS operates *using HTTP/https and the JSONRPC2.0 protocol.* Unlike gRPC, jsonrpc is extremely simple, allows for easy sending of requests from the browser, and does not require any additional code compilation. **Why Care?** Easy-to-use API means you can control nodes from anywhere, including lightweight web clients, without compiling extra code.</details>
+- **Lua script-based methods**<details>*The gopher-lua library is used, providing full support for Lua 5.1.* scripts implement libraries for interacting with sessions (receiving parameters and sending responses), hashing, logging, and more. This allows you to quickly write business logic on the fly without touching the lower layers of abstraction, which also eliminates unnecessary compilation and the risk of breaking the codebase.
+  Example of the "echo" method:
+  ```lua
+  local session = require("internal.session")
+  -- import the internal library for interacting with sessions
+
+  session.response.send(session.request.params.get())
+  -- send everything passed in the parameters in response.
+  ```
+  **Why Care?** You can extend node behavior dynamically, write custom logic fast, and iterate without recompiling — perfect for experiments or automation.
+  </details>
+- **Relatively flexible configuration** <details>
+you can configure the server port, address, name, node settings, and more. 💡 More settings are planned in the future. **Why Care?** Configure nodes for any environment, from Raspberry Pi to VPS, without touching the source code. obviously :)</details>
+- ***And more in the future***
+
+> [!IMPORTANT]
+> This is the beginning of the project's development, and some aspects of it may be unstable, unfinished, and the text about it may be overly ambitious. It's just a matter of time.
+
+## Quick start
 ```bash
+git clone https://github.com/akyaiy/GoSally-mvp.git && \
+cd GoSally-mvp && \
+make build && \
+echo -e "node:\n  com_dir: \"%path%/com\"" > config.yaml && \
+mkdir -p com && \
+echo -e 'local session = require("internal.session")\n\nsession.response.send(session.request.params.get())' > com/echo.lua && \
 ./bin/node run
 ```
-or for structured logs
-```bash
-./bin/node run | jq
-```
 
-Example of GET request to server
+If you have problems, make sure you have all [dependencies](https://github.com/akyaiy/GoSally-mvp/wiki/Getting-started#installing-dependencies) installed, otherwise [file an issue report](https://github.com/akyaiy/GoSally-mvp/issues)
+
+### Test it
 ```bash
-curl -s http://localhost:8080/api/v1/com/echo?msg=Hello
+curl -X POST http://localhost:8080/com \
+  -d '{"jsonrpc":"2.0","context-version": "v1","method":"echo","params":["Hi!!"],"id":1}'
 ```
-Then the response from the server
+Expected response:
 ```json
 {
-  "ResponsibleAgentUUID": "4593a87000bbe088f4e79c477e9c90d3",
-  "RequestedCommand": "echo",
-  "Response": {
-    "answer": "Hello",
-    "status": "ok"
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": [
+    "Hi!!"
+  ],
+  "data": {
+    "responsible-node": "a0e1c440473ffd4d87e32cff2717f5b3",
+    "salt": "f26df732-a3be-4400-8e71-b8dc3ba705fc",
+    "checksum-md5": "cd8bec6a365d1b8ee90773567cb3ad0a"
   }
 }
-
 ```
 
-### How to install
-**You don't need it now, but you can figure it out with the Makefile**
+## Concept
+The project was originally conceived as a tool for building infrastructure using relatively *small nodes with limited functionality*. 💡 In the future, we plan to create a *web interface for interacting with nodes, administration, and configuration*. The concept is simple: suppose we have a node that manages Bind9. It has all the necessary methods for interacting with the service: creating new zones, viewing zone status, changing configuration, and server operation status. All of this works only through manual configuration, with the exception of larger solutions like Webmin and the BIND DNS Server module. The big problem is that while we only needed web configuration for Bind9, we have to pull in a massive amount of software just to implement one module. What if the service is hosted on a low-power Raspberry Pi? That's where GS nodes come in. By default, GS nodes communicate only through API calls, so 💡 in the future, we plan to create a dedicated, also programmable, web node that will provide convenient access to node management.
+
+There's an obvious advantage here: transparency. The project is *completely open source and aims to support community-driven node functionality*. 💡 In the future, we plan to create a "store" similar to Docker Hub, which will contain scripts for configuring bind9, openvpn, and even custom projects.
+
+## API
+As mentioned earlier, *the server handles [jsonrpc2.0](https://www.jsonrpc.org/specification) requests*
+```json
+{
+    "jsonrpc": "2.0",
+    "context-version": "v1",
+    "method": "test",
+    "params": [
+        "Hi!!"
+    ],
+    "id": 1
+}
+```
+This is a typical example of a request using the jsonrpc2.0 protocol.
+```json
+{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "result": [
+        "Hi!!"
+    ],
+    "data": {
+        "responsible-node": "2ad6ebeaf579a7c52801fb6c9dd1b83d",
+        "salt": "e7a81115-01c1-45b1-9618-0eae0ff26451",
+        "checksum-md5": "cd8bec6a365d1b8ee90773567cb3ad0a"
+    }
+}
+```
+In the result field, we see the echo method's response. Those familiar with the jsonrpc2.0 specification will notice that the data structure here is unclear. This is my extension, which has three functions:
+| Field | Type | Description |
+|--------|------|-------------|
+| `responsible-node` | string | ID of the node that executed the task |
+| `salt` | string | Random value for each request — can be used to check that the response is unique |
+| `checksum-md5` | string | MD5 hash of the result field — can be used to avoid processing identical results separately |
+
+## License
+Distributed under the BSD 3-Clause License. See [`LICENSE`](./LICENSE) for more information.
+
+[^1]: Go Sally

com/Access/_common.lua

@@ -0,0 +1,22 @@
+-- File com/Access/_common.lua
+--
+-- Created at 2025-21-10
+--
+-- Description:
+--- Common functions for Unit module
+
+local common = {}
+
+function common.CheckMissingElement(arr, cmp)
+  local is_missing = {}
+  local ok = true
+  for _, key in ipairs(arr) do
+    if cmp[key] == nil then
+      table.insert(is_missing, key)
+      ok = false
+    end
+  end
+  return ok, is_missing
+end
+
+return common

com/Access/_errors.lua

@@ -0,0 +1,30 @@
+-- File com/Access/_errors.lua
+--
+-- Created at 2025-21-10
+-- Description:
+--- Centralized error definitions for Access operations
+--- to keep API responses consistent and clean.
+
+local errors = {
+  -- Common validation
+  MISSING_PARAMS = { code = -32602, message = "Missing params" },
+  INVALID_FIELD_TYPE = { code = -32602, message = "'fields' must be a non-empty table" },
+  INVALID_BY_PARAM = { code = -32602, message = "Invalid 'by' param" },
+  NO_VALID_FIELDS = { code = -32604, message = "No valid fields to update" },
+
+  -- Existence / duplication
+  UNIT_NOT_FOUND = { code = -32102, message = "Unit is not exists" },
+  UNIT_EXISTS = { code = -32101, message = "Unit is already exists" },
+
+  -- Database & constraint
+  UNIQUE_CONSTRAINT = { code = -32602, message = "Unique constraint failed" },
+  DB_QUERY_FAILED = { code = -32001, message = "Database query failed" },
+  DB_EXEC_FAILED = { code = -32002, message = "Database execution failed" },
+  DB_INSERT_FAILED = { code = -32003, message = "Failed to create unit" },
+  DB_DELETE_FAILED = { code = -32004, message = "Failed to delete unit" },
+
+  -- Generic fallback
+  UNKNOWN = { code = -32099, message = "Unexpected internal error" },
+}
+
+return errors

com/Auth/GetAccess.lua

@@ -1,63 +0,0 @@
----@diagnostic disable: redefined-local
-local db = require("internal.database-sqlite").connect("db/user-database.db", {log = true})
-local log = require("internal.log")
-local session = require("internal.session")
-local crypt = require("internal.crypt.bcrypt")
-
-local function close_db()
-  if db then
-    db:close()
-    db = nil
-  end
-end
-
-local function error_response(message, code, data)
-  session.response.error = {
-    code = code or -32600,
-    message = message,
-    data = data or nil
-  }
-  close_db()
-end
-
-local params = session.request.params
-if not params then
-  return error_response("No params provided")
-end
-
-if not (params.username and params.email and params.password) then
-  return error_response("Missing username, email or password", -32602)
-end
-
-local unit, err = db:query(
-  "SELECT id, username, email, password, created_at FROM users WHERE email = ? AND username = ? LIMIT 1",
-  {params.email, params.username}
-)
-
-if err then
-  log.error("DB query error: " .. tostring(err))
-  return error_response("Database query failed")
-end
-
-if not unit or #unit == 0 then
-  return error_response("Unit not found", -32604)
-end
-
-unit = unit[1]
-
-local ok = crypt.compare(unit.password, params.password)
-if not ok then
-  log.warn("Login failed: wrong password for " .. params.username)
-  return error_response("Invalid password", -32605)
-end
-
-session.response.result = {
-  user = {
-    id = unit.id,
-    username = unit.username,
-    email = unit.email,
-    created_at = unit.created_at
-  }
-}
-
-close_db()

com/Auth/NewUnit.lua

@@ -1,77 +0,0 @@
----@diagnostic disable: redefined-local
-local db = require("internal.database-sqlite").connect("db/user-database.db", {log = true})
-local log = require("internal.log")
-local session = require("internal.session")
-local crypt = require("internal.crypt.bcrypt")
-
-if not session.request.params then
-  session.response.error = {
-    message = "no params provided"
-  }
-  return
-end
-
-local params = session.request.params
-
-if not (params.username and params.email and params.password) then
-  session.response.error = {
-    message = "no username/email/password provided"
-  }
-  return
-end
-
-local hashPass = crypt.generate(params.password, crypt.DefaultCost)
-
-local existing, err = db:query("SELECT 1 FROM users WHERE email = ? OR username = ? LIMIT 1", {
-  params.email,
-  params.username
-})
-if err ~= nil then
-  session.response.error = {
-    message = "Database check failed: "..tostring(err)
-  }
-  log.error("Email check failed: "..tostring(err))
-  return
-end
-
-if existing and #existing > 0 then
-  session.response.error = {
-    code = -32604,
-    message = "Unit already exists"
-  }
-  return
-end
-
-local ctx, err = db:exec(
-  "INSERT INTO users (username, email, password) VALUES (?, ?, ?)",
-  {
-    params.username,
-    params.email,
-    hashPass
-  }
-)
-if err ~= nil then
-  session.response.error = {
-    code = -32605,
-    message = "Insert failed: "..tostring(err)
-  }
-  log.error("Insert failed: "..tostring(err))
-  return
-end
-
-local res, err = ctx:wait()
-if err ~= nil then
-  session.response.error = {
-    code = -32606,
-    message = "Insert confirmation failed: "..tostring(err)
-  }
-  log.error("Insert confirmation failed: "..tostring(err))
-  return
-end
-
-session.response.result = {
-  rows_affected = res,
-  message = "Unit created successfully"
-}
-
-db:close()

com/Echo.lua

@@ -0,0 +1,11 @@
+local s = require("internal.session")
+
+if not s.request.params.__fetched.data then
+  s.response.error = {
+    code = 123,
+    message = "params.data is missing"
+  }
+  return
+end
+
+s.response.send(s.request.params.__fetched)

com/List.lua

@@ -2,7 +2,9 @@
 
 local session = require("internal.session")
 
-if session.request.params.about then
+local params = session.request.params.get()
+
+if params.about then
   session.response.result = {
     description = "Returns a list of available methods",
     params = {
@@ -48,8 +50,8 @@ local function scanDirectory(basePath, targetPath)
 end
 
 local basePath = "com"
-local layer = session.request and session.request.params.layer and session.request.params.layer:gsub(">", "/") or nil
+local layer = params.layer and params.layer:gsub(">", "/") or nil
 
-session.response.result = {
+session.response.send({
   answer = layer and scanDirectory(basePath, layer) or scanDirectory(basePath, "")
-}
+})

com/Unit/Create.lua

@@ -0,0 +1,68 @@
+-- File com/Unit/Create.lua
+--
+-- Created at 2025-05-10 18:23
+--
+-- Updated at - 
+-- Description:
+--- Creates a record in the unit.db database without 
+--- requiring additional permissions. Requires username, 
+--- password (hashing occurs at the server level), and email fields.
+
+local log = require("internal.log")
+local db = require("internal.database.sqlite").connect("db/unit.db", {log = true})
+local session = require("internal.session")
+local crypt = require("internal.crypt.bcrypt")
+local sha256 = require("internal.crypt.sha256")
+
+local common = require("com/Unit/_common")
+local errors = require("com/Unit/_errors")
+
+-- Preparing for first db query
+local function close_db()
+  if db then
+    log.debug("Closing DB connection")
+    db:close()
+    db = nil
+  end
+end
+
+local params = session.request.params.get()
+
+local ok, mp = common.CheckMissingElement({"username", "password", "email"}, params)
+if not ok then
+  close_db()
+  session.response.send_error(errors.MISSING_PARAMS.code, errors.MISSING_PARAMS.message, mp)
+end
+
+local hashPass = crypt.generate(params.password, crypt.DefaultCost)
+local unitID = string.sub(sha256.hash(session.__seed), 1, 16)
+
+local ctx, err = db:exec(
+  "INSERT INTO units (user_id, username, email, password) VALUES (?, ?, ?, ?)",
+  {
+    unitID,
+    params.username,
+    params.email,
+    hashPass,
+  }
+)
+
+if err ~= nil then
+  log.error("Insert failed: "..tostring(err))
+  close_db()
+  session.response.send_error(errors.DB_INSERT_FAILED.code, errors.DB_INSERT_FAILED.message)
+end
+
+local _, err = ctx:wait()
+if err ~= nil then
+  close_db()
+  if tostring(err):match("UNIQUE constraint failed") then
+    session.response.send_error(errors.UNIT_EXISTS.code, errors.UNIT_EXISTS.message)
+  else
+    log.error("Insert confirmation failed: "..tostring(err))
+  session.response.send_error()
+  end
+end
+
+close_db()
+session.response.send({unit_id = unitID})

com/Unit/Delete.lua

@@ -0,0 +1,77 @@
+-- File com/Unit/Delete.lua
+--
+-- Created at 2025-05-10 19:18
+--
+-- Updated at - 
+
+local log = require("internal.log")
+local db = require("internal.database.sqlite").connect("db/unit.db", {log = true})
+local session = require("internal.session")
+
+local common = require("com/Unit/_common")
+local errors = require("com/Unit/_errors")
+
+-- Preparing for first db query
+local function close_db()
+  if db then
+    log.debug("Closing DB connection")
+    db:close()
+    db = nil
+  end
+end
+
+local params = session.request.params.get()
+
+local ok, mp = common.CheckMissingElement({"user_id"}, params)
+if not ok then
+  close_db()
+  session.response.send_error(errors.MISSING_PARAMS.code, errors.MISSING_PARAMS.message, mp)
+end
+
+local existing, err = db:query([[
+  SELECT 1
+  FROM units
+  WHERE user_id = ?
+    AND entry_status != 'deleted'
+    AND deleted_at IS NULL
+  LIMIT 1
+]], {
+  params.user_id
+})
+
+if err ~= nil then
+  log.error("Email check failed: "..tostring(err))
+  close_db()
+  session.response.send_error()
+end
+
+if existing and #existing == 0 then
+  close_db()
+  session.response.send_error(errors.UNIT_NOT_FOUND.code, errors.UNIT_NOT_FOUND.message)
+end
+
+local ctx, err = db:exec(
+  [[
+    UPDATE units
+    SET entry_status = 'deleted',
+        deleted_at = CURRENT_TIMESTAMP
+    WHERE user_id = ? AND deleted_at is NULL
+  ]],
+  { params.user_id }
+)
+
+if err ~= nil then
+  log.error("Soft delete failed: " .. tostring(err))
+  close_db()
+  session.response.send_error(errors.DB_DELETE_FAILED.code, errors.DB_DELETE_FAILED.message)
+end
+
+local res, err = ctx:wait()
+if err ~= nil then
+  log.error("Soft delete confirmation failed: " .. tostring(err))
+  close_db()
+  session.response.send_error(errors.DB_DELETE_FAILED.code, errors.DB_DELETE_FAILED.message)
+end
+
+close_db()
+session.response.send()

com/Unit/Get.lua

@@ -0,0 +1,55 @@
+-- File com/Unit/Get.lua
+--
+-- Created at 2025-09-25 20:04
+--
+-- Updated at - 
+
+local log = require("internal.log")
+local db = require("internal.database.sqlite").connect("db/unit.db", {log = true})
+local session = require("internal.session")
+
+local common = require("com/Unit/_common")
+local errors = require("com/Unit/_errors")
+
+-- Preparing for first db query
+local function close_db()
+  if db then
+    log.debug("Closing DB connection")
+    db:close()
+    db = nil
+  end
+end
+
+local params = session.request.params.get()
+
+local ok, mp = common.CheckMissingElement({"by", "value"}, params)
+if not ok then
+  close_db()
+  session.response.send_error(errors.MISSING_PARAMS.code, errors.MISSING_PARAMS.message, mp)
+end
+
+if not (params.by == "email" or params.by == "username" or params.by == "user_id") then
+  close_db()
+  session.response.send_error(errors.INVALID_BY_PARAM.code, errors.INVALID_BY_PARAM.message)
+end
+
+local unit, err = db:query_row(
+  "SELECT user_id, username, email, created_at, updated_at, deleted_at, entry_status FROM units WHERE "..params.by.." = ? AND deleted_at IS NULL LIMIT 1",
+  {
+    params.value
+  }
+)
+
+if err then
+  close_db()
+  log.error("DB query error: " .. tostring(err))
+  session.response.send_error()
+end
+
+if not unit then
+  close_db()
+  session.response.send_error(errors.UNIT_NOT_FOUND.code, errors.UNIT_NOT_FOUND.message)
+end
+
+close_db()
+session.response.send(unit)

com/Unit/Update.lua

@@ -0,0 +1,102 @@
+-- File com/Unit/Update.lua
+--
+-- Created at 2025-10-10
+--
+
+local log = require("internal.log")
+local db = require("internal.database.sqlite").connect("db/unit.db", { log = true })
+local session = require("internal.session")
+
+local common = require("com/Unit/_common")
+local errors = require("com/Unit/_errors")
+
+local function close_db()
+  if db then
+    log.debug("Closing DB connection")
+    db:close()
+    db = nil
+  end
+end
+
+local params = session.request.params.get()
+
+local ok, mp = common.CheckMissingElement({"user_id", "fields"}, params)
+if not ok then
+  close_db()
+  session.response.send_error(errors.MISSING_PARAMS.code, errors.MISSING_PARAMS.message, mp)
+end
+
+if type(params.fields) ~= "table" or next(params.fields) == nil then
+  close_db()
+  session.response.send_error(errors.INVALID_FIELD_TYPE.code, errors.INVALID_FIELD_TYPE.message)
+end
+
+local allowed = {
+  username = true,
+  email = true,
+  password = true,
+  entry_status = true
+}
+
+local exists = db:query_row(
+  "SELECT 1 FROM units WHERE user_id = ? AND deleted_at IS NULL LIMIT 1",
+  { params.user_id }
+)
+
+if not exists then
+  close_db()
+  session.response.send_error(errors.UNIT_NOT_FOUND.code, errors.UNIT_NOT_FOUND.message)
+end
+
+local set_clauses = {}
+local values = {}
+
+for k, v in pairs(params.fields) do
+  if allowed[k] then
+    if k == "password" then
+      local crypt = require("internal.crypt.bcrypt")
+      v = crypt.generate(v, crypt.DefaultCost)
+    end
+    table.insert(set_clauses, k .. " = ?")
+    table.insert(values, v)
+  else
+    log.warn("Ignoring unsupported field: " .. k)
+  end
+end
+
+if #set_clauses == 0 then
+  close_db()
+  session.response.send_error(errors.NO_VALID_FIELDS.code, errors.NO_VALID_FIELDS.message)
+end
+
+table.insert(set_clauses, "updated_at = CURRENT_TIMESTAMP")
+
+local query = "UPDATE units SET " .. table.concat(set_clauses, ", ")
+  .. " WHERE user_id = ? AND deleted_at IS NULL"
+
+table.insert(values, params.user_id)
+
+local ctx, err = db:exec(query, values)
+if not ctx then
+  close_db()
+  if tostring(err):match("UNIQUE constraint failed") then
+    session.response.send_error(errors.UNIQUE_CONSTRAINT.code, errors.UNIQUE_CONSTRAINT.message)
+  else
+    session.response.send_error()
+  end
+end
+
+local _, err = ctx:wait()
+if err ~= nil then
+  close_db()
+  if tostring(err):match("UNIQUE constraint failed") then
+    session.response.send_error(errors.UNIQUE_CONSTRAINT.code, errors.UNIQUE_CONSTRAINT.message)
+  else
+    log.error("Insert confirmation failed: "..tostring(err))
+  session.response.send_error()
+  end
+end
+
+close_db()
+
+session.response.send()

com/Unit/_common.lua

@@ -0,0 +1,23 @@
+-- File com/Unit/_common.lua
+--
+-- Created at 2025-05-10 18:23
+--
+-- Updated at - 
+-- Description:
+--- Common functions for Unit module
+
+local common = {}
+
+function common.CheckMissingElement(arr, cmp)
+  local is_missing = {}
+  local ok = true
+  for _, key in ipairs(arr) do
+    if cmp[key] == nil then
+      table.insert(is_missing, key)
+      ok = false
+    end
+  end
+  return ok, is_missing
+end
+
+return common

com/Unit/_errors.lua

@@ -0,0 +1,30 @@
+-- File com/Unit/_errors.lua
+--
+-- Created at 2025-10-10
+-- Description:
+--- Centralized error definitions for Unit operations
+--- to keep API responses consistent and clean.
+
+local errors = {
+  -- Common validation
+  MISSING_PARAMS = { code = -32602, message = "Missing params" },
+  INVALID_FIELD_TYPE = { code = -32602, message = "'fields' must be a non-empty table" },
+  INVALID_BY_PARAM = { code = -32602, message = "Invalid 'by' param" },
+  NO_VALID_FIELDS = { code = -32604, message = "No valid fields to update" },
+
+  -- Existence / duplication
+  UNIT_NOT_FOUND = { code = -32102, message = "Unit is not exists" },
+  UNIT_EXISTS = { code = -32101, message = "Unit is already exists" },
+
+  -- Database & constraint
+  UNIQUE_CONSTRAINT = { code = -32602, message = "Unique constraint failed" },
+  DB_QUERY_FAILED = { code = -32001, message = "Database query failed" },
+  DB_EXEC_FAILED = { code = -32002, message = "Database execution failed" },
+  DB_INSERT_FAILED = { code = -32003, message = "Failed to create unit" },
+  DB_DELETE_FAILED = { code = -32004, message = "Failed to delete unit" },
+
+  -- Generic fallback
+  UNKNOWN = { code = -32099, message = "Unexpected internal error" },
+}
+
+return errors

com/_DB/Put.lua

@@ -1,66 +0,0 @@
----@diagnostic disable: redefined-local
-local db = require("internal.database-sqlite").connect("db/test.db", {log = true})
-local log = require("internal.log")
-local session = require("internal.session")
-
-if not (session.request.params.name and session.request.params.email) then
-  session.response.error = {
-    code = -32602,
-    message = "Name and email are required"
-  }
-  return
-end
-
-local existing, err = db:query("SELECT 1 FROM users WHERE email = ? LIMIT 1", {
-  session.request.params.email
-})
-if err ~= nil then
-  session.response.error = {
-    code = -32603,
-    message = "Database check failed: "..tostring(err)
-  }
-  log.error("Email check failed: "..tostring(err))
-  return
-end
-
-if existing and #existing > 0 then
-  session.response.error = {
-    code = -32604,
-    message = "Email already exists"
-  }
-  return
-end
-
-local ctx, err = db:exec(
-  "INSERT INTO users (name, email) VALUES (?, ?)", 
-  {
-    session.request.params.name,
-    session.request.params.email
-  }
-)
-if err ~= nil then
-  session.response.error = {
-    code = -32605,
-    message = "Insert failed: "..tostring(err)
-  }
-  log.error("Insert failed: "..tostring(err))
-  return
-end
-
-local res, err = ctx:wait()
-if err ~= nil then
-  session.response.error = {
-    code = -32606,
-    message = "Insert confirmation failed: "..tostring(err)
-  }
-  log.error("Insert confirmation failed: "..tostring(err))
-  return
-end
-
-session.response.result = {
-  success = true,
-  rows_affected = res,
-  message = "User created successfully"
-}
-
-db:close()

com/_Net/GetExpl.lua

@@ -1,29 +0,0 @@
-local session = require("internal.session")
-local net = require("internal.net")
-
-local reqAddr
-local logReq = true
-
-if session.request.params and session.request.params.url then
-  reqAddr = session.request.params.url
-else
-  session.response.error = {
-    code = -32602,
-    message = "no url provided"
-  }
-  return
-end
-
-local resp = net.http.get_request(logReq, reqAddr)
-if resp then
-  session.response.result.answer = {
-    status = resp.status,
-    body = resp.body
-  }
-  return
-end
-
-session.response.error = {
-  data = "error while requesting"
-}
-

com/_Net/PostExpl.lua

@@ -1,35 +0,0 @@
-local session = require("internal.session")
-local net = require("internal.net")
-local log = require("internal.log")
-
-local reqAddr
-local logReq = true
-local payload
-
-log.debug(session.request.params)
-
-if not (session.request.params and session.request.params.url) then
-  session.response.error = {
-    code = -32602,
-    message = "no url or payload provided"
-  }
-  return
-end
-
-
-
-reqAddr = session.request.params.url
-payload = session.request.params.payload
-
-local resp = net.http.post_request(logReq, reqAddr, "application/json", payload)
-if resp then
-  session.response.result.answer = {
-    status = resp.status,
-    body = resp.body
-  }
-  return
-end
-
-session.response.error = {
-  data = "error while requesting"
-}

com/_prepare.lua

@@ -2,15 +2,3 @@
 package.path = package.path .. ";/usr/lib64/lua/5.1/?.lua;/usr/local/share/lua/5.1/?.lua" .. ";./com/?.lua;"
 package.cpath = package.cpath .. ";/usr/lib64/lua/5.1/?.so;/usr/local/lib/lua/5.1/?.so"
 
-print = function() end
-io.write = function(...) end
-io.stdout = function() return nil end
-io.stderr = function() return nil end
-io.read = function(...) return nil end
-
----@type table<string, any>
-Status = {
-	ok = "ok",
-	error = "error",
-	invalid = "invalid",
-}

config-example.yaml

@@ -1,30 +0,0 @@
-node:
-  mode: dev
-  name: "My gosally node"
-  show_config: true
-  com_dir: "%path%/com"
-
-http_server:
-  address: "0.0.0.0"
-  port: "8080"
-  session_ttl: 5s
-  timeout: 3s
-  idle_timeout: 30s
-
-tls:
-  enabled: true
-  cert_file: "%path%/cert/fullchain.pem"
-  key_file: "%path%/cert/privkey.pem"
-
-updates:
-  enabled: false
-  check-interval: 1h
-  repository_url: "https://repo.serve.lv/raw/go-sally"
-
-log:
-  json_format: false
-  level: "debug"
-
-disable_warnings:
-  - --WNonStdTmpDir
-  - --WUndefLogLevel

internal/server/rpc/responsers.go

@@ -1,33 +0,0 @@
-package rpc
-
-import "encoding/json"
-
-func NewError(code int, message string, data any, id *json.RawMessage) *RPCResponse {
-	if data != nil {
-		return &RPCResponse{
-			JSONRPC: JSONRPCVersion,
-			ID:      id,
-			Error: map[string]any{
-				"code":    code,
-				"message": message,
-				"data":    data,
-			},
-		}
-	}
-	return &RPCResponse{
-		JSONRPC: JSONRPCVersion,
-		ID:      id,
-		Error: map[string]any{
-			"code":    code,
-			"message": message,
-		},
-	}
-}
-
-func NewResponse(result any, id *json.RawMessage) *RPCResponse {
-	return &RPCResponse{
-		JSONRPC: JSONRPCVersion,
-		ID:      id,
-		Result:  result,
-	}
-}

internal/server/sv1/lua_handler.go

@@ -1,418 +0,0 @@
-package sv1
-
-// TODO: make a lua state pool using sync.Pool
-
-import (
-	"fmt"
-	"io"
-	"log/slog"
-	"math/rand/v2"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"golang.org/x/crypto/bcrypt"
-
-	"github.com/akyaiy/GoSally-mvp/internal/colors"
-	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
-	lua "github.com/yuin/gopher-lua"
-	_ "modernc.org/sqlite"
-)
-
-func addInitiatorHeaders(sid string, req *http.Request, headers http.Header) {
-	clientIP := req.RemoteAddr
-	if forwardedFor := req.Header.Get("X-Forwarded-For"); forwardedFor != "" {
-		clientIP = forwardedFor
-	}
-	headers.Set("X-Initiator-IP", clientIP)
-	headers.Set("X-Session-UUID", sid)
-	headers.Set("X-Initiator-Host", req.Host)
-	headers.Set("X-Initiator-User-Agent", req.UserAgent())
-	headers.Set("X-Initiator-Referer", req.Referer())
-}
-
-// A small reminder: this code is only at the MVP stage,
-// and some parts of the code may cause shock from the
-// incompetence of the developer. But, in the end,
-// this code is just an idea. If there is a desire to
-// contribute to the development of the code,
-// I will be only glad.
-// TODO: make this huge function more harmonious by dividing responsibilities
-func (h *HandlerV1) handleLUA(sid string, r *http.Request, req *rpc.RPCRequest, path string) *rpc.RPCResponse {
-	llog := h.x.SLog.With(slog.String("session-id", sid))
-	llog.Debug("handling LUA")
-	L := lua.NewState()
-	defer L.Close()
-
-	seed := rand.Int()
-
-	loadSessionMod := func(lL *lua.LState) int {
-		llog.Debug("import module session", slog.String("script", path))
-		sessionMod := lL.NewTable()
-		inTable := lL.NewTable()
-		paramsTable := lL.NewTable()
-		if fetchedParams, ok := req.Params.(map[string]any); ok {
-			for k, v := range fetchedParams {
-				lL.SetField(paramsTable, k, ConvertGolangTypesToLua(lL, v))
-			}
-		}
-		lL.SetField(inTable, "params", paramsTable)
-
-		outTable := lL.NewTable()
-		resultTable := lL.NewTable()
-		lL.SetField(outTable, "result", resultTable)
-
-		lL.SetField(inTable, "address", lua.LString(r.RemoteAddr))
-		lL.SetField(sessionMod, "request", inTable)
-		lL.SetField(sessionMod, "response", outTable)
-
-		lL.SetField(sessionMod, "id", lua.LString(sid))
-
-		lL.SetField(sessionMod, "__gosally_internal", lua.LString(fmt.Sprint(seed)))
-		lL.Push(sessionMod)
-		return 1
-	}
-
-	loadLogMod := func(lL *lua.LState) int {
-		llog.Debug("import module log", slog.String("script", path))
-		logMod := lL.NewTable()
-
-		logFuncs := map[string]func(string, ...any){
-			"info":  llog.Info,
-			"debug": llog.Debug,
-			"error": llog.Error,
-			"warn":  llog.Warn,
-		}
-
-		for name, logFunc := range logFuncs {
-			fun := logFunc
-			lL.SetField(logMod, name, lL.NewFunction(func(lL *lua.LState) int {
-				msg := lL.Get(1)
-				converted := ConvertLuaTypesToGolang(msg)
-				fun(fmt.Sprintf("the script says: %s", converted), slog.String("script", path))
-				return 0
-			}))
-		}
-
-		for _, fn := range []struct {
-			field string
-			pfunc func(string, ...any)
-			color func() string
-		}{
-			{"event", h.x.Log.Printf, nil},
-			{"event_error", h.x.Log.Printf, colors.PrintError},
-			{"event_warn", h.x.Log.Printf, colors.PrintWarn},
-		} {
-			lL.SetField(logMod, fn.field, lL.NewFunction(func(lL *lua.LState) int {
-				msg := lL.Get(1)
-				converted := ConvertLuaTypesToGolang(msg)
-				if fn.color != nil {
-					h.x.Log.Printf("%s: %s: %s", fn.color(), path, converted)
-				} else {
-					h.x.Log.Printf("%s: %s", path, converted)
-				}
-				return 0
-			}))
-		}
-
-		lL.SetField(logMod, "__gosally_internal", lua.LString(fmt.Sprint(seed)))
-		lL.Push(logMod)
-		return 1
-	}
-
-	loadNetMod := func(lL *lua.LState) int {
-		llog.Debug("import module net", slog.String("script", path))
-		netMod := lL.NewTable()
-		netModhttp := lL.NewTable()
-
-		lL.SetField(netModhttp, "get_request", lL.NewFunction(func(lL *lua.LState) int {
-			logRequest := lL.ToBool(1)
-			url := lL.ToString(2)
-
-			req, err := http.NewRequest("GET", url, nil)
-			if err != nil {
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString(err.Error()))
-				return 2
-			}
-
-			addInitiatorHeaders(sid, r, req.Header)
-
-			client := &http.Client{}
-			resp, err := client.Do(req)
-			if err != nil {
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString(err.Error()))
-				return 2
-			}
-			defer resp.Body.Close()
-
-			body, err := io.ReadAll(resp.Body)
-			if err != nil {
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString(err.Error()))
-				return 2
-			}
-
-			if logRequest {
-				llog.Info("HTTP GET request",
-					slog.String("script", path),
-					slog.String("url", url),
-					slog.Int("status", resp.StatusCode),
-					slog.String("status_text", resp.Status),
-					slog.String("initiator_ip", req.Header.Get("X-Initiator-IP")),
-				)
-			}
-
-			result := lL.NewTable()
-			lL.SetField(result, "status", lua.LNumber(resp.StatusCode))
-			lL.SetField(result, "status_text", lua.LString(resp.Status))
-			lL.SetField(result, "body", lua.LString(body))
-			lL.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
-
-			headers := lL.NewTable()
-			for k, v := range resp.Header {
-				lL.SetField(headers, k, ConvertGolangTypesToLua(lL, v))
-			}
-			lL.SetField(result, "headers", headers)
-
-			lL.Push(result)
-			return 1
-		}))
-
-		lL.SetField(netModhttp, "post_request", lL.NewFunction(func(lL *lua.LState) int {
-			logRequest := lL.ToBool(1)
-			url := lL.ToString(2)
-			contentType := lL.ToString(3)
-			payload := lL.ToString(4)
-
-			body := strings.NewReader(payload)
-
-			req, err := http.NewRequest("POST", url, body)
-			if err != nil {
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString(err.Error()))
-				return 2
-			}
-
-			req.Header.Set("Content-Type", contentType)
-
-			addInitiatorHeaders(sid, r, req.Header)
-
-			client := &http.Client{}
-			resp, err := client.Do(req)
-			if err != nil {
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString(err.Error()))
-				return 2
-			}
-			defer resp.Body.Close()
-
-			respBody, err := io.ReadAll(resp.Body)
-			if err != nil {
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString(err.Error()))
-				return 2
-			}
-
-			if logRequest {
-				llog.Info("HTTP POST request",
-					slog.String("script", path),
-					slog.String("url", url),
-					slog.String("content_type", contentType),
-					slog.Int("status", resp.StatusCode),
-					slog.String("status_text", resp.Status),
-					slog.String("initiator_ip", req.Header.Get("X-Initiator-IP")),
-				)
-			}
-
-			result := lL.NewTable()
-			lL.SetField(result, "status", lua.LNumber(resp.StatusCode))
-			lL.SetField(result, "status_text", lua.LString(resp.Status))
-			lL.SetField(result, "body", lua.LString(respBody))
-			lL.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
-
-			headers := lL.NewTable()
-			for k, v := range resp.Header {
-				lL.SetField(headers, k, ConvertGolangTypesToLua(lL, v))
-			}
-			lL.SetField(result, "headers", headers)
-
-			lL.Push(result)
-			return 1
-		}))
-
-		lL.SetField(netMod, "http", netModhttp)
-
-		lL.SetField(netMod, "__gosally_internal", lua.LString(fmt.Sprint(seed)))
-		lL.Push(netMod)
-		return 1
-	}
-
-	loadCryptbcryptMod := func(lL *lua.LState) int {
-		llog.Debug("import module crypt.bcrypt", slog.String("script", path))
-		bcryptMod := lL.NewTable()
-
-		lL.SetField(bcryptMod, "MinCost", lua.LNumber(bcrypt.MinCost))
-		lL.SetField(bcryptMod, "MaxCost", lua.LNumber(bcrypt.MaxCost))
-		lL.SetField(bcryptMod, "DefaultCost", lua.LNumber(bcrypt.DefaultCost))
-
-		lL.SetField(bcryptMod, "generate", lL.NewFunction(func(l *lua.LState) int {
-			password := ConvertLuaTypesToGolang(lL.Get(1))
-			passwordStr, ok := password.(string)
-			if !ok {
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString("error: password must be a string"))
-				return 2
-			}
-
-			cost := ConvertLuaTypesToGolang(lL.Get(2))
-			costInt := bcrypt.DefaultCost
-			switch v := cost.(type) {
-			case int:
-				costInt = v
-			case float64:
-				costInt = int(v)
-			case nil:
-				// ok, use DefaultCost
-			default:
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString("error: cost must be an integer"))
-				return 2
-			}
-
-			hashBytes, err := bcrypt.GenerateFromPassword([]byte(passwordStr), costInt)
-			if err != nil {
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString("error: " + err.Error()))
-				return 2
-			}
-
-			lL.Push(lua.LString(string(hashBytes)))
-			lL.Push(lua.LNil)
-			return 2
-		}))
-
-		lL.SetField(bcryptMod, "compare", lL.NewFunction(func(l *lua.LState) int {
-			hash := ConvertLuaTypesToGolang(lL.Get(1))
-			hashStr, ok := hash.(string)
-			if !ok {
-				lL.Push(lua.LString("error: hash must be a string"))
-				return 1
-			}
-			password := ConvertLuaTypesToGolang(lL.Get(2))
-			passwordStr, ok := password.(string)
-			if !ok {
-				lL.Push(lua.LString("error: password must be a string"))
-				return 1
-			}
-
-			err := bcrypt.CompareHashAndPassword([]byte(hashStr), []byte(passwordStr))
-			if err != nil {
-				lL.Push(lua.LFalse)
-				return 1
-			}
-			lL.Push(lua.LTrue)
-			return 1
-		}))
-
-		lL.SetField(bcryptMod, "__gosally_internal", lua.LString(fmt.Sprint(seed)))
-		lL.Push(bcryptMod)
-		return 1
-	}
-
-	L.PreloadModule("internal.session", loadSessionMod)
-	L.PreloadModule("internal.log", loadLogMod)
-	L.PreloadModule("internal.net", loadNetMod)
-	L.PreloadModule("internal.database-sqlite", loadDBMod(llog))
-	L.PreloadModule("internal.crypt.bcrypt", loadCryptbcryptMod)
-
-	llog.Debug("preparing environment")
-	prep := filepath.Join(*h.x.Config.Conf.Node.ComDir, "_prepare.lua")
-	if _, err := os.Stat(prep); err == nil {
-		if err := L.DoFile(prep); err != nil {
-			llog.Error("script error", slog.String("script", path), slog.String("error", err.Error()))
-			return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
-		}
-	}
-	llog.Debug("executing script", slog.String("script", path))
-	if err := L.DoFile(path); err != nil {
-		llog.Error("script error", slog.String("script", path), slog.String("error", err.Error()))
-		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
-	}
-
-	pkg := L.GetGlobal("package")
-	pkgTbl, ok := pkg.(*lua.LTable)
-	if !ok {
-		llog.Error("script error", slog.String("script", path), slog.String("error", "package not found"))
-		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
-	}
-
-	loaded := pkgTbl.RawGetString("loaded")
-	loadedTbl, ok := loaded.(*lua.LTable)
-	if !ok {
-		llog.Error("script error", slog.String("script", path), slog.String("error", "package.loaded not found"))
-		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
-	}
-
-	sessionVal := loadedTbl.RawGetString("internal.session")
-	sessionTbl, ok := sessionVal.(*lua.LTable)
-	if !ok {
-		return rpc.NewResponse(map[string]any{
-			"responsible-node": h.cs.UUID32,
-		}, req.ID)
-	}
-
-	tag := sessionTbl.RawGetString("__gosally_internal")
-	if tag.Type() != lua.LTString || tag.String() != fmt.Sprint(seed) {
-		llog.Debug("stock session module is not imported: wrong seed", slog.String("script", path))
-		return rpc.NewResponse(map[string]any{
-			"responsible-node": h.cs.UUID32,
-		}, req.ID)
-	}
-
-	outVal := sessionTbl.RawGetString("response")
-	outTbl, ok := outVal.(*lua.LTable)
-	if !ok {
-		llog.Error("script error", slog.String("script", path), slog.String("error", "response is not a table"))
-		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
-	}
-
-	if errVal := outTbl.RawGetString("error"); errVal != lua.LNil {
-		llog.Debug("catch error table", slog.String("script", path))
-		if errTbl, ok := errVal.(*lua.LTable); ok {
-			code := rpc.ErrInternalError
-			message := rpc.ErrInternalErrorS
-			data := make(map[string]any)
-			if c := errTbl.RawGetString("code"); c.Type() == lua.LTNumber {
-				code = int(c.(lua.LNumber))
-			}
-			if msg := errTbl.RawGetString("message"); msg.Type() == lua.LTString {
-				message = msg.String()
-			}
-			rawData := errTbl.RawGetString("data")
-
-			if tbl, ok := rawData.(*lua.LTable); ok {
-				tbl.ForEach(func(k, v lua.LValue) { data[k.String()] = ConvertLuaTypesToGolang(v) })
-			} else {
-				llog.Error("the script terminated with an error", slog.String("code", strconv.Itoa(code)), slog.String("message", message))
-				return rpc.NewError(code, message, ConvertLuaTypesToGolang(rawData), req.ID)
-			}
-			llog.Error("the script terminated with an error", slog.String("code", strconv.Itoa(code)), slog.String("message", message))
-			return rpc.NewError(code, message, data, req.ID)
-		}
-		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
-	}
-
-	resultVal := outTbl.RawGetString("result")
-	payload := make(map[string]any)
-	if tbl, ok := resultVal.(*lua.LTable); ok {
-		tbl.ForEach(func(k, v lua.LValue) { payload[k.String()] = ConvertLuaTypesToGolang(v) })
-	} else {
-		payload["message"] = ConvertLuaTypesToGolang(resultVal)
-	}
-	payload["responsible-node"] = h.cs.UUID32
-	return rpc.NewResponse(payload, req.ID)
-}

internal/server/sv1/lua_types.go

@@ -1,77 +0,0 @@
-package sv1
-
-import (
-	"fmt"
-
-	lua "github.com/yuin/gopher-lua"
-)
-
-func ConvertLuaTypesToGolang(value lua.LValue) any {
-	switch value.Type() {
-	case lua.LTString:
-		return value.String()
-	case lua.LTNumber:
-		return float64(value.(lua.LNumber))
-	case lua.LTBool:
-		return bool(value.(lua.LBool))
-	case lua.LTTable:
-		tbl := value.(*lua.LTable)
-
-		var arr []any
-		isArray := true
-		tbl.ForEach(func(key, val lua.LValue) {
-			if key.Type() != lua.LTNumber {
-				isArray = false
-			}
-			arr = append(arr, ConvertLuaTypesToGolang(val))
-		})
-
-		if isArray {
-			return arr
-		}
-
-		result := make(map[string]any)
-		tbl.ForEach(func(key, val lua.LValue) {
-			result[key.String()] = ConvertLuaTypesToGolang(val)
-		})
-		return result
-
-	case lua.LTNil:
-		return nil
-	default:
-		return value.String()
-	}
-}
-
-func ConvertGolangTypesToLua(L *lua.LState, val any) lua.LValue {
-	switch v := val.(type) {
-	case string:
-		return lua.LString(v)
-	case bool:
-		return lua.LBool(v)
-	case int:
-		return lua.LNumber(float64(v))
-	case int64:
-		return lua.LNumber(float64(v))
-	case float32:
-		return lua.LNumber(float64(v))
-	case float64:
-		return lua.LNumber(v)
-	case []any:
-		tbl := L.NewTable()
-		for i, item := range v {
-			tbl.RawSetInt(i+1, ConvertGolangTypesToLua(L, item))
-		}
-		return tbl
-	case map[string]any:
-		tbl := L.NewTable()
-		for key, value := range v {
-			tbl.RawSetString(key, ConvertGolangTypesToLua(L, value))
-		}
-		return tbl
-	case nil:
-		return lua.LNil
-	default:
-		return lua.LString(fmt.Sprintf("%v", v))
-	}
-}

main.go

@@ -1,10 +0,0 @@
-package main
-
-import (
-	"github.com/akyaiy/GoSally-mvp/cmd"
-	_ "modernc.org/sqlite"
-)
-
-func main() {
-	cmd.Execute()
-}

src/cmd/root.go

@@ -1,3 +1,5 @@
+// The cmd package is the main package where all the main hooks and methods are called.
+// GoSally uses spf13/cobra to organize all the calls.
 package cmd
 
 import (
@@ -5,9 +7,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/akyaiy/GoSally-mvp/hooks"
-	"github.com/akyaiy/GoSally-mvp/internal/colors"
-	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/hooks"
+	"github.com/akyaiy/GoSally-mvp/src/internal/colors"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
 	"github.com/spf13/cobra"
 )
 
@@ -22,6 +24,8 @@ scripts in a given directory. For more information, visit: https://gosally.oblat
 	},
 }
 
+// Execute prepares global log, loads cmdline args
+// and executes rootCmd.Execute()
 func Execute() {
 	log.SetOutput(os.Stdout)
 	log.SetPrefix(colors.SetBrightBlack(fmt.Sprintf("(%s) ", corestate.StageNotReady)))

src/cmd/run.go

@@ -1,7 +1,7 @@
 package cmd
 
 import (
-	"github.com/akyaiy/GoSally-mvp/hooks"
+	"github.com/akyaiy/GoSally-mvp/src/hooks"
 	"github.com/spf13/cobra"
 )
 
@@ -11,6 +11,7 @@ var runCmd = &cobra.Command{
 	Short:   "Run node normally",
 	Long: `
 "run" starts the node with settings depending on the configuration file`,
+	// hooks.Run essentially the heart of the program
 	Run: hooks.Run,
 }
 

src/cmd/version.go

@@ -4,7 +4,8 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/sv1"
 	"github.com/spf13/cobra"
 )
 
@@ -13,7 +14,8 @@ var verCmd = &cobra.Command{
 	Aliases: []string{"ver", "v"},
 	Short:   "Return node version",
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Printf("GoSally node: %s\n", config.NodeVersion)
+		fmt.Printf("Go Sally version: %s\n", config.NodeVersion)
+		fmt.Printf("sv1 version: %s\n", sv1.SV1Version)
 		fmt.Printf("Go version: %s\n", runtime.Version())
 		fmt.Printf("Go OS/Arch: %s/%s\n", runtime.GOOS, runtime.GOARCH)
 	},

src/go.mod

@@ -1,4 +1,4 @@
-module github.com/akyaiy/GoSally-mvp
+module github.com/akyaiy/GoSally-mvp/src
 
 go 1.24.4
 
@@ -19,6 +19,7 @@ require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+	github.com/golang-jwt/jwt/v5 v5.3.0
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect

src/go.sum

@@ -13,6 +13,8 @@ github.com/go-chi/cors v1.2.2 h1:Jmey33TE+b+rB7fT8MUy1u0I4L+NARQlK6LhzKPSyQE=
 github.com/go-chi/cors v1.2.2/go.mod h1:sSbTewc+6wYHBBCW7ytsFSn836hqM7JxpglAy2Vzc58=
 github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
 github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=

src/hooks/initial.go

@@ -18,16 +18,17 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/akyaiy/GoSally-mvp/internal/colors"
-	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
-	"github.com/akyaiy/GoSally-mvp/internal/core/run_manager"
-	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/logs"
+	"github.com/akyaiy/GoSally-mvp/src/internal/colors"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/run_manager"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/utils"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/logs"
 	"gopkg.in/ini.v1"
 )
 
+// The config composer needs to be in the global scope
 var Compositor *config.Compositor = config.NewCompositor()
 
 func InitGlobalLoggerHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
@@ -65,7 +66,8 @@ func InitConfigLoadHook(_ context.Context, cs *corestate.CoreState, x *app.AppX)
 	}
 }
 
-func InitUUUDHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+// The hook reads or prepares a persistent uuid for the node
+func InitUUIDHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
 	uuid32, err := corestate.GetNodeUUID(filepath.Join(cs.MetaDir, "uuid"))
 	if errors.Is(err, fs.ErrNotExist) {
 		if err := corestate.SetNodeUUID(filepath.Join(cs.NodePath, cs.MetaDir, cs.UUID32DirName)); err != nil {
@@ -80,8 +82,11 @@ func InitUUUDHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
 		x.Log.Fatalf("uuid load error: %s", err)
 	}
 	cs.UUID32 = uuid32
+	corestate.NODE_UUID = uuid32
 }
 
+// The hook is responsible for checking the initialization stage
+// and restarting in some cases
 func InitRuntimeHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
 	if *x.Config.Env.ParentStagePID != os.Getpid() {
 		// still pre-init stage
@@ -133,6 +138,8 @@ func InitRuntimeHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
 }
 
 // post-init stage
+// The hook creates a run.lock file, which contains information
+// about the process and the node, in the runtime directory.
 func InitRunlockHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
 	NodeApp.Fallback(func(ctx context.Context, cs *corestate.CoreState, x *app.AppX) {
 		x.Log.Println("Cleaning up...")
@@ -185,6 +192,8 @@ func InitRunlockHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
 	}
 }
 
+// The hook reads the configuration and replaces special expressions
+// (%tmp% and so on) in string fields with the required data.
 func InitConfigReplHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
 	if !slices.Contains(*x.Config.Conf.DisableWarnings, "--WNonStdTmpDir") && os.TempDir() != "/tmp" {
 		x.Log.Printf("%s: %s", colors.PrintWarn(), "Non-standard value specified for temporary directory")
@@ -209,6 +218,8 @@ func InitConfigReplHook(_ context.Context, cs *corestate.CoreState, x *app.AppX)
 	}
 }
 
+// The hook is responsible for outputting the
+// final config and asking for confirmation.
 func InitConfigPrintHook(ctx context.Context, cs *corestate.CoreState, x *app.AppX) {
 	if *x.Config.Conf.Node.ShowConfig {
 		fmt.Printf("Configuration from %s:\n", x.Config.CMDLine.Run.ConfigPath)
@@ -223,7 +234,11 @@ func InitConfigPrintHook(ctx context.Context, cs *corestate.CoreState, x *app.Ap
 		}
 	}
 
+	if *x.Config.Conf.Node.Name == "noname" {
+		x.Log.Printf("Starting node")
+	} else {
 		x.Log.Printf("Starting \"%s\" node", *x.Config.Conf.Node.Name)
+	}
 }
 
 func InitSLogHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
@@ -239,6 +254,8 @@ func InitSLogHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
 	*x.SLog = *newSlog
 }
 
+// The method goes through the entire config structure through
+// reflection and replaces string fields with the required ones.
 func processConfig(conf any, replacements map[string]any) error {
 	val := reflect.ValueOf(conf)
 	if val.Kind() == reflect.Ptr {

src/hooks/run.go

@@ -11,17 +11,18 @@ import (
 	"regexp"
 	"time"
 
-	"github.com/akyaiy/GoSally-mvp/internal/colors"
-	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
-	"github.com/akyaiy/GoSally-mvp/internal/core/run_manager"
-	"github.com/akyaiy/GoSally-mvp/internal/core/update"
-	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/logs"
-	"github.com/akyaiy/GoSally-mvp/internal/server/gateway"
-	"github.com/akyaiy/GoSally-mvp/internal/server/session"
-	"github.com/akyaiy/GoSally-mvp/internal/server/sv1"
+	"github.com/akyaiy/GoSally-mvp/src/internal/colors"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/run_manager"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/update"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/utils"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/logs"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/gateway"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/session"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/sv1"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/sv2"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/cors"
 	"github.com/spf13/cobra"
@@ -29,11 +30,12 @@ import (
 )
 
 var NodeApp = app.New()
+var AllowedCmdPattern = `^[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*$`
 
 func Run(cmd *cobra.Command, args []string) {
 	NodeApp.InitialHooks(
 		InitGlobalLoggerHook, InitCorestateHook, InitConfigLoadHook,
-		InitUUUDHook, InitRuntimeHook, InitRunlockHook,
+		InitUUIDHook, InitRuntimeHook, InitRunlockHook,
 		InitConfigReplHook, InitConfigPrintHook, InitSLogHook,
 	)
 
@@ -60,17 +62,24 @@ func RunHook(ctx context.Context, cs *corestate.CoreState, x *app.AppX) error {
 	serverv1 := sv1.InitV1Server(&sv1.HandlerV1InitStruct{
 		X:          x,
 		CS:         cs,
-		AllowedCmd: regexp.MustCompile(`^[a-zA-Z0-9]+(>[a-zA-Z0-9]+)*$`),
+		AllowedCmd: regexp.MustCompile(AllowedCmdPattern),
 		Ver:        "v1",
 	})
 
+	sv2 := sv2.InitServer(&sv2.HandlerInitStruct{
+		X:          x,
+		CS:         cs,
+		AllowedCmd: regexp.MustCompile(AllowedCmdPattern),
+		Ver:        "v2",
+	})
+
 	session_manager := session.New(*x.Config.Conf.HTTPServer.SessionTTL)
 
 	s := gateway.InitGateway(&gateway.GatewayServerInit{
 		SM: session_manager,
 		CS: cs,
 		X:  x,
-	}, serverv1)
+	}, serverv1, sv2)
 
 	r := chi.NewRouter()
 	r.Use(cors.Handler(cors.Options{

src/internal/core/corestate/corestate.go

@@ -1,5 +1,7 @@
 package corestate
 
+var NODE_UUID string
+
 type Stage string
 
 const (

src/internal/core/corestate/node_uuid.go

@@ -7,8 +7,8 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/utils"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/config"
 )
 
 // GetNodeUUID outputs the correct uuid from the file at the path specified in the arguments.

src/internal/core/run_manager/run_manager.go

@@ -6,7 +6,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/utils"
 )
 
 type RunManagerContract interface {

src/internal/core/update/update.go

@@ -13,10 +13,10 @@ import (
 	"strings"
 	"syscall"
 
-	"github.com/akyaiy/GoSally-mvp/internal/core/run_manager"
-	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/run_manager"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/utils"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/config"
 	"golang.org/x/net/context"
 )
 

src/internal/core/utils/uuid.go

@@ -5,7 +5,7 @@ import (
 	"encoding/hex"
 	"errors"
 
-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/config"
 )
 
 func NewUUIDRaw(length int) ([]byte, error) {

src/internal/engine/app/app.go

@@ -9,8 +9,8 @@ import (
 	"sync"
 	"syscall"
 
-	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/config"
 )
 
 type AppContract interface {

src/internal/engine/config/compositor.go

@@ -61,6 +61,7 @@ func (c *Compositor) LoadConf(path string) error {
 	v.SetDefault("log.json_format", "false")
 	v.SetDefault("log.level", "info")
 	v.SetDefault("log.output", "%2%")
+	v.SetDefault("disable_warnings", []string{})
 
 	if err := v.ReadInConfig(); err != nil {
 		return fmt.Errorf("error reading config: %w", err)

src/internal/engine/config/print.go

@@ -5,7 +5,7 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/akyaiy/GoSally-mvp/internal/colors"
+	"github.com/akyaiy/GoSally-mvp/src/internal/colors"
 )
 
 func (c *Compositor) Print(v any) {

src/internal/engine/logs/logger.go

@@ -11,7 +11,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/config"
 	"gopkg.in/natefinch/lumberjack.v2"
 )
 

src/internal/engine/lua/handler.go

@@ -0,0 +1 @@
+package lua

src/internal/engine/lua/pool.go

@@ -0,0 +1,35 @@
+package lua
+
+import (
+	"sync"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+type LuaPool struct {
+	pool sync.Pool
+}
+
+func NewLuaPool() *LuaPool {
+	return &LuaPool{
+		pool: sync.Pool{
+			New: func() any {
+				L := lua.NewState()
+
+				return L
+			},
+		},
+	}
+}
+
+func (lp *LuaPool) Get() *lua.LState {
+	return lp.pool.Get().(*lua.LState)
+}
+
+func (lp *LuaPool) Put(L *lua.LState) {
+	L.Close()
+
+	newL := lua.NewState()
+
+	lp.pool.Put(newL)
+}

src/internal/engine/lua/types.go

@@ -0,0 +1,25 @@
+package lua
+
+import (
+	"net/http"
+
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/rpc"
+)
+
+type LuaEngineDeps struct {
+	HttpRequest    *http.Request
+	JSONRPCRequest *rpc.RPCRequest
+	SessionUUID    string
+	ScriptPath     string
+}
+
+type LuaEngineContract interface {
+	Handle(deps *LuaEngineDeps) *rpc.RPCResponse
+}
+
+type LuaEngine struct {
+	x  *app.AppX
+	cs *corestate.CoreState
+}

src/internal/server/gateway/general_types.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"net/http"
 
-	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
-	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
-	"github.com/akyaiy/GoSally-mvp/internal/server/session"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/rpc"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/session"
 )
 
 // serversApiVer is a type alias for string, used to represent API version strings in the GeneralServer.

src/internal/server/gateway/init.go

@@ -3,9 +3,9 @@ package gateway
 import (
 	"errors"
 
-	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
-	"github.com/akyaiy/GoSally-mvp/internal/server/session"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/session"
 )
 
 // GeneralServerInit structure only for initialization general server.

src/internal/server/gateway/route.go

@@ -8,8 +8,8 @@ import (
 	"net/http"
 	"sync"
 
-	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
-	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/utils"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/rpc"
 	"github.com/google/uuid"
 )
 
@@ -20,18 +20,14 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 	sessionUUID := r.Header.Get("X-Session-UUID")
 	if sessionUUID == "" {
 		sessionUUID = uuid.New().String()
+
 	}
 	gs.x.SLog.Debug("new request", slog.String("session-uuid", sessionUUID), slog.Group("connection", slog.String("ip", r.RemoteAddr)))
 
 	w.Header().Set("X-Session-UUID", sessionUUID)
 	if !gs.sm.Add(sessionUUID) {
 		gs.x.SLog.Debug("session is busy", slog.String("session-uuid", sessionUUID))
-		rpc.WriteError(w, &rpc.RPCResponse{
-			Error: map[string]any{
-				"code":    rpc.ErrSessionIsBusy,
-				"message": rpc.ErrSessionIsBusyS,
-			},
-		})
+		rpc.WriteError(w, rpc.NewError(rpc.ErrSessionIsBusy, rpc.ErrSessionIsBusyS, nil, nil))
 		return
 	}
 	defer gs.sm.Delete(sessionUUID)
@@ -40,14 +36,7 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		gs.x.SLog.Debug("failed to read body", slog.String("err", err.Error()))
 		w.WriteHeader(http.StatusBadRequest)
-		rpc.WriteError(w, &rpc.RPCResponse{
-			JSONRPC: rpc.JSONRPCVersion,
-			ID:      nil,
-			Error: map[string]any{
-				"code":    rpc.ErrInternalError,
-				"message": rpc.ErrInternalErrorS,
-			},
-		})
+		rpc.WriteError(w, rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, nil))
 		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInternalErrorS))
 		return
 	}
@@ -60,14 +49,7 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 		if err := json.Unmarshal(body, &single); err != nil {
 			gs.x.SLog.Debug("failed to parse json", slog.String("err", err.Error()))
 			w.WriteHeader(http.StatusBadRequest)
-			rpc.WriteError(w, &rpc.RPCResponse{
-				JSONRPC: rpc.JSONRPCVersion,
-				ID:      nil,
-				Error: map[string]any{
-					"code":    rpc.ErrParseError,
-					"message": rpc.ErrParseErrorS,
-				},
-			})
+			rpc.WriteError(w, rpc.NewError(rpc.ErrParseError, rpc.ErrParseErrorS, nil, nil))
 			gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrParseErrorS))
 			return
 		}

src/internal/server/rpc/definition.go

@@ -13,8 +13,16 @@ type RPCRequest struct {
 type RPCResponse struct {
 	JSONRPC string           `json:"jsonrpc"`
 	ID      *json.RawMessage `json:"id"`
-	Result  any              `json:"result,omitempty"`
-	Error   any              `json:"error,omitempty"`
+	Result  any              `json:"result,omitzero"`
+	Error   any              `json:"error,omitzero"`
+	Data    *RPCData         `json:"data,omitzero"`
+}
+
+type RPCData struct {
+	ResponsibleNode string `json:"responsible-node,omitempty"`
+	Salt            string `json:"salt,omitempty"`
+	Checksum        string `json:"checksum-md5,omitempty"`
+	NewSessionUUID  string `json:"new-session-uuid,omitempty"`
 }
 
 const (

src/internal/server/rpc/responsers.go

@@ -0,0 +1,60 @@
+package rpc
+
+import (
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/google/uuid"
+)
+
+func generateChecksum(result any) string {
+	if result == nil {
+		return ""
+	}
+	data, err := json.Marshal(result)
+	if err != nil {
+		return ""
+	}
+	return fmt.Sprintf("%x", md5.Sum(data))
+}
+
+func generateSalt() string {
+	return uuid.NewString()
+}
+
+func GetData(data any) *RPCData {
+	return &RPCData{
+		Salt:            generateSalt(),
+		ResponsibleNode: corestate.NODE_UUID,
+		Checksum:        generateChecksum(data),
+	}
+}
+
+func NewError(code int, message string, data any, id *json.RawMessage) *RPCResponse {
+	Error := make(map[string]any)
+	Error = map[string]any{
+		"code":    code,
+		"message": message,
+	}
+	if data != nil {
+		Error["data"] = data
+	}
+
+	return &RPCResponse{
+		JSONRPC: JSONRPCVersion,
+		ID:      id,
+		Error:   Error,
+		Data:    GetData(Error),
+	}
+}
+
+func NewResponse(result any, id *json.RawMessage) *RPCResponse {
+	return &RPCResponse{
+		JSONRPC: JSONRPCVersion,
+		ID:      id,
+		Result:  result,
+		Data:    GetData(result),
+	}
+}

src/internal/server/sv1/db_sqlite.go

@@ -44,7 +44,7 @@ func getDBMutex(dbPath string) *sync.RWMutex {
 	return mtx
 }
 
-func loadDBMod(llog *slog.Logger) func(*lua.LState) int {
+func loadDBMod(llog *slog.Logger, sid string) func(*lua.LState) int {
 	return func(L *lua.LState) int {
 		llog.Debug("import module db-sqlite")
 		dbMod := L.NewTable()
@@ -82,10 +82,11 @@ func loadDBMod(llog *slog.Logger) func(*lua.LState) int {
 		L.SetField(mt, "__index", L.SetFuncs(L.NewTable(), map[string]lua.LGFunction{
 			"exec":      dbExec,
 			"query":     dbQuery,
+			"query_row": dbQueryRow,
 			"close":     dbClose,
 		}))
 
-		L.SetField(dbMod, "__gosally_internal", lua.LString("0"))
+		L.SetField(dbMod, "__seed", lua.LString(sid))
 		L.Push(dbMod)
 		return 1
 	}
@@ -162,7 +163,7 @@ func dbExec(L *lua.LState) int {
 	var result lua.LValue = lua.LNil
 	var errorMsg lua.LValue = lua.LNil
 
-	L.SetField(ctx, "wait", L.NewFunction(func(lL *lua.LState) int {
+	L.SetField(ctx, "wait", L.NewFunction(func(L *lua.LState) int {
 		res := <-resCh
 		L.SetField(ctx, "done", lua.LBool(true))
 
@@ -175,35 +176,35 @@ func dbExec(L *lua.LState) int {
 		}
 
 		if res.err != nil {
-			lL.Push(lua.LNil)
-			lL.Push(lua.LString(res.err.Error()))
+			L.Push(lua.LNil)
+			L.Push(lua.LString(res.err.Error()))
 			return 2
 		}
-		lL.Push(lua.LNumber(res.rowsAffected))
-		lL.Push(lua.LNil)
+		L.Push(lua.LNumber(res.rowsAffected))
+		L.Push(lua.LNil)
 		return 2
 	}))
 
-	L.SetField(ctx, "check", L.NewFunction(func(lL *lua.LState) int {
+	L.SetField(ctx, "check", L.NewFunction(func(L *lua.LState) int {
 		select {
 		case res := <-resCh:
-			lL.SetField(ctx, "done", lua.LBool(true))
+			L.SetField(ctx, "done", lua.LBool(true))
 			if res.err != nil {
 				errorMsg = lua.LString(res.err.Error())
 				result = lua.LNil
-				lL.Push(lua.LNil)
-				lL.Push(lua.LString(res.err.Error()))
+				L.Push(lua.LNil)
+				L.Push(lua.LString(res.err.Error()))
 				return 2
 			} else {
 				result = lua.LNumber(res.rowsAffected)
 				errorMsg = lua.LNil
-				lL.Push(lua.LNumber(res.rowsAffected))
-				lL.Push(lua.LNil)
+				L.Push(lua.LNumber(res.rowsAffected))
+				L.Push(lua.LNil)
 				return 2
 			}
 		default:
-			lL.Push(result)
-			lL.Push(errorMsg)
+			L.Push(result)
+			L.Push(errorMsg)
 			return 2
 		}
 	}))
@@ -213,6 +214,102 @@ func dbExec(L *lua.LState) int {
 	return 2
 }
 
+func dbQueryRow(L *lua.LState) int {
+	ud := L.CheckUserData(1)
+	conn, ok := ud.Value.(*DBConnection)
+	if !ok {
+		L.Push(lua.LNil)
+		L.Push(lua.LString("invalid database connection"))
+		return 2
+	}
+
+	query := L.CheckString(2)
+
+	var args []any
+	if L.GetTop() >= 3 {
+		params := L.CheckTable(3)
+		params.ForEach(func(k lua.LValue, v lua.LValue) {
+			args = append(args, ConvertLuaTypesToGolang(v))
+		})
+	}
+
+	if conn.log {
+		conn.logger.Info("DB QueryRow",
+			slog.String("query", query),
+			slog.Any("params", args))
+	}
+
+	mtx := getDBMutex(conn.dbPath)
+	mtx.RLock()
+	defer mtx.RUnlock()
+
+	db, err := sql.Open("sqlite", conn.dbPath+"?_busy_timeout=5000&_journal_mode=WAL&_sync=NORMAL&_cache_size=-10000")
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+	defer db.Close()
+
+	row := db.QueryRow(query, args...)
+
+	columns := []string{}
+	stmt, err := db.Prepare(query)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("prepare failed: %v", err)))
+		return 2
+	}
+	defer stmt.Close()
+	rows, err := stmt.Query(args...)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("query failed: %v", err)))
+		return 2
+	}
+	defer rows.Close()
+	cols, err := rows.Columns()
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("get columns failed: %v", err)))
+		return 2
+	}
+	for _, c := range cols {
+		columns = append(columns, c)
+	}
+
+	colCount := len(columns)
+	values := make([]any, colCount)
+	valuePtrs := make([]any, colCount)
+	for i := range columns {
+		valuePtrs[i] = &values[i]
+	}
+
+	err = row.Scan(valuePtrs...)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			L.Push(lua.LNil)
+			return 1
+		}
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("scan failed: %v", err)))
+		return 2
+	}
+
+	rowTable := L.NewTable()
+	for i, col := range columns {
+		val := values[i]
+		if val == nil {
+			L.SetField(rowTable, col, lua.LNil)
+		} else {
+			L.SetField(rowTable, col, ConvertGolangTypesToLua(L, val))
+		}
+	}
+
+	L.Push(rowTable)
+	return 1
+}
+
 func dbQuery(L *lua.LState) int {
 	ud := L.CheckUserData(1)
 	conn, ok := ud.Value.(*DBConnection)

src/internal/server/sv1/handle.go

@@ -5,7 +5,7 @@ import (
 	"log/slog"
 	"net/http"
 
-	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/rpc"
 )
 
 func (h *HandlerV1) Handle(_ context.Context, sid string, r *http.Request, req *rpc.RPCRequest) *rpc.RPCResponse {
@@ -24,6 +24,16 @@ func (h *HandlerV1) Handle(_ context.Context, sid string, r *http.Request, req *
 			return rpc.NewError(rpc.ErrMethodNotFound, rpc.ErrMethodNotFoundS, nil, req.ID)
 		}
 	}
-
+	switch req.Params.(type) {
+	case map[string]any, []any, nil:
 		return h.handleLUA(sid, r, req, method)
+	default:
+		// JSON-RPC 2.0 Specification:
+		// https://www.jsonrpc.org/specification#parameter_structures
+		//
+		// "params" MUST be either an *array* or an *object* if included.
+		// Any other type (e.g., a number, string, or boolean) is INVALID.
+		h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInvalidParamsS))
+		return rpc.NewError(rpc.ErrInvalidParams, rpc.ErrInvalidParamsS, nil, req.ID)
+	}
 }

src/internal/server/sv1/jwt.go

@@ -0,0 +1,86 @@
+package sv1
+
+import (
+	"log/slog"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	lua "github.com/yuin/gopher-lua"
+)
+
+func loadJWTMod(llog *slog.Logger, sid string) func(*lua.LState) int {
+	return func(L *lua.LState) int {
+		llog.Debug("import module jwt")
+		jwtMod := L.NewTable()
+
+		L.SetField(jwtMod, "encode", L.NewFunction(jwtEncode))
+		L.SetField(jwtMod, "decode", L.NewFunction(jwtDecode))
+
+		L.SetField(jwtMod, "__seed", lua.LString(sid))
+		L.Push(jwtMod)
+		return 1
+	}
+}
+
+func jwtEncode(L *lua.LState) int {
+	payloadTbl := L.CheckTable(1)
+	secret := L.GetField(payloadTbl, "secret").String()
+	payload := L.GetField(payloadTbl, "payload").(*lua.LTable)
+	expiresIn := L.GetField(payloadTbl, "expires_in")
+	expDuration := time.Hour
+
+	if expiresIn.Type() == lua.LTNumber {
+		floatVal := ConvertLuaTypesToGolang(expiresIn).(float64)
+		expDuration = time.Duration(floatVal) * time.Second
+	}
+
+	claims := jwt.MapClaims{}
+	payload.ForEach(func(key, value lua.LValue) {
+		claims[key.String()] = ConvertLuaTypesToGolang(value)
+	})
+	claims["iat"] = time.Now().Unix()
+	claims["exp"] = time.Now().Add(expDuration).Unix()
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	signedToken, err := token.SignedString([]byte(secret))
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+
+	L.Push(lua.LString(signedToken))
+	return 1
+}
+
+func jwtDecode(L *lua.LState) int {
+	tokenString := L.CheckString(1)
+	optsTbl := L.OptTable(2, L.NewTable())
+	secret := L.GetField(optsTbl, "secret").String()
+
+	token, err := jwt.Parse(tokenString, func(t *jwt.Token) (any, error) {
+		return []byte(secret), nil
+	})
+
+	if err != nil || !token.Valid {
+		L.Push(lua.LString("Invalid token: " + err.Error()))
+		L.Push(lua.LNil)
+		return 2
+	}
+
+	claims, ok := token.Claims.(jwt.MapClaims)
+	if !ok {
+		L.Push(lua.LString("Invalid claims"))
+		L.Push(lua.LNil)
+		return 2
+	}
+
+	luaTable := L.NewTable()
+	for k, v := range claims {
+		luaTable.RawSetString(k, ConvertGolangTypesToLua(L, v))
+	}
+
+	L.Push(lua.LNil)
+	L.Push(luaTable)
+	return 2
+}

src/internal/server/sv1/lua_handler.go

@@ -0,0 +1,636 @@
+package sv1
+
+// TODO: make a lua state pool using sync.Pool
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"log/slog"
+	"math/rand/v2"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"golang.org/x/crypto/bcrypt"
+
+	"github.com/akyaiy/GoSally-mvp/src/internal/colors"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/rpc"
+	lua "github.com/yuin/gopher-lua"
+	_ "modernc.org/sqlite"
+)
+
+func addInitiatorHeaders(sid string, req *http.Request, headers http.Header) {
+	clientIP := req.RemoteAddr
+	if forwardedFor := req.Header.Get("X-Forwarded-For"); forwardedFor != "" {
+		clientIP = forwardedFor
+	}
+	headers.Set("X-Initiator-IP", clientIP)
+	headers.Set("X-Session-UUID", sid)
+	headers.Set("X-Initiator-Host", req.Host)
+	headers.Set("X-Initiator-User-Agent", req.UserAgent())
+	headers.Set("X-Initiator-Referer", req.Referer())
+}
+
+// A small reminder: this code is only at the MVP stage,
+// and some parts of the code may cause shock from the
+// incompetence of the developer. But, in the end,
+// this code is just an idea. If there is a desire to
+// contribute to the development of the code,
+// I will be only glad.
+// TODO: make this huge function more harmonious by dividing responsibilities
+func (h *HandlerV1) handleLUA(sid string, r *http.Request, req *rpc.RPCRequest, path string) *rpc.RPCResponse {
+	var __exit = -1
+
+	llog := h.x.SLog.With(slog.String("session-id", sid))
+	llog.Debug("handling LUA")
+	L := lua.NewState()
+	defer L.Close()
+
+	osMod := L.GetGlobal("os").(*lua.LTable)
+	L.SetField(osMod, "exit", lua.LNil)
+
+	ioMod := L.GetGlobal("io").(*lua.LTable)
+	for _, k := range []string{"write", "output", "flush", "read", "input"} {
+		ioMod.RawSetString(k, lua.LNil)
+	}
+	L.Env.RawSetString("print", lua.LNil)
+
+	for _, name := range []string{"stdout", "stderr", "stdin"} {
+		stream := ioMod.RawGetString(name)
+		if t, ok := stream.(*lua.LUserData); ok {
+			t.Metatable = lua.LNil
+		}
+	}
+
+	seed := rand.Int()
+
+	loadSessionMod := func(L *lua.LState) int {
+		llog.Debug("import module session", slog.String("script", path))
+		sessionMod := L.NewTable()
+		inTable := L.NewTable()
+		paramsTable := L.NewTable()
+		headersTable := L.NewTable()
+
+		fetchedHeadersTable := L.NewTable()
+		for k, v := range r.Header {
+			L.SetField(fetchedHeadersTable, k, ConvertGolangTypesToLua(L, v))
+		}
+
+		headersGetter := L.NewFunction(func(L *lua.LState) int {
+			path := L.OptString(1, "")
+			def := L.Get(2)
+
+			get := func(path string) lua.LValue {
+				if path == "" {
+					return fetchedHeadersTable
+				}
+				fetched := r.Header.Get(path)
+				if fetched == "" {
+					return lua.LNil
+				}
+				return lua.LString(fetched)
+			}
+			val := get(path)
+			if val == lua.LNil && def != lua.LNil {
+				L.Push(def)
+			} else {
+				L.Push(val)
+			}
+			return 1
+		})
+
+		L.SetField(headersTable, "__fetched", fetchedHeadersTable)
+
+		L.SetField(headersTable, "get", headersGetter)
+		L.SetField(inTable, "headers", headersTable)
+
+		fetchedParamsTable := L.NewTable()
+		switch params := req.Params.(type) {
+		case map[string]any:
+			for k, v := range params {
+				L.SetField(fetchedParamsTable, k, ConvertGolangTypesToLua(L, v))
+			}
+		case []any:
+			for i, v := range params {
+				fetchedParamsTable.RawSetInt(i+1, ConvertGolangTypesToLua(L, v))
+			}
+		}
+
+		paramsGetter := L.NewFunction(func(L *lua.LState) int {
+			path := L.OptString(1, "")
+			def := L.Get(2)
+
+			get := func(tbl *lua.LTable, path string) lua.LValue {
+				if path == "" {
+					return tbl
+				}
+				current := tbl
+				parts := strings.Split(path, ".")
+				size := len(parts)
+				for index, key := range parts {
+					val := current.RawGetString(key)
+					if tblVal, ok := val.(*lua.LTable); ok {
+						current = tblVal
+					} else {
+						if index == size-1 {
+							return val
+						}
+						return lua.LNil
+					}
+				}
+				return current
+			}
+
+			paramsTbl := L.GetField(paramsTable, "__fetched") //
+			val := get(paramsTbl.(*lua.LTable), path)         //
+			if val == lua.LNil && def != lua.LNil {
+				L.Push(def)
+			} else {
+				L.Push(val)
+			}
+			return 1
+		})
+		L.SetField(paramsTable, "__fetched", fetchedParamsTable)
+
+		L.SetField(paramsTable, "get", paramsGetter)
+		L.SetField(inTable, "params", paramsTable)
+
+		outTable := L.NewTable()
+		scriptDataTable := L.NewTable()
+		L.SetField(outTable, "__script_data", scriptDataTable)
+
+		L.SetField(inTable, "address", lua.LString(r.RemoteAddr))
+
+		L.SetField(sessionMod, "throw_error", L.NewFunction(func(L *lua.LState) int {
+			arg := L.Get(1)
+			var msg string
+			switch arg.Type() {
+			case lua.LTString:
+				msg = arg.String()
+			case lua.LTNumber:
+				msg = strconv.FormatFloat(float64(arg.(lua.LNumber)), 'f', -1, 64)
+			default:
+				L.ArgError(1, "expected string or number")
+				return 0
+			}
+
+			L.RaiseError("%s", msg)
+			return 0
+		}))
+
+		resTable := L.NewTable()
+		L.SetField(scriptDataTable, "result", resTable)
+		L.SetField(outTable, "send", L.NewFunction(func(L *lua.LState) int {
+			res := L.Get(1)
+
+			resFTable := scriptDataTable.RawGetString("result")
+			if resPTable, ok := res.(*lua.LTable); ok {
+				resPTable.ForEach(func(key, value lua.LValue) {
+					L.SetField(resFTable, key.String(), value)
+				})
+			} else {
+				L.SetField(scriptDataTable, "result", res)
+			}
+
+			__exit = 0
+			L.RaiseError("__successfull")
+			return 0
+		}))
+
+		L.SetField(outTable, "set", L.NewFunction(func(L *lua.LState) int {
+			res := L.Get(1)
+			if res == lua.LNil {
+				return 0
+			}
+
+			resFTable := scriptDataTable.RawGetString("result")
+			if resPTable, ok := res.(*lua.LTable); ok {
+				resPTable.ForEach(func(key, value lua.LValue) {
+					L.SetField(resFTable, key.String(), value)
+				})
+			} else {
+				L.SetField(scriptDataTable, "result", res)
+			}
+			return 0
+		}))
+
+		errTable := L.NewTable()
+		L.SetField(scriptDataTable, "error", errTable)
+		L.SetField(outTable, "send_error", L.NewFunction(func(L *lua.LState) int {
+			var params [3]lua.LValue
+			for i := range 3 {
+				params[i] = L.Get(i + 1)
+			}
+			if errTable, ok := scriptDataTable.RawGetString("error").(*lua.LTable); ok {
+				for _, v := range params {
+					switch v.Type() {
+					case lua.LTNumber:
+						if n, ok := v.(lua.LNumber); ok {
+							L.SetField(errTable, "code", n)
+						}
+					case lua.LTString:
+						if s, ok := v.(lua.LString); ok {
+							L.SetField(errTable, "message", s)
+						}
+					case lua.LTTable:
+						if tbl, ok := v.(*lua.LTable); ok {
+							L.SetField(errTable, "data", tbl)
+						}
+					}
+				}
+			}
+
+			__exit = 1
+			L.RaiseError("__unsuccessfull")
+			return 0
+		}))
+
+		L.SetField(outTable, "set_error", L.NewFunction(func(L *lua.LState) int {
+			var params [3]lua.LValue
+			for i := range 3 {
+				params[i] = L.Get(i + 1)
+			}
+			if errTable, ok := scriptDataTable.RawGetString("error").(*lua.LTable); ok {
+				for _, v := range params {
+					switch v.Type() {
+					case lua.LTNumber:
+						if n, ok := v.(lua.LNumber); ok {
+							L.SetField(errTable, "code", n)
+						}
+					case lua.LTString:
+						if s, ok := v.(lua.LString); ok {
+							L.SetField(errTable, "message", s)
+						}
+					case lua.LTTable:
+						if tbl, ok := v.(*lua.LTable); ok {
+							L.SetField(errTable, "data", tbl)
+						}
+					}
+				}
+			}
+			return 0
+		}))
+
+		L.SetField(sessionMod, "request", inTable)
+		L.SetField(sessionMod, "response", outTable)
+
+		L.SetField(sessionMod, "id", lua.LString(sid))
+
+		L.SetField(sessionMod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(sessionMod)
+		return 1
+	}
+
+	loadLogMod := func(L *lua.LState) int {
+		llog.Debug("import module log", slog.String("script", path))
+		logMod := L.NewTable()
+
+		logFuncs := map[string]func(string, ...any){
+			"info":  llog.Info,
+			"debug": llog.Debug,
+			"error": llog.Error,
+			"warn":  llog.Warn,
+		}
+
+		for name, logFunc := range logFuncs {
+			fun := logFunc
+			L.SetField(logMod, name, L.NewFunction(func(L *lua.LState) int {
+				msg := L.Get(1)
+				converted := ConvertLuaTypesToGolang(msg)
+				fun(fmt.Sprintf("the script says: %s", converted), slog.String("script", path))
+				return 0
+			}))
+		}
+
+		for _, fn := range []struct {
+			field string
+			pfunc func(string, ...any)
+			color func() string
+		}{
+			{"event", h.x.Log.Printf, nil},
+			{"event_error", h.x.Log.Printf, colors.PrintError},
+			{"event_warn", h.x.Log.Printf, colors.PrintWarn},
+		} {
+			L.SetField(logMod, fn.field, L.NewFunction(func(L *lua.LState) int {
+				msg := L.Get(1)
+				converted := ConvertLuaTypesToGolang(msg)
+				if fn.color != nil {
+					h.x.Log.Printf("%s: %s: %s", fn.color(), path, converted)
+				} else {
+					h.x.Log.Printf("%s: %s", path, converted)
+				}
+				return 0
+			}))
+		}
+
+		L.SetField(logMod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(logMod)
+		return 1
+	}
+
+	loadNetMod := func(L *lua.LState) int {
+		llog.Debug("import module net", slog.String("script", path))
+		netMod := L.NewTable()
+		netModhttp := L.NewTable()
+
+		L.SetField(netModhttp, "get_request", L.NewFunction(func(L *lua.LState) int {
+			logRequest := L.ToBool(1)
+			url := L.ToString(2)
+
+			req, err := http.NewRequest("GET", url, nil)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+
+			addInitiatorHeaders(sid, r, req.Header)
+
+			client := &http.Client{}
+			resp, err := client.Do(req)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+			defer resp.Body.Close()
+
+			body, err := io.ReadAll(resp.Body)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+
+			if logRequest {
+				llog.Info("HTTP GET request",
+					slog.String("script", path),
+					slog.String("url", url),
+					slog.Int("status", resp.StatusCode),
+					slog.String("status_text", resp.Status),
+					slog.String("initiator_ip", req.Header.Get("X-Initiator-IP")),
+				)
+			}
+
+			result := L.NewTable()
+			L.SetField(result, "status", lua.LNumber(resp.StatusCode))
+			L.SetField(result, "status_text", lua.LString(resp.Status))
+			L.SetField(result, "body", lua.LString(body))
+			L.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
+
+			headers := L.NewTable()
+			for k, v := range resp.Header {
+				L.SetField(headers, k, ConvertGolangTypesToLua(L, v))
+			}
+			L.SetField(result, "headers", headers)
+
+			L.Push(result)
+			return 1
+		}))
+
+		L.SetField(netModhttp, "post_request", L.NewFunction(func(L *lua.LState) int {
+			logRequest := L.ToBool(1)
+			url := L.ToString(2)
+			contentType := L.ToString(3)
+			payload := L.ToString(4)
+
+			body := strings.NewReader(payload)
+
+			req, err := http.NewRequest("POST", url, body)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+
+			req.Header.Set("Content-Type", contentType)
+
+			addInitiatorHeaders(sid, r, req.Header)
+
+			client := &http.Client{}
+			resp, err := client.Do(req)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+			defer resp.Body.Close()
+
+			respBody, err := io.ReadAll(resp.Body)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+
+			if logRequest {
+				llog.Info("HTTP POST request",
+					slog.String("script", path),
+					slog.String("url", url),
+					slog.String("content_type", contentType),
+					slog.Int("status", resp.StatusCode),
+					slog.String("status_text", resp.Status),
+					slog.String("initiator_ip", req.Header.Get("X-Initiator-IP")),
+				)
+			}
+
+			result := L.NewTable()
+			L.SetField(result, "status", lua.LNumber(resp.StatusCode))
+			L.SetField(result, "status_text", lua.LString(resp.Status))
+			L.SetField(result, "body", lua.LString(respBody))
+			L.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
+
+			headers := L.NewTable()
+			for k, v := range resp.Header {
+				L.SetField(headers, k, ConvertGolangTypesToLua(L, v))
+			}
+			L.SetField(result, "headers", headers)
+
+			L.Push(result)
+			return 1
+		}))
+
+		L.SetField(netMod, "http", netModhttp)
+
+		L.SetField(netMod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(netMod)
+		return 1
+	}
+
+	loadCryptbcryptMod := func(L *lua.LState) int {
+		llog.Debug("import module crypt.bcrypt", slog.String("script", path))
+		bcryptMod := L.NewTable()
+
+		L.SetField(bcryptMod, "MinCost", lua.LNumber(bcrypt.MinCost))
+		L.SetField(bcryptMod, "MaxCost", lua.LNumber(bcrypt.MaxCost))
+		L.SetField(bcryptMod, "DefaultCost", lua.LNumber(bcrypt.DefaultCost))
+
+		L.SetField(bcryptMod, "generate", L.NewFunction(func(l *lua.LState) int {
+			password := ConvertLuaTypesToGolang(L.Get(1))
+			passwordStr, ok := password.(string)
+			if !ok {
+				L.Push(lua.LNil)
+				L.Push(lua.LString("error: password must be a string"))
+				return 2
+			}
+
+			cost := ConvertLuaTypesToGolang(L.Get(2))
+			costInt := bcrypt.DefaultCost
+			switch v := cost.(type) {
+			case int:
+				costInt = v
+			case float64:
+				costInt = int(v)
+			case nil:
+				// ok, use DefaultCost
+			default:
+				L.Push(lua.LNil)
+				L.Push(lua.LString("error: cost must be an integer"))
+				return 2
+			}
+
+			hashBytes, err := bcrypt.GenerateFromPassword([]byte(passwordStr), costInt)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString("error: " + err.Error()))
+				return 2
+			}
+
+			L.Push(lua.LString(string(hashBytes)))
+			L.Push(lua.LNil)
+			return 2
+		}))
+
+		L.SetField(bcryptMod, "compare", L.NewFunction(func(l *lua.LState) int {
+			hash := ConvertLuaTypesToGolang(L.Get(1))
+			hashStr, ok := hash.(string)
+			if !ok {
+				L.Push(lua.LString("error: hash must be a string"))
+				return 1
+			}
+			password := ConvertLuaTypesToGolang(L.Get(2))
+			passwordStr, ok := password.(string)
+			if !ok {
+				L.Push(lua.LString("error: password must be a string"))
+				return 1
+			}
+
+			err := bcrypt.CompareHashAndPassword([]byte(hashStr), []byte(passwordStr))
+			if err != nil {
+				L.Push(lua.LFalse)
+				return 1
+			}
+			L.Push(lua.LTrue)
+			return 1
+		}))
+
+		L.SetField(bcryptMod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(bcryptMod)
+		return 1
+	}
+
+	loadCryptbsha256Mod := func(L *lua.LState) int {
+		llog.Debug("import module crypt.sha256", slog.String("script", path))
+		sha265mod := L.NewTable()
+
+		L.SetField(sha265mod, "hash", L.NewFunction(func(l *lua.LState) int {
+			data := ConvertLuaTypesToGolang(L.Get(1))
+			var dataStr = fmt.Sprint(data)
+
+			hash := sha256.Sum256([]byte(dataStr))
+
+			L.Push(lua.LString(hex.EncodeToString(hash[:])))
+			L.Push(lua.LNil)
+			return 2
+		}))
+
+		L.SetField(sha265mod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(sha265mod)
+		return 1
+	}
+
+	L.PreloadModule("internal.session", loadSessionMod)
+	L.PreloadModule("internal.log", loadLogMod)
+	L.PreloadModule("internal.net", loadNetMod)
+	L.PreloadModule("internal.database.sqlite", loadDBMod(llog, fmt.Sprint(seed)))
+	L.PreloadModule("internal.crypt.bcrypt", loadCryptbcryptMod)
+	L.PreloadModule("internal.crypt.sha256", loadCryptbsha256Mod)
+	L.PreloadModule("internal.crypt.jwt", loadJWTMod(llog, fmt.Sprint(seed)))
+
+	llog.Debug("preparing environment")
+	prep := filepath.Join(*h.x.Config.Conf.Node.ComDir, "_prepare.lua")
+	if _, err := os.Stat(prep); err == nil {
+		if err := L.DoFile(prep); err != nil {
+			llog.Error("script error", slog.String("script", path), slog.String("error", err.Error()))
+			return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+		}
+	}
+	llog.Debug("executing script", slog.String("script", path))
+	err := L.DoFile(path)
+	if err != nil && __exit != 0 && __exit != 1 {
+		llog.Error("script error", slog.String("script", path), slog.String("error", err.Error()))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	pkg := L.GetGlobal("package")
+	pkgTbl, ok := pkg.(*lua.LTable)
+	if !ok {
+		llog.Error("script error", slog.String("script", path), slog.String("error", "package not found"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	loaded := pkgTbl.RawGetString("loaded")
+	loadedTbl, ok := loaded.(*lua.LTable)
+	if !ok {
+		llog.Error("script error", slog.String("script", path), slog.String("error", "package.loaded not found"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	sessionVal := loadedTbl.RawGetString("internal.session")
+	sessionTbl, ok := sessionVal.(*lua.LTable)
+	if !ok {
+		return rpc.NewResponse(nil, req.ID)
+	}
+
+	tag := sessionTbl.RawGetString("__seed")
+	if tag.Type() != lua.LTString || tag.String() != fmt.Sprint(seed) {
+		llog.Debug("stock session module is not imported: wrong seed", slog.String("script", path))
+		return rpc.NewResponse(nil, req.ID)
+	}
+
+	outVal := sessionTbl.RawGetString("response")
+	outTbl, ok := outVal.(*lua.LTable)
+	if !ok {
+		llog.Error("script error", slog.String("script", path), slog.String("error", "response is not a table"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	if scriptDataTable, ok := outTbl.RawGetString("__script_data").(*lua.LTable); ok {
+		switch __exit {
+		case 1:
+			if errTbl, ok := scriptDataTable.RawGetString("error").(*lua.LTable); ok {
+				llog.Debug("catch error table", slog.String("script", path))
+				code := rpc.ErrInternalError
+				message := rpc.ErrInternalErrorS
+				if c := errTbl.RawGetString("code"); c.Type() == lua.LTNumber {
+					code = int(c.(lua.LNumber))
+				}
+				if msg := errTbl.RawGetString("message"); msg.Type() == lua.LTString {
+					message = msg.String()
+				}
+				data := ConvertLuaTypesToGolang(errTbl.RawGetString("data"))
+				llog.Error("the script terminated with an error", slog.Int("code", code), slog.String("message", message), slog.Any("data", data))
+				return rpc.NewError(code, message, data, req.ID)
+			}
+			return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+		case 0:
+			resVal := ConvertLuaTypesToGolang(scriptDataTable.RawGetString("result"))
+			return rpc.NewResponse(resVal, req.ID)
+		}
+	}
+	return rpc.NewResponse(nil, req.ID)
+}

src/internal/server/sv1/lua_types.go

@@ -0,0 +1,126 @@
+package sv1
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+func ConvertLuaTypesToGolang(value lua.LValue) any {
+	switch value.Type() {
+	case lua.LTString:
+		return value.String()
+	case lua.LTNumber:
+		return float64(value.(lua.LNumber))
+	case lua.LTBool:
+		return bool(value.(lua.LBool))
+	case lua.LTTable:
+		tbl := value.(*lua.LTable)
+
+		maxIdx := 0
+		isArray := true
+
+		var isNumeric = false
+		tbl.ForEach(func(key, _ lua.LValue) {
+			var numKey lua.LValue
+			var ok bool
+			switch key.Type() {
+			case lua.LTString:
+				numKey, ok = key.(lua.LString)
+				if !ok {
+					isArray = false
+					return
+				}
+			case lua.LTNumber:
+				numKey, ok = key.(lua.LNumber)
+				if !ok {
+					isArray = false
+					return
+				}
+				isNumeric = true
+			}
+
+			num, err := strconv.Atoi(numKey.String())
+			if err != nil {
+				isArray = false
+				return
+			}
+			if num < 1 {
+				isArray = false
+				return
+			}
+			if num > maxIdx {
+				maxIdx = num
+			}
+		})
+
+		if isArray {
+			arr := make([]any, maxIdx)
+			if isNumeric {
+				for i := 1; i <= maxIdx; i++ {
+					arr[i-1] = ConvertLuaTypesToGolang(tbl.RawGetInt(i))
+				}
+			} else {
+				for i := 1; i <= maxIdx; i++ {
+					arr[i-1] = ConvertLuaTypesToGolang(tbl.RawGetString(strconv.Itoa(i)))
+				}
+			}
+			return arr
+		}
+		result := make(map[string]any)
+		tbl.ForEach(func(key, val lua.LValue) {
+			result[key.String()] = ConvertLuaTypesToGolang(val)
+		})
+		return result
+
+	case lua.LTNil:
+		return nil
+	default:
+		return value.String()
+	}
+}
+
+func ConvertGolangTypesToLua(L *lua.LState, val any) lua.LValue {
+	if val == nil {
+		return lua.LNil
+	}
+
+	rv := reflect.ValueOf(val)
+	rt := rv.Type()
+
+	switch rt.Kind() {
+	case reflect.String:
+		return lua.LString(rv.String())
+	case reflect.Bool:
+		return lua.LBool(rv.Bool())
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return lua.LNumber(rv.Int())
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return lua.LNumber(rv.Uint())
+	case reflect.Float32, reflect.Float64:
+		return lua.LNumber(rv.Float())
+
+	case reflect.Slice, reflect.Array:
+		tbl := L.NewTable()
+		for i := 0; i < rv.Len(); i++ {
+			tbl.RawSetInt(i+1, ConvertGolangTypesToLua(L, rv.Index(i).Interface()))
+		}
+		return tbl
+
+	case reflect.Map:
+		if rt.Key().Kind() == reflect.String {
+			tbl := L.NewTable()
+			for _, key := range rv.MapKeys() {
+				val := rv.MapIndex(key)
+				tbl.RawSetString(key.String(), ConvertGolangTypesToLua(L, val.Interface()))
+			}
+			return tbl
+		}
+
+	default:
+		return lua.LString(fmt.Sprintf("%v", val))
+	}
+	return lua.LString(fmt.Sprintf("%v", val))
+}

src/internal/server/sv1/path.go

@@ -6,15 +6,17 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/rpc"
 )
 
+var RPCMethodSeparator = "."
+
 func (h *HandlerV1) resolveMethodPath(method string) (string, error) {
 	if !h.allowedCmd.MatchString(method) {
 		return "", errors.New(rpc.ErrInvalidMethodFormatS)
 	}
 
-	parts := strings.Split(method, ">")
+	parts := strings.Split(method, RPCMethodSeparator)
 	relPath := filepath.Join(parts...) + ".lua"
 	fullPath := filepath.Join(*h.x.Config.Conf.Node.ComDir, relPath)
 

src/internal/server/sv1/server.go

@@ -5,10 +5,12 @@ package sv1
 import (
 	"regexp"
 
-	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/app"
 )
 
+var SV1Version = "v1"
+
 // HandlerV1InitStruct structure is only for initialization
 type HandlerV1InitStruct struct {
 	Ver        string

src/internal/server/sv2/handle.go

@@ -0,0 +1,12 @@
+package sv2
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/rpc"
+)
+
+func (h *Handler) Handle(_ context.Context, sid string, r *http.Request, req *rpc.RPCRequest) *rpc.RPCResponse {
+	return nil
+}

src/internal/server/sv2/server.go

@@ -0,0 +1,43 @@
+// SV2 works with binaries, scripts, and anything else that has access to stdin/stdout.
+// Modules run in a separate process and communicate via I/O.
+package sv2
+
+import (
+	"regexp"
+
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/src/internal/engine/app"
+)
+
+// HandlerV2InitStruct structure is only for initialization
+type HandlerInitStruct struct {
+	Ver        string
+	CS         *corestate.CoreState
+	X          *app.AppX
+	AllowedCmd *regexp.Regexp
+}
+
+type Handler struct {
+	cs *corestate.CoreState
+	x  *app.AppX
+
+	// allowedCmd and listAllowedCmd are regular expressions used to validate command names.
+	allowedCmd *regexp.Regexp
+
+	ver string
+}
+
+func InitServer(o *HandlerInitStruct) *Handler {
+	return &Handler{
+		cs:         o.CS,
+		x:          o.X,
+		allowedCmd: o.AllowedCmd,
+		ver:        o.Ver,
+	}
+}
+
+// GetVersion returns the API version of the HandlerV1, which is set during initialization.
+// This version is used to identify the API version in the request routing.
+func (h *Handler) GetVersion() string {
+	return h.ver
+}

src/main.go

@@ -0,0 +1,11 @@
+// Package main used only for calling cmd.Execute()
+package main
+
+import (
+	"github.com/akyaiy/GoSally-mvp/src/cmd"
+	_ "modernc.org/sqlite"
+)
+
+func main() {
+	cmd.Execute()
+}